| Methods Summary |
|---|
| private static boolean | contains(java.lang.String[] names, java.lang.String name)
for (int i = 0; i < names.length; i++) {
if (name.equalsIgnoreCase(names[i])) {
return true;
}
}
return false;
|
| public static javax.imageio.stream.ImageInputStream | createImageInputStream(java.lang.Object input)Returns an ImageInputStream that will take its
input from the given Object. The set of
ImageInputStreamSpis registered with the
IIORegistry class is queried and the first one
that is able to take input from the supplied object is used to
create the returned ImageInputStream. If no
suitable ImageInputStreamSpi exists,
null is returned.
The current cache settings from getUseCacheand
getCacheDirectory will be used to control caching.
if (input == null) {
throw new IllegalArgumentException("input == null!");
}
Iterator iter;
// Ensure category is present
try {
iter = theRegistry.getServiceProviders(ImageInputStreamSpi.class,
true);
} catch (IllegalArgumentException e) {
return null;
}
boolean usecache = getUseCache() && hasCachePermission();
while (iter.hasNext()) {
ImageInputStreamSpi spi = (ImageInputStreamSpi)iter.next();
if (spi.getInputClass().isInstance(input)) {
try {
return spi.createInputStreamInstance(input,
usecache,
getCacheDirectory());
} catch (IOException e) {
throw new IIOException("Can't create cache file!", e);
}
}
}
return null;
|
| public static javax.imageio.stream.ImageOutputStream | createImageOutputStream(java.lang.Object output)Returns an ImageOutputStream that will send its
output to the given Object. The set of
ImageOutputStreamSpis registered with the
IIORegistry class is queried and the first one
that is able to send output from the supplied object is used to
create the returned ImageOutputStream. If no
suitable ImageOutputStreamSpi exists,
null is returned.
The current cache settings from getUseCacheand
getCacheDirectory will be used to control caching.
if (output == null) {
throw new IllegalArgumentException("output == null!");
}
Iterator iter;
// Ensure category is present
try {
iter = theRegistry.getServiceProviders(ImageOutputStreamSpi.class,
true);
} catch (IllegalArgumentException e) {
return null;
}
boolean usecache = getUseCache() && hasCachePermission();
while (iter.hasNext()) {
ImageOutputStreamSpi spi = (ImageOutputStreamSpi)iter.next();
if (spi.getOutputClass().isInstance(output)) {
try {
return spi.createOutputStreamInstance(output,
usecache,
getCacheDirectory());
} catch (IOException e) {
throw new IIOException("Can't create cache file!", e);
}
}
}
return null;
|
| public static java.io.File | getCacheDirectory()Returns the current value set by
setCacheDirectory, or null if no
explicit setting has been made.
return getCacheInfo().getCacheDirectory();
|
| private static synchronized javax.imageio.ImageIO$CacheInfo | getCacheInfo()Returns the CacheInfo object associated with this
ThreadGroup.
AppContext context = AppContext.getAppContext();
CacheInfo info = (CacheInfo)context.get(CacheInfo.class);
if (info == null) {
info = new CacheInfo();
context.put(CacheInfo.class, info);
}
return info;
|
| public static javax.imageio.ImageReader | getImageReader(javax.imageio.ImageWriter writer)Returns an ImageReadercorresponding to the given
ImageWriter, if there is one, or null
if the plug-in for this ImageWriter does not
specify a corresponding ImageReader, or if the
given ImageWriter is not registered. This method
is provided principally for symmetry with
getImageWriter(ImageReader). Note that this
method returns the "preferred" reader, which is the first in
the list returned by
javax.imageio.spi.ImageWriterSpi.getImageReaderSpiNames().
if (writer == null) {
throw new IllegalArgumentException("writer == null!");
}
ImageWriterSpi writerSpi = writer.getOriginatingProvider();
if (writerSpi == null) {
Iterator writerSpiIter;
// Ensure category is present
try {
writerSpiIter =
theRegistry.getServiceProviders(ImageWriterSpi.class,
false);
} catch (IllegalArgumentException e) {
return null;
}
while (writerSpiIter.hasNext()) {
ImageWriterSpi temp = (ImageWriterSpi) writerSpiIter.next();
if (temp.isOwnWriter(writer)) {
writerSpi = temp;
break;
}
}
if (writerSpi == null) {
return null;
}
}
String[] readerNames = writerSpi.getImageReaderSpiNames();
if (readerNames == null) {
return null;
}
Class readerSpiClass = null;
try {
readerSpiClass = Class.forName(readerNames[0], true,
ClassLoader.getSystemClassLoader());
} catch (ClassNotFoundException e) {
return null;
}
ImageReaderSpi readerSpi = (ImageReaderSpi)
theRegistry.getServiceProviderByClass(readerSpiClass);
if (readerSpi == null) {
return null;
}
try {
return readerSpi.createReaderInstance();
} catch (IOException e) {
// Deregister the spi in this case, but only as a readerSpi
theRegistry.deregisterServiceProvider(readerSpi,
ImageReaderSpi.class);
return null;
}
|
| public static java.util.Iterator | getImageReaders(java.lang.Object input)Returns an Iterator containing all currently
registered ImageReaders that claim to be able to
decode the supplied Object, typically an
ImageInputStream.
The stream position is left at its prior position upon
exit from this method.
if (input == null) {
throw new IllegalArgumentException("input == null!");
}
Iterator iter;
// Ensure category is present
try {
iter = theRegistry.getServiceProviders(ImageReaderSpi.class,
new CanDecodeInputFilter(input),
true);
} catch (IllegalArgumentException e) {
return new HashSet().iterator();
}
return new ImageReaderIterator(iter);
|
| public static java.util.Iterator | getImageReadersByFormatName(java.lang.String formatName)Returns an Iterator containing all currently
registered ImageReaders that claim to be able to
decode the named format.
try {
readerFormatNamesMethod =
ImageReaderSpi.class.getMethod("getFormatNames");
readerFileSuffixesMethod =
ImageReaderSpi.class.getMethod("getFileSuffixes");
readerMIMETypesMethod =
ImageReaderSpi.class.getMethod("getMIMETypes");
writerFormatNamesMethod =
ImageWriterSpi.class.getMethod("getFormatNames");
writerFileSuffixesMethod =
ImageWriterSpi.class.getMethod("getFileSuffixes");
writerMIMETypesMethod =
ImageWriterSpi.class.getMethod("getMIMETypes");
} catch (NoSuchMethodException e) {
e.printStackTrace();
}
if (formatName == null) {
throw new IllegalArgumentException("formatName == null!");
}
Iterator iter;
// Ensure category is present
try {
iter = theRegistry.getServiceProviders(ImageReaderSpi.class,
new ContainsFilter(readerFormatNamesMethod,
formatName),
true);
} catch (IllegalArgumentException e) {
return new HashSet().iterator();
}
return new ImageReaderIterator(iter);
|
| public static java.util.Iterator | getImageReadersByMIMEType(java.lang.String MIMEType)Returns an Iterator containing all currently
registered ImageReaders that claim to be able to
decode files with the given MIME type.
if (MIMEType == null) {
throw new IllegalArgumentException("MIMEType == null!");
}
// Ensure category is present
Iterator iter;
try {
iter = theRegistry.getServiceProviders(ImageReaderSpi.class,
new ContainsFilter(readerMIMETypesMethod,
MIMEType),
true);
} catch (IllegalArgumentException e) {
return new HashSet().iterator();
}
return new ImageReaderIterator(iter);
|
| public static java.util.Iterator | getImageReadersBySuffix(java.lang.String fileSuffix)Returns an Iterator containing all currently
registered ImageReaders that claim to be able to
decode files with the given suffix.
if (fileSuffix == null) {
throw new IllegalArgumentException("fileSuffix == null!");
}
// Ensure category is present
Iterator iter;
try {
iter = theRegistry.getServiceProviders(ImageReaderSpi.class,
new ContainsFilter(readerFileSuffixesMethod,
fileSuffix),
true);
} catch (IllegalArgumentException e) {
return new HashSet().iterator();
}
return new ImageReaderIterator(iter);
|
| public static java.util.Iterator | getImageTranscoders(javax.imageio.ImageReader reader, javax.imageio.ImageWriter writer)Returns an Iterator containing all currently
registered ImageTranscoders that claim to be
able to transcode between the metadata of the given
ImageReader and ImageWriter.
if (reader == null) {
throw new IllegalArgumentException("reader == null!");
}
if (writer == null) {
throw new IllegalArgumentException("writer == null!");
}
ImageReaderSpi readerSpi = reader.getOriginatingProvider();
ImageWriterSpi writerSpi = writer.getOriginatingProvider();
ServiceRegistry.Filter filter =
new TranscoderFilter(readerSpi, writerSpi);
Iterator iter;
// Ensure category is present
try {
iter = theRegistry.getServiceProviders(ImageTranscoderSpi.class,
filter, true);
} catch (IllegalArgumentException e) {
return new HashSet().iterator();
}
return new ImageTranscoderIterator(iter);
|
| public static javax.imageio.ImageWriter | getImageWriter(javax.imageio.ImageReader reader)Returns an ImageWritercorresponding to the given
ImageReader, if there is one, or null
if the plug-in for this ImageReader does not
specify a corresponding ImageWriter, or if the
given ImageReader is not registered. This
mechanism may be used to obtain an ImageWriter
that will understand the internal structure of non-pixel
metadata (as encoded by IIOMetadata objects)
generated by the ImageReader. By obtaining this
data from the ImageReader and passing it on to the
ImageWriter obtained with this method, a client
program can read an image, modify it in some way, and write it
back out preserving all metadata, without having to understand
anything about the structure of the metadata, or even about
the image format. Note that this method returns the
"preferred" writer, which is the first in the list returned by
javax.imageio.spi.ImageReaderSpi.getImageWriterSpiNames().
if (reader == null) {
throw new IllegalArgumentException("reader == null!");
}
ImageReaderSpi readerSpi = reader.getOriginatingProvider();
if (readerSpi == null) {
Iterator readerSpiIter;
// Ensure category is present
try {
readerSpiIter =
theRegistry.getServiceProviders(ImageReaderSpi.class,
false);
} catch (IllegalArgumentException e) {
return null;
}
while (readerSpiIter.hasNext()) {
ImageReaderSpi temp = (ImageReaderSpi) readerSpiIter.next();
if (temp.isOwnReader(reader)) {
readerSpi = temp;
break;
}
}
if (readerSpi == null) {
return null;
}
}
String[] writerNames = readerSpi.getImageWriterSpiNames();
if (writerNames == null) {
return null;
}
Class writerSpiClass = null;
try {
writerSpiClass = Class.forName(writerNames[0], true,
ClassLoader.getSystemClassLoader());
} catch (ClassNotFoundException e) {
return null;
}
ImageWriterSpi writerSpi = (ImageWriterSpi)
theRegistry.getServiceProviderByClass(writerSpiClass);
if (writerSpi == null) {
return null;
}
try {
return writerSpi.createWriterInstance();
} catch (IOException e) {
// Deregister the spi in this case, but only as a writerSpi
theRegistry.deregisterServiceProvider(writerSpi,
ImageWriterSpi.class);
return null;
}
|
| public static java.util.Iterator | getImageWriters(javax.imageio.ImageTypeSpecifier type, java.lang.String formatName)Returns an Iterator containing all currently
registered ImageWriters that claim to be able to
encode images of the given layout (specified using an
ImageTypeSpecifier) in the given format.
if (type == null) {
throw new IllegalArgumentException("type == null!");
}
if (formatName == null) {
throw new IllegalArgumentException("formatName == null!");
}
Iterator iter;
// Ensure category is present
try {
iter = theRegistry.getServiceProviders(ImageWriterSpi.class,
new CanEncodeImageAndFormatFilter(type,
formatName),
true);
} catch (IllegalArgumentException e) {
return new HashSet().iterator();
}
return new ImageWriterIterator(iter);
|
| public static java.util.Iterator | getImageWritersByFormatName(java.lang.String formatName)Returns an Iterator containing all currently
registered ImageWriters that claim to be able to
encode the named format.
if (formatName == null) {
throw new IllegalArgumentException("formatName == null!");
}
Iterator iter;
// Ensure category is present
try {
iter = theRegistry.getServiceProviders(ImageWriterSpi.class,
new ContainsFilter(writerFormatNamesMethod,
formatName),
true);
} catch (IllegalArgumentException e) {
return new HashSet().iterator();
}
return new ImageWriterIterator(iter);
|
| public static java.util.Iterator | getImageWritersByMIMEType(java.lang.String MIMEType)Returns an Iterator containing all currently
registered ImageWriters that claim to be able to
encode files with the given MIME type.
if (MIMEType == null) {
throw new IllegalArgumentException("MIMEType == null!");
}
Iterator iter;
// Ensure category is present
try {
iter = theRegistry.getServiceProviders(ImageWriterSpi.class,
new ContainsFilter(writerMIMETypesMethod,
MIMEType),
true);
} catch (IllegalArgumentException e) {
return new HashSet().iterator();
}
return new ImageWriterIterator(iter);
|
| public static java.util.Iterator | getImageWritersBySuffix(java.lang.String fileSuffix)Returns an Iterator containing all currently
registered ImageWriters that claim to be able to
encode files with the given suffix.
if (fileSuffix == null) {
throw new IllegalArgumentException("fileSuffix == null!");
}
Iterator iter;
// Ensure category is present
try {
iter = theRegistry.getServiceProviders(ImageWriterSpi.class,
new ContainsFilter(writerFileSuffixesMethod,
fileSuffix),
true);
} catch (IllegalArgumentException e) {
return new HashSet().iterator();
}
return new ImageWriterIterator(iter);
|
| public static java.lang.String[] | getReaderFileSuffixes()Returns an array of Strings listing all of the
file suffixes associated with the formats understood
by the current set of registered readers.
return getReaderWriterInfo(ImageReaderSpi.class,
SpiInfo.FILE_SUFFIXES);
|
| public static java.lang.String[] | getReaderFormatNames()Returns an array of Strings listing all of the
informal format names understood by the current set of registered
readers.
return getReaderWriterInfo(ImageReaderSpi.class,
SpiInfo.FORMAT_NAMES);
|
| public static java.lang.String[] | getReaderMIMETypes()Returns an array of Strings listing all of the
MIME types understood by the current set of registered
readers.
return getReaderWriterInfo(ImageReaderSpi.class,
SpiInfo.MIME_TYPES);
|
| private static java.lang.String[] | getReaderWriterInfo(java.lang.Class spiClass, javax.imageio.ImageIO$SpiInfo spiInfo)
@Override
String[] info(ImageReaderWriterSpi spi) {
return spi.getFormatNames();
}
@Override
String[] info(ImageReaderWriterSpi spi) {
return spi.getMIMETypes();
}
@Override
String[] info(ImageReaderWriterSpi spi) {
return spi.getFileSuffixes();
}
// Ensure category is present
Iterator<S> iter;
try {
iter = theRegistry.getServiceProviders(spiClass, true);
} catch (IllegalArgumentException e) {
return new String[0];
}
HashSet<String> s = new HashSet<String>();
while (iter.hasNext()) {
ImageReaderWriterSpi spi = iter.next();
Collections.addAll(s, spiInfo.info(spi));
}
return s.toArray(new String[s.size()]);
|
| private static java.lang.String | getTempDir()Returns the default temporary (cache) directory as defined by the
java.io.tmpdir system property.
GetPropertyAction a = new GetPropertyAction("java.io.tmpdir");
return (String)AccessController.doPrivileged(a);
|
| public static boolean | getUseCache()Returns the current value set by setUseCache, or
true if no explicit setting has been made.
return getCacheInfo().getUseCache();
|
| public static java.lang.String[] | getWriterFileSuffixes()Returns an array of Strings listing all of the
file suffixes associated with the formats understood
by the current set of registered writers.
return getReaderWriterInfo(ImageWriterSpi.class,
SpiInfo.FILE_SUFFIXES);
|
| public static java.lang.String[] | getWriterFormatNames()Returns an array of Strings listing all of the
informal format names understood by the current set of registered
writers.
return getReaderWriterInfo(ImageWriterSpi.class,
SpiInfo.FORMAT_NAMES);
|
| public static java.lang.String[] | getWriterMIMETypes()Returns an array of Strings listing all of the
MIME types understood by the current set of registered
writers.
return getReaderWriterInfo(ImageWriterSpi.class,
SpiInfo.MIME_TYPES);
|
| private static boolean | hasCachePermission()Determines whether the caller has write access to the cache
directory, stores the result in the CacheInfo object,
and returns the decision. This method helps to prevent mysterious
SecurityExceptions to be thrown when this convenience class is used
in an applet, for example.
Boolean hasPermission = getCacheInfo().getHasPermission();
if (hasPermission != null) {
return hasPermission.booleanValue();
} else {
try {
SecurityManager security = System.getSecurityManager();
if (security != null) {
File cachedir = getCacheDirectory();
String cachepath;
if (cachedir != null) {
cachepath = cachedir.getPath();
} else {
cachepath = getTempDir();
if (cachepath == null) {
getCacheInfo().setHasPermission(Boolean.FALSE);
return false;
}
}
security.checkWrite(cachepath);
}
} catch (SecurityException e) {
getCacheInfo().setHasPermission(Boolean.FALSE);
return false;
}
getCacheInfo().setHasPermission(Boolean.TRUE);
return true;
}
|
| public static java.awt.image.BufferedImage | read(java.io.File input)Returns a BufferedImage as the result of decoding
a supplied File with an ImageReader
chosen automatically from among those currently registered.
The File is wrapped in an
ImageInputStream. If no registered
ImageReader claims to be able to read the
resulting stream, null is returned.
The current cache settings from getUseCacheand
getCacheDirectory will be used to control caching in the
ImageInputStream that is created.
Note that there is no read method that takes a
filename as a String; use this method instead after
creating a File from the filename.
This method does not attempt to locate
ImageReaders that can read directly from a
File; that may be accomplished using
IIORegistry and ImageReaderSpi.
if (input == null) {
throw new IllegalArgumentException("input == null!");
}
if (!input.canRead()) {
throw new IIOException("Can't read input file!");
}
ImageInputStream stream = createImageInputStream(input);
if (stream == null) {
throw new IIOException("Can't create an ImageInputStream!");
}
BufferedImage bi = read(stream);
if (bi == null) {
stream.close();
}
return bi;
|
| public static java.awt.image.BufferedImage | read(java.io.InputStream input)Returns a BufferedImage as the result of decoding
a supplied InputStream with an ImageReader
chosen automatically from among those currently registered.
The InputStream is wrapped in an
ImageInputStream. If no registered
ImageReader claims to be able to read the
resulting stream, null is returned.
The current cache settings from getUseCacheand
getCacheDirectory will be used to control caching in the
ImageInputStream that is created.
This method does not attempt to locate
ImageReaders that can read directly from an
InputStream; that may be accomplished using
IIORegistry and ImageReaderSpi.
This method does not close the provided
InputStream after the read operation has completed;
it is the responsibility of the caller to close the stream, if desired.
if (input == null) {
throw new IllegalArgumentException("input == null!");
}
ImageInputStream stream = createImageInputStream(input);
BufferedImage bi = read(stream);
if (bi == null) {
stream.close();
}
return bi;
|
| public static java.awt.image.BufferedImage | read(java.net.URL input)Returns a BufferedImage as the result of decoding
a supplied URL with an ImageReader
chosen automatically from among those currently registered. An
InputStream is obtained from the URL,
which is wrapped in an ImageInputStream. If no
registered ImageReader claims to be able to read
the resulting stream, null is returned.
The current cache settings from getUseCacheand
getCacheDirectory will be used to control caching in the
ImageInputStream that is created.
This method does not attempt to locate
ImageReaders that can read directly from a
URL; that may be accomplished using
IIORegistry and ImageReaderSpi.
if (input == null) {
throw new IllegalArgumentException("input == null!");
}
InputStream istream = null;
try {
istream = input.openStream();
} catch (IOException e) {
throw new IIOException("Can't get input stream from URL!", e);
}
ImageInputStream stream = createImageInputStream(istream);
BufferedImage bi;
try {
bi = read(stream);
if (bi == null) {
stream.close();
}
} finally {
istream.close();
}
return bi;
|
| public static java.awt.image.BufferedImage | read(javax.imageio.stream.ImageInputStream stream)Returns a BufferedImage as the result of decoding
a supplied ImageInputStream with an
ImageReader chosen automatically from among those
currently registered. If no registered
ImageReader claims to be able to read the stream,
null is returned.
Unlike most other methods in this class, this method does
close the provided ImageInputStream after the read
operation has completed, unless null is returned,
in which case this method does not close the stream.
if (stream == null) {
throw new IllegalArgumentException("stream == null!");
}
Iterator iter = getImageReaders(stream);
if (!iter.hasNext()) {
return null;
}
ImageReader reader = (ImageReader)iter.next();
ImageReadParam param = reader.getDefaultReadParam();
reader.setInput(stream, true, true);
BufferedImage bi;
try {
bi = reader.read(0, param);
} finally {
reader.dispose();
stream.close();
}
return bi;
|
| public static void | scanForPlugins()Scans for plug-ins on the application class path,
loads their service provider classes, and registers a service
provider instance for each one found with the
IIORegistry.
This method is needed because the application class path can
theoretically change, or additional plug-ins may become available.
Rather than re-scanning the classpath on every invocation of the
API, the class path is scanned automatically only on the first
invocation. Clients can call this method to prompt a re-scan.
Thus this method need only be invoked by sophisticated applications
which dynamically make new plug-ins available at runtime.
The getResources method of the context
ClassLoader is used locate JAR files containing
files named
META-INF/services/javax.imageio.spi.classname,
where classname is one of ImageReaderSpi,
ImageWriterSpi, ImageTranscoderSpi,
ImageInputStreamSpi, or
ImageOutputStreamSpi, along the application class
path.
The contents of the located files indicate the names of
actual implementation classes which implement the
aforementioned service provider interfaces; the default class
loader is then used to load each of these classes and to
instantiate an instance of each class, which is then placed
into the registry for later retrieval.
The exact set of locations searched depends on the
implementation of the Java runtime enviroment.
theRegistry.registerApplicationClasspathSpis();
|
| public static void | setCacheDirectory(java.io.File cacheDirectory)Sets the directory where cache files are to be created. A
value of null indicates that the system-dependent
default temporary-file directory is to be used. If
getUseCache returns false, this value is ignored.
if ((cacheDirectory != null) && !(cacheDirectory.isDirectory())) {
throw new IllegalArgumentException("Not a directory!");
}
getCacheInfo().setCacheDirectory(cacheDirectory);
getCacheInfo().setHasPermission(null);
|
| public static void | setUseCache(boolean useCache)Sets a flag indicating whether a disk-based cache file should
be used when creating ImageInputStreams and
ImageOutputStreams.
When reading from a standard InputStream>, it
may be necessary to save previously read information in a cache
since the underlying stream does not allow data to be re-read.
Similarly, when writing to a standard
OutputStream, a cache may be used to allow a
previously written value to be changed before flushing it to
the final destination.
The cache may reside in main memory or on disk. Setting
this flag to false disallows the use of disk for
future streams, which may be advantageous when working with
small images, as the overhead of creating and destroying files
is removed.
On startup, the value is set to true.
getCacheInfo().setUseCache(useCache);
|
| public static boolean | write(java.awt.image.RenderedImage im, java.lang.String formatName, javax.imageio.stream.ImageOutputStream output)Writes an image using the an arbitrary ImageWriter
that supports the given format to an
ImageOutputStream. The image is written to the
ImageOutputStream starting at the current stream
pointer, overwriting existing stream data from that point
forward, if present.
This method does not close the provided
ImageOutputStream after the write operation has completed;
it is the responsibility of the caller to close the stream, if desired.
if (im == null) {
throw new IllegalArgumentException("im == null!");
}
if (formatName == null) {
throw new IllegalArgumentException("formatName == null!");
}
if (output == null) {
throw new IllegalArgumentException("output == null!");
}
ImageWriter writer = null;
ImageTypeSpecifier type =
ImageTypeSpecifier.createFromRenderedImage(im);
Iterator iter = getImageWriters(type, formatName);
if (iter.hasNext()) {
writer = (ImageWriter)iter.next();
}
if (writer == null) {
return false;
}
writer.setOutput(output);
try {
writer.write(im);
} finally {
writer.dispose();
output.flush();
}
return true;
|
| public static boolean | write(java.awt.image.RenderedImage im, java.lang.String formatName, java.io.File output)Writes an image using an arbitrary ImageWriter
that supports the given format to a File. If
there is already a File present, its contents are
discarded.
if (output == null) {
throw new IllegalArgumentException("output == null!");
}
ImageOutputStream stream = null;
try {
output.delete();
stream = createImageOutputStream(output);
} catch (IOException e) {
throw new IIOException("Can't create output stream!", e);
}
boolean val;
try {
val = write(im, formatName, stream);
} finally {
stream.close();
}
return val;
|
| public static boolean | write(java.awt.image.RenderedImage im, java.lang.String formatName, java.io.OutputStream output)Writes an image using an arbitrary ImageWriter
that supports the given format to an OutputStream.
This method does not close the provided
OutputStream after the write operation has completed;
it is the responsibility of the caller to close the stream, if desired.
The current cache settings from getUseCacheand
getCacheDirectory will be used to control caching.
if (output == null) {
throw new IllegalArgumentException("output == null!");
}
ImageOutputStream stream = null;
try {
stream = createImageOutputStream(output);
} catch (IOException e) {
throw new IIOException("Can't create output stream!", e);
}
boolean val;
try {
val = write(im, formatName, stream);
} finally {
stream.close();
}
return val;
|
