/** * Returns an <code>Iterator</code> containing all currently * registered <code>ImageWriter</code>s that claim to be able to * encode the named format. * * @param formatName a <code>String</code> containing the informal * name of a format (<i>e.g.</i>, "jpeg" or "tiff". * * @return an <code>Iterator</code> containing * <code>ImageWriter</code>s. * * @exception IllegalArgumentException if <code>formatName</code> is * <code>null</code>. * * @see javax.imageio.spi.ImageWriterSpi#getFormatNames */ public static Iterator<ImageWriter> getImageWritersByFormatName(String formatName) { 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 Collections.emptyIterator(); } return new ImageWriterIterator(iter); }
/** * Returns an <code>Iterator</code> containing all currently * registered <code>ImageWriter</code>s that claim to be able to * encode files with the given suffix. * * @param fileSuffix a <code>String</code> containing a file * suffix (<i>e.g.</i>, "jpg" or "tiff"). * * @return an <code>Iterator</code> containing <code>ImageWriter</code>s. * * @exception IllegalArgumentException if <code>fileSuffix</code> is * <code>null</code>. * * @see javax.imageio.spi.ImageWriterSpi#getFileSuffixes */ public static Iterator<ImageWriter> getImageWritersBySuffix(String fileSuffix) { 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 Collections.emptyIterator(); } return new ImageWriterIterator(iter); }
/** * Returns an <code>Iterator</code> containing all currently * registered <code>ImageWriter</code>s that claim to be able to * encode files with the given MIME type. * * @param MIMEType a <code>String</code> containing a file * suffix (<i>e.g.</i>, "image/jpeg" or "image/x-bmp"). * * @return an <code>Iterator</code> containing <code>ImageWriter</code>s. * * @exception IllegalArgumentException if <code>MIMEType</code> is * <code>null</code>. * * @see javax.imageio.spi.ImageWriterSpi#getMIMETypes */ public static Iterator<ImageWriter> getImageWritersByMIMEType(String MIMEType) { 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 Collections.emptyIterator(); } return new ImageWriterIterator(iter); }
/** * 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); }
/** * 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); }
public void doTest() { File pwd = new File("."); try { File f = File.createTempFile("transparency_test_", ".gif", pwd); System.out.println("file: " + f.getCanonicalPath()); ImageWriter w = ImageIO.getImageWritersByFormatName("GIF").next(); ImageWriterSpi spi = w.getOriginatingProvider(); boolean succeed_write = ImageIO.write(src, "gif", f); if (!succeed_write) { throw new RuntimeException("Test failed: failed to write src."); } dst = ImageIO.read(f); checkResult(src, dst); } catch (IOException e) { throw new RuntimeException("Test failed.", e); } }
/** * Returns an {@code Iterator} containing all currently * registered {@code ImageWriter}s that claim to be able to * encode the named format. * * @param formatName a {@code String} containing the informal * name of a format (<i>e.g.</i>, "jpeg" or "tiff". * * @return an {@code Iterator} containing * {@code ImageWriter}s. * * @exception IllegalArgumentException if {@code formatName} is * {@code null}. * * @see javax.imageio.spi.ImageWriterSpi#getFormatNames */ public static Iterator<ImageWriter> getImageWritersByFormatName(String formatName) { if (formatName == null) { throw new IllegalArgumentException("formatName == null!"); } Iterator<ImageWriterSpi> iter; // Ensure category is present try { iter = theRegistry.getServiceProviders(ImageWriterSpi.class, new ContainsFilter(writerFormatNamesMethod, formatName), true); } catch (IllegalArgumentException e) { return Collections.emptyIterator(); } return new ImageWriterIterator(iter); }
/** * Returns an {@code Iterator} containing all currently * registered {@code ImageWriter}s that claim to be able to * encode files with the given suffix. * * @param fileSuffix a {@code String} containing a file * suffix (<i>e.g.</i>, "jpg" or "tiff"). * * @return an {@code Iterator} containing {@code ImageWriter}s. * * @exception IllegalArgumentException if {@code fileSuffix} is * {@code null}. * * @see javax.imageio.spi.ImageWriterSpi#getFileSuffixes */ public static Iterator<ImageWriter> getImageWritersBySuffix(String fileSuffix) { if (fileSuffix == null) { throw new IllegalArgumentException("fileSuffix == null!"); } Iterator<ImageWriterSpi> iter; // Ensure category is present try { iter = theRegistry.getServiceProviders(ImageWriterSpi.class, new ContainsFilter(writerFileSuffixesMethod, fileSuffix), true); } catch (IllegalArgumentException e) { return Collections.emptyIterator(); } return new ImageWriterIterator(iter); }
/** * Returns an {@code Iterator} containing all currently * registered {@code ImageWriter}s that claim to be able to * encode files with the given MIME type. * * @param MIMEType a {@code String} containing a file * suffix (<i>e.g.</i>, "image/jpeg" or "image/x-bmp"). * * @return an {@code Iterator} containing {@code ImageWriter}s. * * @exception IllegalArgumentException if {@code MIMEType} is * {@code null}. * * @see javax.imageio.spi.ImageWriterSpi#getMIMETypes */ public static Iterator<ImageWriter> getImageWritersByMIMEType(String MIMEType) { if (MIMEType == null) { throw new IllegalArgumentException("MIMEType == null!"); } Iterator<ImageWriterSpi> iter; // Ensure category is present try { iter = theRegistry.getServiceProviders(ImageWriterSpi.class, new ContainsFilter(writerMIMETypesMethod, MIMEType), true); } catch (IllegalArgumentException e) { return Collections.emptyIterator(); } return new ImageWriterIterator(iter); }
/** * Returns an {@code Iterator} containing all currently * registered {@code ImageWriter}s that claim to be able to * encode images of the given layout (specified using an * {@code ImageTypeSpecifier}) in the given format. * * @param type an {@code ImageTypeSpecifier} indicating the * layout of the image to be written. * @param formatName the informal name of the {@code format}. * * @return an {@code Iterator} containing {@code ImageWriter}s. * * @exception IllegalArgumentException if any parameter is * {@code null}. * * @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<ImageWriterSpi> 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); }
/** * Returns an {@code Iterator} containing all currently * registered {@code ImageTranscoder}s that claim to be * able to transcode between the metadata of the given * {@code ImageReader} and {@code ImageWriter}. * * @param reader an {@code ImageReader}. * @param writer an {@code ImageWriter}. * * @return an {@code Iterator} containing * {@code ImageTranscoder}s. * * @exception IllegalArgumentException if {@code reader} or * {@code writer} is {@code null}. */ 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<ImageTranscoderSpi> iter; // Ensure category is present try { iter = theRegistry.getServiceProviders(ImageTranscoderSpi.class, filter, true); } catch (IllegalArgumentException e) { return Collections.emptyIterator(); } return new ImageTranscoderIterator(iter); }
public SpiTest() { testImageReaderSpiConstructor(); testImageWriterSpiConstructor(); ServiceRegistry registry = IIORegistry.getDefaultInstance(); Iterator readers = registry.getServiceProviders(ImageReaderSpi.class, false); while (readers.hasNext()) { ImageReaderSpi rspi = (ImageReaderSpi)readers.next(); System.out.println("*** Testing " + rspi.getClass().getName()); testSpi(rspi); } Iterator writers = registry.getServiceProviders(ImageWriterSpi.class, false); while (writers.hasNext()) { ImageWriterSpi wspi = (ImageWriterSpi)writers.next(); System.out.println("*** Testing " + wspi.getClass().getName()); testSpi(wspi); } }
public static void main(String[] args) { ImageReaderSpi rspi = new PNGImageReaderSpi(); if (rspi.getNativeStreamMetadataFormatName() != null) { fatal(); } if (rspi.isStandardStreamMetadataFormatSupported() != false) { fatal(); } if (rspi.getExtraStreamMetadataFormatNames() != null) { fatal(); } ImageWriterSpi wspi = new PNGImageWriterSpi(); if (wspi.getNativeStreamMetadataFormatName() != null) { fatal(); } if (wspi.isStandardStreamMetadataFormatSupported() != false) { fatal(); } if (wspi.getExtraStreamMetadataFormatNames() != null) { fatal(); } }
public static void main(final String[] args) throws IOException { final IIORegistry registry = IIORegistry.getDefaultInstance(); final Iterator<ImageWriterSpi> iter = registry.getServiceProviders( ImageWriterSpi.class, provider -> true, true); // Validates all supported ImageWriters int numFailures = 0; while (iter.hasNext()) { final WriteAfterAbort writeAfterAbort = new WriteAfterAbort(); final ImageWriter writer = iter.next().createWriterInstance(); System.out.println("ImageWriter = " + writer); try { writeAfterAbort.test(writer); } catch (Exception e) { System.err.println("Test failed for \"" + writer.getOriginatingProvider().getFormatNames()[0] + "\" format."); numFailures++; } } if (numFailures == 0) { System.out.println("Test passed."); } else { throw new RuntimeException("Test failed."); } }
/** * 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]; } }
/** * 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 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; }