}         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;        }    }     /**     * Returns an <code>ImageReader</code>corresponding to the given     * <code>ImageWriter</code>, if there is one, or <code>null</code>     * if the plug-in for this <code>ImageWriter</code> does not     * specify a corresponding <code>ImageReader</code>, or if the     * given <code>ImageWriter</code> is not registered.  This method     * is provided principally for symmetry with     * <code>getImageWriter(ImageReader)</code>.  Note that this     * method returns the "preferred" reader, which is the first in     * the list returned by     * javax.imageio.spi.ImageWriterSpi.<code>getImageReaderSpiNames()</code>.     *     * @param writer an instance of a registered <code>ImageWriter</code>.     *     * @return an <code>ImageReader</code>, or null.     *     * @exception IllegalArgumentException if <code>writer</code> is     * <code>null</code>.     *     * @see #getImageWriter(ImageReader)     * @see javax.imageio.spi.ImageWriterSpi#getImageReaderSpiNames()     */    public static ImageReader getImageReader(ImageWriter writer) {        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;        }    }     /**     * Returns an <code>Iterator</code> containing all currently     * registered <code>ImageWriter</code>s that claim to be able to     * encode images of the given layout (specified using an     * <code>ImageTypeSpecifier</code>) in the given format.     *     * @param type an <code>ImageTypeSpecifier</code> indicating the     * layout of the image to be written.     * @param formatName the informal name of the <code>format</code>.     *     * @return an <code>Iterator</code> containing <code>ImageWriter</code>s.     *     * @exception IllegalArgumentException if any parameter is     * <code>null</code>.     *     * @see javax.imageio.spi.ImageWriterSpi#canEncodeImage(ImageTypeSpecifier)     */    public static Iterator<ImageWriter>        getImageWriters(ImageTypeSpecifier type, String formatName)    {        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 Collections.emptyIterator();        }         return new ImageWriterIterator(iter);    }     static class ImageTranscoderIterator        implements Iterator<ImageTranscoder>    {        // Contains ImageTranscoderSpis        public Iterator iter;         public ImageTranscoderIterator(Iterator iter) {            this.iter = iter;        }         public boolean hasNext() {            return iter.hasNext();        }         public ImageTranscoder next() {            ImageTranscoderSpi spi = null;            spi = (ImageTranscoderSpi)iter.next();            return spi.createTranscoderInstance();        }         public void remove() {            throw new UnsupportedOperationException();        }    }     static class TranscoderFilter        implements ServiceRegistry.Filter {         String readerSpiName;        String writerSpiName;         public TranscoderFilter(ImageReaderSpi readerSpi,                                ImageWriterSpi writerSpi) {            this.readerSpiName = readerSpi.getClass().getName();            this.writerSpiName = writerSpi.getClass().getName();        }         public boolean filter(Object elt) {            ImageTranscoderSpi spi = (ImageTranscoderSpi)elt;            String readerName = spi.getReaderServiceProviderName();            String writerName = spi.getWriterServiceProviderName();            return (readerName.equals(readerSpiName) &&                    writerName.equals(writerSpiName));        }    }     /**     * Returns an <code>Iterator</code> containing all currently     * registered <code>ImageTranscoder</code>s that claim to be     * able to transcode between the metadata of the given     * <code>ImageReader</code> and <code>ImageWriter</code>.     *     * @param reader an <code>ImageReader</code>.     * @param writer an <code>ImageWriter</code>.     *     * @return an <code>Iterator</code> containing     * <code>ImageTranscoder</code>s.     *     * @exception IllegalArgumentException if <code>reader</code> or     * <code>writer</code> is <code>null</code>.     */    public static Iterator<ImageTranscoder>        getImageTranscoders(ImageReader reader, ImageWriter writer)    {        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 Collections.emptyIterator();        }        return new ImageTranscoderIterator(iter);    }     // All-in-one methods     /**     * Returns a <code>BufferedImage</code> as the result of decoding     * a supplied <code>File</code> with an <code>ImageReader</code>     * chosen automatically from among those currently registered.     * The <code>File</code> is wrapped in an     * <code>ImageInputStream</code>.  If no registered     * <code>ImageReader</code> claims to be able to read the     * resulting stream, <code>null</code> is returned.     *     * <p> The current cache settings from <code>getUseCache</code>and     * <code>getCacheDirectory</code> will be used to control caching in the     * <code>ImageInputStream</code> that is created.     *     * <p> Note that there is no <code>read</code> method that takes a     * filename as a <code>String</code>; use this method instead after     * creating a <code>File</code> from the filename.     *     * <p> This method does not attempt to locate     * <code>ImageReader</code>s that can read directly from a     * <code>File</code>; that may be accomplished using     * <code>IIORegistry</code> and <code>ImageReaderSpi</code>.     *     * @param input a <code>File</code> to read from.     *     * @return a <code>BufferedImage</code> containing the decoded     * contents of the input, or <code>null</code>.     *     * @exception IllegalArgumentException if <code>input</code> is     * <code>null</code>.     * @exception IOException if an error occurs during reading.     */    public static BufferedImage read(File input) throws IOException {        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;    }     /**     * Returns a <code>BufferedImage</code> as the result of decoding     * a supplied <code>InputStream</code> with an <code>ImageReader</code>     * chosen automatically from among those currently registered.     * The <code>InputStream</code> is wrapped in an     * <code>ImageInputStream</code>.  If no registered     * <code>ImageReader</code> claims to be able to read the     * resulting stream, <code>null</code> is returned.     *     * <p> The current cache settings from <code>getUseCache</code>and     * <code>getCacheDirectory</code> will be used to control caching in the     * <code>ImageInputStream</code> that is created.     *     * <p> This method does not attempt to locate     * <code>ImageReader</code>s that can read directly from an     * <code>InputStream</code>; that may be accomplished using     * <code>IIORegistry</code> and <code>ImageReaderSpi</code>.     *     * <p> This method <em>does not</em> close the provided     * <code>InputStream</code> after the read operation has completed;     * it is the responsibility of the caller to close the stream, if desired.     *     * @param input an <code>InputStream</code> to read from.     *     * @return a <code>BufferedImage</code> containing the decoded     * contents of the input, or <code>null</code>.     *     * @exception IllegalArgumentException if <code>input</code> is     * <code>null</code>.     * @exception IOException if an error occurs during reading.     */    public static BufferedImage read(InputStream input) throws IOException {        if (input == null) {            throw new IllegalArgumentException("input == null!");        }         ImageInputStream stream = createImageInputStream(input);        BufferedImage bi = read(stream);        if (bi == null) {            stream.close();        }        return bi;    }     /**     * Returns a <code>BufferedImage</code> as the result of decoding     * a supplied <code>URL</code> with an <code>ImageReader</code>     * chosen automatically from among those currently registered.  An     * <code>InputStream</code> is obtained from the <code>URL</code>,     * which is wrapped in an <code>ImageInputStream</code>.  If no     * registered <code>ImageReader</code> claims to be able to read     * the resulting stream, <code>null</code> is returned.     *     * <p> The current cache settings from <code>getUseCache</code>and     * <code>getCacheDirectory</code> will be used to control caching in the     * <code>ImageInputStream</code> that is created.     *     * <p> This method does not attempt to locate     * <code>ImageReader</code>s that can read directly from a     * <code>URL</code>; that may be accomplished using     * <code>IIORegistry</code> and <code>ImageReaderSpi</code>.     *     * @param input a <code>URL</code> to read from.     *     * @return a <code>BufferedImage</code> containing the decoded     * contents of the input, or <code>null</code>.     *     * @exception IllegalArgumentException if <code>input</code> is     * <code>null</code>.     * @exception IOException if an error occurs during reading.     */    public static BufferedImage read(URL input) throws IOException {        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;    }     /**     * Returns a <code>BufferedImage</code> as the result of decoding     * a supplied <code>ImageInputStream</code> with an     * <code>ImageReader</code> chosen automatically from among those     * currently registered.  If no registered     * <code>ImageReader</code> claims to be able to read the stream,     * <code>null</code> is returned.     *     * <p> Unlike most other methods in this class, this method <em>does</em>     * close the provided <code>ImageInputStream</code> after the read     * operation has completed, unless <code>null</code> is returned,     * in which case this method <em>does not</em> close the stream.     *     * @param stream an <code>ImageInputStream</code> to read from.     *     * @return a <code>BufferedImage</code> containing the decoded     * contents of the input, or <code>null</code>.     *     * @exception IllegalArgumentException if <code>stream</code> is     * <code>null</code>.     * @exception IOException if an error occurs during reading.     */    public static BufferedImage read(ImageInputStream stream)        throws IOException {        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;    }     /**     * Writes an image using the an arbitrary <code>ImageWriter</code>     * that supports the given format to an     * <code>ImageOutputStream</code>.  The image is written to the     * <code>ImageOutputStream</code> starting at the current stream     * pointer, overwriting existing stream data from that point     * forward, if present.     *     * <p> This method <em>does not</em> close the provided     * <code>ImageOutputStream</code> after the write operation has completed;     * it is the responsibility of the caller to close the stream, if desired.     *     * @param im a <code>RenderedImage</code> to be written.     * @param formatName a <code>String</code> containg the informal     * name of the format.     * @param output an <code>ImageOutputStream</code> to be written to.     *     * @return <code>false</code> if no appropriate writer is found.     *     * @exception IllegalArgumentException if any parameter is     * <code>null</code>.     * @exception IOException if an error occurs during writing.     */    public static boolean write(RenderedImage im,                                String formatName,                                ImageOutputStream output) throws IOException {        if (im == null) {            throw new IllegalArgumentException("im == null!");        }        if (formatName == null) {            throw new IllegalArgumentException("formatName == null!");        }        if (output == null) {            throw new IllegalArgumentException("output == null!");        }         return doWrite(im, getWriter(im, formatName), output);    }     /**     * Writes an image using an arbitrary <code>ImageWriter</code>     * that supports the given format to a <code>File</code>.  If     * there is already a <code>File</code> present, its contents are     * discarded.     *

Lines 1001–1500 of 1619. Previous lines Load more