ojluni/src/main/java/javax/swing/plaf/nimbus/ImageCache.java - platform/libcore - Git at Google

 /*
  * Copyright (c) 2005, 2006, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
  * published by the Free Software Foundation.  Oracle designates this
  * particular file as subject to the "Classpath" exception as provided
  * by Oracle in the LICENSE file that accompanied this code.
  *
  * This code is distributed in the hope that it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  * version 2 for more details (a copy is included in the LICENSE file that
  * accompanied this code).
  *
  * You should have received a copy of the GNU General Public License version
  * 2 along with this work; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  *
  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  * or visit www.oracle.com if you need additional information or have any
  * questions.
  */
 package javax.swing.plaf.nimbus;

 import java.awt.GraphicsConfiguration;
 import java.awt.Image;
 import java.lang.ref.ReferenceQueue;
 import java.lang.ref.SoftReference;
 import java.util.Arrays;
 import java.util.Iterator;
 import java.util.LinkedHashMap;
 import java.util.Map;
 import java.util.concurrent.locks.ReadWriteLock;
 import java.util.concurrent.locks.ReentrantReadWriteLock;

 /**
  * ImageCache - A fixed pixel count sized cache of Images keyed by arbitrary set of arguments. All images are held with
  * SoftReferences so they will be dropped by the GC if heap memory gets tight. When our size hits max pixel count least
  * recently requested images are removed first.
  *
  * @author Created by Jasper Potts (Aug 7, 2007)
  */
 class ImageCache {
     // Ordered Map keyed by args hash, ordered by most recent accessed entry.
     private final LinkedHashMap<Integer, PixelCountSoftReference> map =
             new LinkedHashMap<Integer, PixelCountSoftReference>(16, 0.75f, true);
     // Maximum number of pixels to cache, this is used if maxCount
     private final int maxPixelCount;
     // Maximum cached image size in pxiels
     private final int maxSingleImagePixelSize;
     // The current number of pixels stored in the cache
     private int currentPixelCount = 0;
     // Lock for concurrent access to map
     private ReadWriteLock lock = new ReentrantReadWriteLock();
     // Reference queue for tracking lost softreferences to images in the cache
     private ReferenceQueue<Image> referenceQueue = new ReferenceQueue<Image>();
     // Singleton Instance
     private static final ImageCache instance = new ImageCache();


     /** Get static singleton instance */
     static ImageCache getInstance() {
         return instance;
     }

     public ImageCache() {
         this.maxPixelCount = (8 * 1024 * 1024) / 4; // 8Mb of pixels
         this.maxSingleImagePixelSize = 300 * 300;
     }

     public ImageCache(int maxPixelCount, int maxSingleImagePixelSize) {
         this.maxPixelCount = maxPixelCount;
         this.maxSingleImagePixelSize = maxSingleImagePixelSize;
     }

     /** Clear the cache */
     public void flush() {
         lock.readLock().lock();
         try {
             map.clear();
         } finally {
             lock.readLock().unlock();
         }
     }

     /**
      * Check if the image size is to big to be stored in the cache
      *
      * @param w The image width
      * @param h The image height
      * @return True if the image size is less than max
      */
     public boolean isImageCachable(int w, int h) {
         return (w * h) < maxSingleImagePixelSize;
     }

     /**
      * Get the cached image for given keys
      *
      * @param config The graphics configuration, needed if cached image is a Volatile Image. Used as part of cache key
      * @param w      The image width, used as part of cache key
      * @param h      The image height, used as part of cache key
      * @param args   Other arguments to use as part of the cache key
      * @return Returns the cached Image, or null there is no cached image for key
      */
     public Image getImage(GraphicsConfiguration config, int w, int h, Object... args) {
         lock.readLock().lock();
         try {
             PixelCountSoftReference ref = map.get(hash(config, w, h, args));
             // check reference has not been lost and the key truly matches, in case of false positive hash match
             if (ref != null && ref.equals(config,w, h, args)) {
                 return ref.get();
             } else {
                 return null;
             }
         } finally {
             lock.readLock().unlock();
         }
     }

     /**
      * Sets the cached image for the specified constraints.
      *
      * @param image  The image to store in cache
      * @param config The graphics configuration, needed if cached image is a Volatile Image. Used as part of cache key
      * @param w      The image width, used as part of cache key
      * @param h      The image height, used as part of cache key
      * @param args   Other arguments to use as part of the cache key
      * @return true if the image could be cached or false if the image is too big
      */
     public boolean setImage(Image image, GraphicsConfiguration config, int w, int h, Object... args) {
         if (!isImageCachable(w, h)) return false;
         int hash = hash(config, w, h, args);
         lock.writeLock().lock();
         try {
             PixelCountSoftReference ref = map.get(hash);
             // check if currently in map
             if (ref != null && ref.get() == image) {
                 return true;
             }
             // clear out old
             if (ref != null) {
                 currentPixelCount -= ref.pixelCount;
                 map.remove(hash);
             }
             // add new image to pixel count
             int newPixelCount = image.getWidth(null) * image.getHeight(null);
             currentPixelCount += newPixelCount;
             // clean out lost references if not enough space
             if (currentPixelCount > maxPixelCount) {
                 while ((ref = (PixelCountSoftReference)referenceQueue.poll()) != null){
                     //reference lost
                     map.remove(ref.hash);
                     currentPixelCount -= ref.pixelCount;
                 }
             }
             // remove old items till there is enough free space
             if (currentPixelCount > maxPixelCount) {
                 Iterator<Map.Entry<Integer, PixelCountSoftReference>> mapIter = map.entrySet().iterator();
                 while ((currentPixelCount > maxPixelCount) && mapIter.hasNext()) {
                     Map.Entry<Integer, PixelCountSoftReference> entry = mapIter.next();
                     mapIter.remove();
                     Image img = entry.getValue().get();
                     if (img != null) img.flush();
                     currentPixelCount -= entry.getValue().pixelCount;
                 }
             }
             // finaly put new in map
             map.put(hash, new PixelCountSoftReference(image, referenceQueue, newPixelCount,hash, config, w, h, args));
             return true;
         } finally {
             lock.writeLock().unlock();
         }
     }

     /** Create a unique hash from all the input */
     private int hash(GraphicsConfiguration config, int w, int h, Object ... args) {
         int hash;
         hash = (config != null ? config.hashCode() : 0);
         hash = 31 * hash + w;
         hash = 31 * hash + h;
         hash = 31 * hash + Arrays.deepHashCode(args);
         return hash;
     }


     /** Extended SoftReference that stores the pixel count even after the image is lost */
     private static class PixelCountSoftReference extends SoftReference<Image> {
         private final int pixelCount;
         private final int hash;
         // key parts
         private final GraphicsConfiguration config;
         private final int w;
         private final int h;
         private final Object[] args;

         public PixelCountSoftReference(Image referent, ReferenceQueue<? super Image> q, int pixelCount, int hash,
                                        GraphicsConfiguration config, int w, int h, Object[] args) {
             super(referent, q);
             this.pixelCount = pixelCount;
             this.hash = hash;
             this.config = config;
             this.w = w;
             this.h = h;
             this.args = args;
         }

         public boolean equals (GraphicsConfiguration config, int w, int h, Object[] args){
             return config == this.config &&
                             w == this.w &&
                             h == this.h &&
                             Arrays.equals(args, this.args);
         }
     }
 }
	/*
	* Copyright (c) 2005, 2006, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation. Oracle designates this
	* particular file as subject to the "Classpath" exception as provided
	* by Oracle in the LICENSE file that accompanied this code.
	*
	* This code is distributed in the hope that it will be useful, but WITHOUT
	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*/
	package javax.swing.plaf.nimbus;

	import java.awt.GraphicsConfiguration;
	import java.awt.Image;
	import java.lang.ref.ReferenceQueue;
	import java.lang.ref.SoftReference;
	import java.util.Arrays;
	import java.util.Iterator;
	import java.util.LinkedHashMap;
	import java.util.Map;
	import java.util.concurrent.locks.ReadWriteLock;
	import java.util.concurrent.locks.ReentrantReadWriteLock;

	/**
	* ImageCache - A fixed pixel count sized cache of Images keyed by arbitrary set of arguments. All images are held with
	* SoftReferences so they will be dropped by the GC if heap memory gets tight. When our size hits max pixel count least
	* recently requested images are removed first.
	*
	* @author Created by Jasper Potts (Aug 7, 2007)
	*/
	class ImageCache {
	// Ordered Map keyed by args hash, ordered by most recent accessed entry.
	private final LinkedHashMap<Integer, PixelCountSoftReference> map =
	new LinkedHashMap<Integer, PixelCountSoftReference>(16, 0.75f, true);
	// Maximum number of pixels to cache, this is used if maxCount
	private final int maxPixelCount;
	// Maximum cached image size in pxiels
	private final int maxSingleImagePixelSize;
	// The current number of pixels stored in the cache
	private int currentPixelCount = 0;
	// Lock for concurrent access to map
	private ReadWriteLock lock = new ReentrantReadWriteLock();
	// Reference queue for tracking lost softreferences to images in the cache
	private ReferenceQueue<Image> referenceQueue = new ReferenceQueue<Image>();
	// Singleton Instance
	private static final ImageCache instance = new ImageCache();


	/** Get static singleton instance */
	static ImageCache getInstance() {
	return instance;
	}

	public ImageCache() {
	this.maxPixelCount = (8 * 1024 * 1024) / 4; // 8Mb of pixels
	this.maxSingleImagePixelSize = 300 * 300;
	}

	public ImageCache(int maxPixelCount, int maxSingleImagePixelSize) {
	this.maxPixelCount = maxPixelCount;
	this.maxSingleImagePixelSize = maxSingleImagePixelSize;
	}

	/** Clear the cache */
	public void flush() {
	lock.readLock().lock();
	try {
	map.clear();
	} finally {
	lock.readLock().unlock();
	}
	}

	/**
	* Check if the image size is to big to be stored in the cache
	*
	* @param w The image width
	* @param h The image height
	* @return True if the image size is less than max
	*/
	public boolean isImageCachable(int w, int h) {
	return (w * h) < maxSingleImagePixelSize;
	}

	/**
	* Get the cached image for given keys
	*
	* @param config The graphics configuration, needed if cached image is a Volatile Image. Used as part of cache key
	* @param w The image width, used as part of cache key
	* @param h The image height, used as part of cache key
	* @param args Other arguments to use as part of the cache key
	* @return Returns the cached Image, or null there is no cached image for key
	*/
	public Image getImage(GraphicsConfiguration config, int w, int h, Object... args) {
	lock.readLock().lock();
	try {
	PixelCountSoftReference ref = map.get(hash(config, w, h, args));
	// check reference has not been lost and the key truly matches, in case of false positive hash match
	if (ref != null && ref.equals(config,w, h, args)) {
	return ref.get();
	} else {
	return null;
	}
	} finally {
	lock.readLock().unlock();
	}
	}

	/**
	* Sets the cached image for the specified constraints.
	*
	* @param image The image to store in cache
	* @param config The graphics configuration, needed if cached image is a Volatile Image. Used as part of cache key
	* @param w The image width, used as part of cache key
	* @param h The image height, used as part of cache key
	* @param args Other arguments to use as part of the cache key
	* @return true if the image could be cached or false if the image is too big
	*/
	public boolean setImage(Image image, GraphicsConfiguration config, int w, int h, Object... args) {
	if (!isImageCachable(w, h)) return false;
	int hash = hash(config, w, h, args);
	lock.writeLock().lock();
	try {
	PixelCountSoftReference ref = map.get(hash);
	// check if currently in map
	if (ref != null && ref.get() == image) {
	return true;
	}
	// clear out old
	if (ref != null) {
	currentPixelCount -= ref.pixelCount;
	map.remove(hash);
	}
	// add new image to pixel count
	int newPixelCount = image.getWidth(null) * image.getHeight(null);
	currentPixelCount += newPixelCount;
	// clean out lost references if not enough space
	if (currentPixelCount > maxPixelCount) {
	while ((ref = (PixelCountSoftReference)referenceQueue.poll()) != null){
	//reference lost
	map.remove(ref.hash);
	currentPixelCount -= ref.pixelCount;
	}
	}
	// remove old items till there is enough free space
	if (currentPixelCount > maxPixelCount) {
	Iterator<Map.Entry<Integer, PixelCountSoftReference>> mapIter = map.entrySet().iterator();
	while ((currentPixelCount > maxPixelCount) && mapIter.hasNext()) {
	Map.Entry<Integer, PixelCountSoftReference> entry = mapIter.next();
	mapIter.remove();
	Image img = entry.getValue().get();
	if (img != null) img.flush();
	currentPixelCount -= entry.getValue().pixelCount;
	}
	}
	// finaly put new in map
	map.put(hash, new PixelCountSoftReference(image, referenceQueue, newPixelCount,hash, config, w, h, args));
	return true;
	} finally {
	lock.writeLock().unlock();
	}
	}

	/** Create a unique hash from all the input */
	private int hash(GraphicsConfiguration config, int w, int h, Object ... args) {
	int hash;
	hash = (config != null ? config.hashCode() : 0);
	hash = 31 * hash + w;
	hash = 31 * hash + h;
	hash = 31 * hash + Arrays.deepHashCode(args);
	return hash;
	}


	/** Extended SoftReference that stores the pixel count even after the image is lost */
	private static class PixelCountSoftReference extends SoftReference<Image> {
	private final int pixelCount;
	private final int hash;
	// key parts
	private final GraphicsConfiguration config;
	private final int w;
	private final int h;
	private final Object[] args;

	public PixelCountSoftReference(Image referent, ReferenceQueue<? super Image> q, int pixelCount, int hash,
	GraphicsConfiguration config, int w, int h, Object[] args) {
	super(referent, q);
	this.pixelCount = pixelCount;
	this.hash = hash;
	this.config = config;
	this.w = w;
	this.h = h;
	this.args = args;
	}

	public boolean equals (GraphicsConfiguration config, int w, int h, Object[] args){
	return config == this.config &&
	w == this.w &&
	h == this.h &&
	Arrays.equals(args, this.args);
	}
	}
	}