/** * Writes a buffered image to a TIFF output stream. * @param image buffered image to write out as a TIFF * @param output output stream to write to * @throws IOException If there is an error writing to * <code>output</code>. */ private void writeTiff(BufferedImage image, OutputStream output) throws IOException { try (ImageOutputStream ios = ImageIO.createImageOutputStream(output)) { IIORegistry registry = IIORegistry.getDefaultInstance(); registry.registerServiceProviders( ServiceRegistry.lookupProviders( TIFFImageWriterSpi.class)); TIFFImageWriterSpi spi = registry.getServiceProviderByClass( TIFFImageWriterSpi.class); TIFFImageWriter writer = new TIFFImageWriter(spi); writer.setOutput(ios); writer.write(null, new IIOImage(image, null, null), null); } }
/** * 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; }
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) throws IOException { MarkTryFinallyReproducerSpi spi = new MarkTryFinallyReproducerSpi(); IIORegistry.getDefaultInstance().registerServiceProvider(spi); ImageInputStream iis1 = new NotClosingImageInputStream(ImageIO.createImageInputStream(new ByteArrayInputStream(bmp))); iis1.readByte(); iis1.mark(); long p1 = iis1.getStreamPosition(); iis1.readByte(); iis1.mark(); long p2 = iis1.getStreamPosition(); BufferedImage bi1 = ImageIO.read(iis1); iis1.reset(); long pn2 = iis1.getStreamPosition(); iis1.reset(); long pn1 = iis1.getStreamPosition(); if (p1 != pn1 || p2!= pn2) { throw new RuntimeException("Exception from call to canDecodeInput in ImageIO. " + "Corrupted stack in ImageInputStream"); } }
public static void main (String[] args) throws IIOException { // Verify getReaderMIMETypes() behavior by keeping MIMEType as null. TestImageReaderSpi mimeNullReadSpi = new TestImageReaderSpi(FORMATNAMES, SUFFIXES, null); IIORegistry.getDefaultInstance(). registerServiceProvider(mimeNullReadSpi); ImageIO.getReaderMIMETypes(); IIORegistry.getDefaultInstance(). deregisterServiceProvider(mimeNullReadSpi); /* * Verify getReaderFileSuffixes() behavior by keeping * file suffix as null. */ TestImageReaderSpi suffixNullReadSpi = new TestImageReaderSpi(FORMATNAMES, null, MIMETYPES); IIORegistry.getDefaultInstance(). registerServiceProvider(suffixNullReadSpi); ImageIO.getReaderFileSuffixes(); IIORegistry.getDefaultInstance(). deregisterServiceProvider(suffixNullReadSpi); }
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."); } }
/** * 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; }
private void registerSpi() { // We will register a new Spi for creating NIO-based ImageInputStreams. final IIORegistry defaultInstance = IIORegistry.getDefaultInstance(); Iterator<ImageInputStreamSpi> serviceProviders = defaultInstance.getServiceProviders(ImageInputStreamSpi.class, true); ImageInputStreamSpi toUnorder = null; if (defaultInstance.getServiceProviderByClass(FileImageInputStreamSpi.class) == null) { // register only if not already registered while (serviceProviders.hasNext()) { ImageInputStreamSpi current = serviceProviders.next(); if (current.getInputClass() == File.class) { toUnorder = current; break; } } channelImageInputStreamSpi = new FileImageInputStreamSpi(); defaultInstance.registerServiceProvider(channelImageInputStreamSpi); if (toUnorder != null) { // Make the custom Spi to be the first one to be used. defaultInstance.setOrdering(ImageInputStreamSpi.class, channelImageInputStreamSpi, toUnorder); } } }
/** * Registers a file image input strwM SPI for image input stream, if none is yet registered. */ protected void registerSpi() { final IIORegistry defaultInstance = IIORegistry.getDefaultInstance(); Iterator<ImageInputStreamSpi> serviceProviders = defaultInstance.getServiceProviders(ImageInputStreamSpi.class, true); ImageInputStreamSpi toUnorder = null; if (defaultInstance.getServiceProviderByClass(FileImageInputStreamSpi.class) == null) { // register only if not already registered while (serviceProviders.hasNext()) { ImageInputStreamSpi current = serviceProviders.next(); if (current.getInputClass() == File.class) { toUnorder = current; break; } } imageInputStreamSpi = new FileImageInputStreamSpi(); defaultInstance.registerServiceProvider(imageInputStreamSpi); if (toUnorder != null) { // Make the custom Spi to be the first one to be used. defaultInstance.setOrdering(ImageInputStreamSpi.class, imageInputStreamSpi, toUnorder); } } }
private static void initImageIO() { // todo - actually this should be done in the activator of ceres-jai which does not exist yet Lookup.Result<ModuleInfo> moduleInfos = Lookup.getDefault().lookupResult(ModuleInfo.class); String ceresJaiCodeName = "org.esa.snap.ceres.jai"; Optional<? extends ModuleInfo> info = moduleInfos.allInstances().stream().filter( moduleInfo -> ceresJaiCodeName.equals(moduleInfo.getCodeName())).findFirst(); if (info.isPresent()) { ClassLoader classLoader = info.get().getClassLoader(); IIORegistry iioRegistry = IIORegistry.getDefaultInstance(); iioRegistry.registerServiceProviders(IIORegistry.lookupProviders(ImageReaderSpi.class, classLoader)); iioRegistry.registerServiceProviders(IIORegistry.lookupProviders(ImageWriterSpi.class, classLoader)); } else { LOG.warning(String.format("Module '%s' not found. Not able to load image-IO services.", ceresJaiCodeName)); } }
/** * 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; }
private static void initIIOReadFormats() { List spis = new ArrayList(); List shortNames = new ArrayList(); ImageIO.scanForPlugins(); IIORegistry registry = IIORegistry.getDefaultInstance(); java.util.Iterator readerspis = registry.getServiceProviders(ImageReaderSpi.class, false); while (readerspis.hasNext()) { // REMIND: there could be more than one non-core plugin for // a particular format, as is the case for JPEG2000 in the JAI // IIO Tools package, so we should support that somehow ImageReaderSpi spi = (ImageReaderSpi)readerspis.next(); String klass = spi.getClass().getName(); String format = spi.getFormatNames()[0].toLowerCase(); String suffix = spi.getFileSuffixes()[0].toLowerCase(); if (suffix == null || suffix.equals("")) { suffix = format; } String shortName; if (klass.startsWith("com.sun.imageio.plugins")) { shortName = "core-" + suffix; } else { shortName = "ext-" + suffix; } spis.add(spi); shortNames.add(shortName); } imageioReaderSpis = new ImageReaderSpi[spis.size()]; imageioReaderSpis = (ImageReaderSpi[])spis.toArray(imageioReaderSpis); imageioReadFormatShortNames = new String[shortNames.size()]; imageioReadFormatShortNames = (String[])shortNames.toArray(imageioReadFormatShortNames); }
private static void initIIOWriteFormats() { List spis = new ArrayList(); List shortNames = new ArrayList(); ImageIO.scanForPlugins(); IIORegistry registry = IIORegistry.getDefaultInstance(); java.util.Iterator writerspis = registry.getServiceProviders(ImageWriterSpi.class, false); while (writerspis.hasNext()) { // REMIND: there could be more than one non-core plugin for // a particular format, as is the case for JPEG2000 in the JAI // IIO Tools package, so we should support that somehow ImageWriterSpi spi = (ImageWriterSpi)writerspis.next(); String klass = spi.getClass().getName(); String format = spi.getFormatNames()[0].toLowerCase(); String suffix = spi.getFileSuffixes()[0].toLowerCase(); if (suffix == null || suffix.equals("")) { suffix = format; } String shortName; if (klass.startsWith("com.sun.imageio.plugins")) { shortName = "core-" + suffix; } else { shortName = "ext-" + suffix; } spis.add(spi); shortNames.add(shortName); } imageioWriterSpis = new ImageWriterSpi[spis.size()]; imageioWriterSpis = (ImageWriterSpi[])spis.toArray(imageioWriterSpis); imageioWriteFormatShortNames = new String[shortNames.size()]; imageioWriteFormatShortNames = (String[])shortNames.toArray(imageioWriteFormatShortNames); }
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 while (iter.hasNext()) { final WriteAfterAbort writeAfterAbort = new WriteAfterAbort(); final ImageWriter writer = iter.next().createWriterInstance(); System.out.println("ImageWriter = " + writer); writeAfterAbort.test(writer); } System.out.println("Test passed"); }
public static void main(final String[] args) throws Exception { final IIORegistry registry = IIORegistry.getDefaultInstance(); final Iterator<ImageWriterSpi> iter = registry.getServiceProviders(ImageWriterSpi.class, provider -> true, true); // Validates all supported ImageWriters while (iter.hasNext()) { final ImageWriter writer = iter.next().createWriterInstance(); System.out.println("ImageWriter = " + writer); test(writer); } System.out.println("Test passed"); }
public void run() { // System.out.println("Thread " + threadName + " in thread group " + // getThreadGroup().getName()); // Create a new AppContext as though we were an applet SunToolkit.createNewAppContext(); // Get default registry and store reference this.registry = IIORegistry.getDefaultInstance(); for (int i = 0; i < 10; i++) { // System.out.println(threadName + // ": setting cache parameters to " + // useCache + ", " + cacheDirectory); ImageIO.setUseCache(useCache); ImageIO.setCacheDirectory(cacheDirectory); try { sleep(1000L); } catch (InterruptedException e) { } // System.out.println(threadName + ": reading cache parameters"); boolean newUseCache = ImageIO.getUseCache(); File newCacheDirectory = ImageIO.getCacheDirectory(); if (newUseCache != useCache || newCacheDirectory != cacheDirectory) { // System.out.println(threadName + ": got " + // newUseCache + ", " + // newCacheDirectory); // System.out.println(threadName + ": crosstalk encountered!"); gotCrosstalk = true; } } }
public DeregisterAllSpiTest() throws Exception { ImageReaderSpi BMPSpi = new BMPImageReaderSPI(); IIORegistry.getDefaultInstance().registerServiceProvider(BMPSpi); System.out.println("Reader Format Names available in the registry"); String formatNames[] = ImageIO.getReaderFormatNames(); if( formatNames == null || formatNames.length <= 0) { throw new RuntimeException("No registered ImageReaders!"); } for (int x=0; x < formatNames.length; x++) { System.out.println("format "+formatNames[x]); } IIORegistry.getDefaultInstance().deregisterAll(); System.out.println("\nReader Format Names after deregistering all SPIs"); formatNames = ImageIO.getReaderFormatNames(); if(formatNames.length == 0) { System.out.println("No readers available\n"); } else { throw new RuntimeException("Some providers was not deregistered!"); } IIORegistry.getDefaultInstance().registerServiceProvider(BMPSpi); System.out.println("Reader Format Names after re-register of BMP Plugin"); formatNames = ImageIO.getReaderFormatNames(); if(formatNames.length == 0) { throw new RuntimeException("Unable to register new SPI after deregisterAll()!"); } }
public RegisterPluginTwiceTest() throws Exception { BMPImageReaderSPI BMPSpi = new BMPImageReaderSPI(); BMPImageReaderSPI BMPSpi1 = new BMPImageReaderSPI(); IIORegistry regis = IIORegistry.getDefaultInstance(); boolean res1 = regis.registerServiceProvider(BMPSpi, javax.imageio.spi.ImageReaderSpi.class); boolean res2 = regis.registerServiceProvider(BMPSpi1, javax.imageio.spi.ImageReaderSpi.class); if(!res1 || res2) { throw new RuntimeException("Bad returned values for registerServiceProvider"); } Iterator it = regis.getServiceProviders(Class.forName("javax.imageio.spi.ImageReaderSpi"), true); int count = 0; while (it.hasNext()) { Object o = it.next(); if(o instanceof BMPImageReaderSPI) { count++; System.out.println("Found next BMPImageReaderSPI, count = " +count); } } if(count > 1) { throw new RuntimeException("Too many instances of the BMPImageReaderSPI was registered!"); } }
protected void clearImageIORegistry() { IIORegistry registry = IIORegistry.getDefaultInstance(); Iterator<Class<?>> categories = registry.getCategories(); final ClassLoader webClassLoader = getWebApplicationClassLoader(); ServiceRegistry.Filter classLoaderFilter = provider -> { //remove all service provider loaded by the current ClassLoader return webClassLoader.equals(provider.getClass().getClassLoader()); }; while (categories.hasNext()) { @SuppressWarnings("unchecked") Class<IIOServiceProvider> category = (Class<IIOServiceProvider>) categories.next(); Iterator<IIOServiceProvider> serviceProviders = registry.getServiceProviders(category, classLoaderFilter, true); if (serviceProviders.hasNext()) { info("removing service provider of category: " + category.getSimpleName()); //copy to list LinkedList<IIOServiceProvider> serviceProviderList = new LinkedList<>(); while (serviceProviders.hasNext()) { serviceProviderList.add(serviceProviders.next()); } for (IIOServiceProvider serviceProvider : serviceProviderList) { info(" - removing: " + serviceProvider.getDescription(Locale.ROOT)); registry.deregisterServiceProvider(serviceProvider); } } } }