private Iterator<ImageReaderSpi> getJPEGProviders() { return IIORegistry.getDefaultInstance().getServiceProviders( ImageReaderSpi.class, new ServiceRegistry.Filter() { public boolean filter(Object provider) { if (provider instanceof ImageReaderSpi) { ImageReaderSpi spi = (ImageReaderSpi) provider; for (String format : spi.getFormatNames()) { if ("JPEG".equals(format)) { return true; } } } return false; } }, true ); }
final IIORegistry ioRegistry = IIORegistry.getDefaultInstance(); Set<IIOServiceProvider> providersToUnload = new HashSet(); for (Iterator<Class<?>> cats = ioRegistry.getCategories(); cats.hasNext(); ) { Class<?> category = cats.next(); for (Iterator it = ioRegistry.getServiceProviders(category, false); it.hasNext(); ) { final IIOServiceProvider provider = (IIOServiceProvider) it.next(); ioRegistry.deregisterServiceProvider(provider); LOGGER.info("Unregistering Image I/O provider " + provider);
T standard = null; T codeclib = null; final IIORegistry registry = IIORegistry.getDefaultInstance(); for (final Iterator<T> it = registry.getServiceProviders(category, false); it.hasNext(); ) { final T provider = it.next(); final String[] formats = provider.getFormatNames(); registry.setOrdering(category, codeclib, standard); } else { registry.setOrdering(category, standard, codeclib);
/** * Unregisters providers in the "https://github.com/geosolutions-it/evo-odas/issues/102" for a * given category (reader, writer). ImageIO contains a pure java reader and a writer, but also a * couple based on native libs (if present). * * @param category */ private <T extends ImageReaderWriterSpi> void unregisterImageIOJpeg2000Support( Class<T> category) { IIORegistry registry = IIORegistry.getDefaultInstance(); Iterator<T> it = registry.getServiceProviders(category, false); ArrayList<T> providers = Lists.newArrayList(it); for (T spi : providers) { if (COM_SUN_JPEG2000_PACKAGE.equals(spi.getClass().getPackage().getName())) { registry.deregisterServiceProvider(spi); } } }
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); } } }
@Test public void testJPEG2000Registration() { IIORegistry registry = IIORegistry.getDefaultInstance(); assertNoSunJPEG2000(registry, ImageReaderSpi.class); assertNoSunJPEG2000(registry, ImageWriterSpi.class); }
private static void deregisterOSXTIFFImageReaderSpi() { IIORegistry registry = IIORegistry.getDefaultInstance(); ImageReaderSpi provider = lookupProviderByName(registry, "com.sun.imageio.plugins.tiff.TIFFImageReaderSpi", ImageReaderSpi.class); if (provider != null) { registry.deregisterServiceProvider(provider); } } }
/** Set up the JPEG-2000 image reader. */ private J2KImageReader getReader() { final IIORegistry registry = IIORegistry.getDefaultInstance(); final Iterator<J2KImageReaderSpi> iter = ServiceRegistry.lookupProviders(J2KImageReaderSpi.class); registry.registerServiceProviders(iter); final J2KImageReaderSpi spi = registry.getServiceProviderByClass(J2KImageReaderSpi.class); return new J2KImageReader(spi); }
Iterator<ImageWriterSpi> services = registry.getServiceProviders(ImageWriterSpi.class, new ServiceRegistry.Filter() { @Override
IIORegistry.getDefaultInstance().registerServiceProvider(new URLImageInputStreamSpi()); ImageIO.setUseCache(false);
private ImageIOInitializer(List<String> excludedSpis) { // Setting of the excluded spis this.excludedSpis = excludedSpis; // Check if the plugins for Writers and Readers have been already registered registry = IIORegistry.getDefaultInstance(); ImageWriterSpi provider = registry.getServiceProviderByClass(GIFImageWriterSpi.class); // If it is not registered you have to scan for the requested plugins if (provider == null) { if (LOGGER.isLoggable(Level.FINER)) { LOGGER.log(Level.FINER, "Something must be registered"); } ImageIO.scanForPlugins(); removeSpis(); } }
/** Register the JPEG-2000 readers with the reader service. */ private static IIORegistry registerServiceProviders() { IIORegistry registry = IIORegistry.getDefaultInstance(); Iterator<J2KImageReaderSpi> iter = ServiceLoader.load(J2KImageReaderSpi.class).iterator(); registry.registerServiceProviders(iter); return registry; }
@Test public void testDestroyConcurrentModRegression() { ServletContext context = mock(ServletContext.class); ServletContextEvent destroyed = mock(ServletContextEvent.class); when(destroyed.getServletContext()).thenReturn(context); ServletContextListener listener = new IIOProviderContextListener(); listener.contextInitialized(mock(ServletContextEvent.class)); ImageReaderSpi provider1 = new MockImageReaderSpiOne(); ImageReaderSpi provider2 = new MockImageReaderSpiToo(); // NOTE: Fake registering for simplicity, but it still exposes the original problem with de-registering IIORegistry registry = IIORegistry.getDefaultInstance(); registry.registerServiceProvider(provider1); registry.registerServiceProvider(provider2); assertTrue(registry.contains(provider1)); assertTrue(registry.contains(provider2)); listener.contextDestroyed(destroyed); assertFalse(registry.contains(provider1)); assertFalse(registry.contains(provider2)); }
writerSpiIter = theRegistry.getServiceProviders(ImageWriterSpi.class, false); } catch (IllegalArgumentException e) { return null; ImageReaderSpi readerSpi = (ImageReaderSpi) theRegistry.getServiceProviderByClass(readerSpiClass); if (readerSpi == null) { return null; } catch (IOException e) { theRegistry.deregisterServiceProvider(readerSpi, ImageReaderSpi.class); return null;
public static BufferedImage readTiff(String url) throws IOException { if (!IIORegistry.lookupProviders(Class.forName(JavaImageEditor.TIFF_READER_CLASS)).hasNext()) { IIORegistry.getDefaultInstance().registerServiceProvider(Class.forName(JavaImageEditor.TIFF_READER_CLASS).newInstance());
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)); } }
// Get the global registry IIORegistry registry = IIORegistry.getDefaultInstance(); // Lookup the known TIFF providers ImageReaderSpi jaiProvider = lookupProviderByName(registry, "com.sun.media.imageioimpl.plugins.tiff.TIFFImageReader"); ImageReaderSpi geoProvider = lookupProviderByName(registry, "it.geosolutions.imageioimpl.plugins.tiff.TIFFImageReader"); if (jaiProvider != null && geoProvider != null) { // If both are found, EITHER // order the it.geosolutions provider BEFORE the com.sun (JAI) provider registry.setOrdering(ImageReaderSpi.class, geoProvider, jaiProvider); // OR // un-register the JAI provider registry.deregisterServiceProvider(jaiProvider); }
/** Private method for deregistering the Spi class defined by the user */ private void removeSpis() { // Cycle on the defined SPIs for deregistering them if (excludedSpis != null && !excludedSpis.isEmpty()) { for (String spi : excludedSpis) { try { // Reflection: Get the class associated to the spi name Class<?> clazz = Class.forName(spi); // Check if the Service Provider has been registered Object provider = registry.getServiceProviderByClass(clazz); // If so, the Provider is deregistered if (provider != null) { registry.deregisterServiceProvider(provider); } } catch (ClassNotFoundException e) { // If the Class is not present, then the Provider cannot have been // registered if (LOGGER.isLoggable(Level.FINER)) { LOGGER.log(Level.FINER, e.getMessage(), e); } } } } }
/** Set up the JPEG-2000 image reader. */ private J2KImageReader getReader() { J2KImageReaderSpi spi = serviceRegistry.getServiceProviderByClass(J2KImageReaderSpi.class); return new J2KImageReader(spi); }
public ImageWriter next() { ImageWriterSpi spi = null; try { spi = (ImageWriterSpi) iter.next(); return spi.createWriterInstance(); } catch (IOException e) { // Deregister the spi in this case, but only as a writerSpi theRegistry.deregisterServiceProvider(spi, ImageWriterSpi.class); } return null; }