getImageReadersByFormatName(String formatName) { 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 Collections.emptyIterator(); } return new ImageReaderIterator(iter); }
/** * Returns an <code>Iterator</code> containing all currently * registered <code>ImageReader</code>s that claim to be able to * decode 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>ImageReader</code>s. * * @exception IllegalArgumentException if <code>fileSuffix</code> * is <code>null</code>. * * @see javax.imageio.spi.ImageReaderSpi#getFileSuffixes */ public static Iterator<ImageReader> getImageReadersBySuffix(String fileSuffix) { 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 Collections.emptyIterator(); } return new ImageReaderIterator(iter); }
/** * Returns an <code>Iterator</code> containing all currently * registered <code>ImageReader</code>s that claim to be able to * decode 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>ImageReader</code>s. * * @exception IllegalArgumentException if <code>MIMEType</code> is * <code>null</code>. * * @see javax.imageio.spi.ImageReaderSpi#getMIMETypes */ public static Iterator<ImageReader> getImageReadersByMIMEType(String MIMEType) { 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 Collections.emptyIterator(); } return new ImageReaderIterator(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(ImageReaderSpi spi) throws IOException { System.out.println("Test for " + title + (canDecode ? " (can decode)" : " (can't decode)")); System.out.print("As a stream..."); ImageInputStream iis = ImageIO.createImageInputStream(getDataStream()); if (spi.canDecodeInput(iis) != canDecode) { throw new RuntimeException("Test failed: wrong decideion " + "for stream data"); } System.out.println("OK"); System.out.print("As a file..."); iis = ImageIO.createImageInputStream(getDataFile()); if (spi.canDecodeInput(iis) != canDecode) { throw new RuntimeException("Test failed: wrong decideion " + "for file data"); } System.out.println("OK"); }
/** * Retrieves a JPEG reader which supports native JPEG stream metadata. */ private static ImageReader getJPEGTablesReader() { ImageReader jpegReader = null; try { IIORegistry registry = IIORegistry.getDefaultInstance(); Iterator<?> readerSPIs = registry.getServiceProviders(ImageReaderSpi.class, new JPEGSPIFilter(), true); if(readerSPIs.hasNext()) { ImageReaderSpi jpegReaderSPI = (ImageReaderSpi)readerSPIs.next(); jpegReader = jpegReaderSPI.createReaderInstance(); } } catch(Exception e) { // Ignore it ... } return jpegReader; }
getImageReadersByFormatName(String formatName) { if (formatName == null) { throw new IllegalArgumentException("formatName == null!"); } Iterator<ImageReaderSpi> iter; // Ensure category is present try { iter = theRegistry.getServiceProviders(ImageReaderSpi.class, new ContainsFilter(readerFormatNamesMethod, formatName), true); } catch (IllegalArgumentException e) { return Collections.emptyIterator(); } return new ImageReaderIterator(iter); }
/** * Returns an {@code Iterator} containing all currently * registered {@code ImageReader}s that claim to be able to * decode 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 ImageReader}s. * * @exception IllegalArgumentException if {@code fileSuffix} * is {@code null}. * * @see javax.imageio.spi.ImageReaderSpi#getFileSuffixes */ public static Iterator<ImageReader> getImageReadersBySuffix(String fileSuffix) { if (fileSuffix == null) { throw new IllegalArgumentException("fileSuffix == null!"); } // Ensure category is present Iterator<ImageReaderSpi> iter; try { iter = theRegistry.getServiceProviders(ImageReaderSpi.class, new ContainsFilter(readerFileSuffixesMethod, fileSuffix), true); } catch (IllegalArgumentException e) { return Collections.emptyIterator(); } return new ImageReaderIterator(iter); }
/** * Returns an {@code Iterator} containing all currently * registered {@code ImageReader}s that claim to be able to * decode 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 ImageReader}s. * * @exception IllegalArgumentException if {@code MIMEType} is * {@code null}. * * @see javax.imageio.spi.ImageReaderSpi#getMIMETypes */ public static Iterator<ImageReader> getImageReadersByMIMEType(String MIMEType) { if (MIMEType == null) { throw new IllegalArgumentException("MIMEType == null!"); } // Ensure category is present Iterator<ImageReaderSpi> iter; try { iter = theRegistry.getServiceProviders(ImageReaderSpi.class, new ContainsFilter(readerMIMETypesMethod, MIMEType), true); } catch (IllegalArgumentException e) { return Collections.emptyIterator(); } return new ImageReaderIterator(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 OrderingTest() { ServiceRegistry reg = IIORegistry.getDefaultInstance(); ImageReaderSpi gifSpi = (ImageReaderSpi) reg.getServiceProviderByClass(com.sun.imageio.plugins.gif.GIFImageReaderSpi.class); ImageReaderSpi pngSpi = (ImageReaderSpi) reg.getServiceProviderByClass(com.sun.imageio.plugins.png.PNGImageReaderSpi.class); boolean ordered = reg.setOrdering(ImageReaderSpi.class, gifSpi, pngSpi); ordered = reg.setOrdering(ImageReaderSpi.class, pngSpi, gifSpi); boolean unordered = reg.unsetOrdering(ImageReaderSpi.class, gifSpi, pngSpi); boolean unordered1 = reg.unsetOrdering(ImageReaderSpi.class, gifSpi, pngSpi); if (unordered1) { throw new RuntimeException("FAIL: Ordering 2 spi objects in the " + "reverse direction does not remove the previous ordering " + "set between the spi objects and hence unsetOrdering() " + "returns true for the same spi objects when called consecutively"); } else { System.out.println("PASS"); } }
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 DeregisterOrderedSpiTest() { try { ServiceRegistry reg = IIORegistry.getDefaultInstance(); ImageReaderSpi gifSpi = (ImageReaderSpi) reg.getServiceProviderByClass(com.sun.imageio.plugins.gif.GIFImageReaderSpi.class); ImageReaderSpi pngSpi = (ImageReaderSpi) reg.getServiceProviderByClass(com.sun.imageio.plugins.png.PNGImageReaderSpi.class); ImageReaderSpi jpgSpi = (ImageReaderSpi) reg.getServiceProviderByClass(com.sun.imageio.plugins.jpeg.JPEGImageReaderSpi.class); ImageReaderSpi bmpSpi = (ImageReaderSpi) reg.getServiceProviderByClass(com.sun.imageio.plugins.bmp.BMPImageReaderSpi.class); boolean ordered = reg.setOrdering(ImageReaderSpi.class, pngSpi, gifSpi); ordered = reg.setOrdering(ImageReaderSpi.class, gifSpi, jpgSpi); ordered = reg.setOrdering(ImageReaderSpi.class, bmpSpi, gifSpi); reg.deregisterServiceProvider(gifSpi); System.out.println("PASS"); } catch (Exception e) { System.out.println("FAIL"); throw new RuntimeException("Deregistering a spi object involved in some " + "ordering throws the following exception: " + e.toString()); } }
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(); } }
/** * Retrieves a JPEG reader which supports native JPEG stream metadata. */ private static ImageReader getJPEGTablesReader() { ImageReader jpegReader = null; try { IIORegistry registry = IIORegistry.getDefaultInstance(); Class<?> imageReaderClass = Class.forName("javax.imageio.spi.ImageReaderSpi"); Iterator<?> readerSPIs = registry.getServiceProviders(imageReaderClass, new JPEGSPIFilter(), true); if(readerSPIs.hasNext()) { ImageReaderSpi jpegReaderSPI = (ImageReaderSpi)readerSPIs.next(); jpegReader = jpegReaderSPI.createReaderInstance(); } } catch(Exception e) { // Ignore it ... } return jpegReader; }
/** * 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; }
/** * 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]; } }
public boolean filter(Object elt) { try { ImageReaderSpi spi = (ImageReaderSpi)elt; ImageInputStream stream = null; if (input instanceof ImageInputStream) { stream = (ImageInputStream)input; } // Perform mark/reset as a defensive measure // even though plug-ins are supposed to take // care of it. boolean canDecode = false; if (stream != null) { stream.mark(); } canDecode = spi.canDecodeInput(input); if (stream != null) { stream.reset(); } return canDecode; } catch (IOException e) { return false; } }
/** * 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; }