tests/Camera2Tests/SmartCamera/SimpleCamera/src/androidx/media/filterfw/FrameManager.java - platform/frameworks/base - Gitiles

 /*
  * Copyright (C) 2011 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 package androidx.media.filterfw;

 import androidx.media.filterfw.BackingStore.Backing;

 import java.util.Arrays;
 import java.util.Comparator;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Map;
 import java.util.PriorityQueue;
 import java.util.Set;

 /**
  * The FrameManager tracks, caches, allocates and deallocates frame data.
  * All Frame instances are managed by a FrameManager, and belong to exactly one of these. Frames
  * cannot be shared across FrameManager instances, however multiple MffContexts may use the same
  * FrameManager.
  *
  * Additionally, frame managers allow attaching Frames under a specified key. This allows decoupling
  * filter-graphs by instructing one node to attach a frame under a specific key, and another to
  * fetch the frame under the same key.
  */
 public class FrameManager {

     /** The default max cache size is set to 12 MB */
     public final static int DEFAULT_MAX_CACHE_SIZE = 12 * 1024 * 1024;

     /** Frame caching policy: No caching */
     public final static int FRAME_CACHE_NONE = 0;
     /** Frame caching policy: Drop least recently used frame buffers */
     public final static int FRAME_CACHE_LRU = 1;
     /** Frame caching policy: Drop least frequently used frame buffers */
     public final static int FRAME_CACHE_LFU = 2;

     /** Slot Flag: No flags set */
     public final static int SLOT_FLAGS_NONE = 0x00;
     /** Slot Flag: Sticky flag set: Frame will remain in slot after fetch. */
     public final static int SLOT_FLAG_STICKY = 0x01;

     private GraphRunner mRunner;
     private Set<Backing> mBackings = new HashSet<Backing>();
     private BackingCache mCache;

     private Map<String, FrameSlot> mFrameSlots = new HashMap<String, FrameSlot>();

     static class FrameSlot {
         private FrameType mType;
         private int mFlags;
         private Frame mFrame = null;

         public FrameSlot(FrameType type, int flags) {
             mType = type;
             mFlags = flags;
         }

         public FrameType getType() {
             return mType;
         }

         public boolean hasFrame() {
             return mFrame != null;
         }

         public void releaseFrame() {
             if (mFrame != null) {
                 mFrame.release();
                 mFrame = null;
             }
         }

         // TODO: Type check
         public void assignFrame(Frame frame) {
             Frame oldFrame = mFrame;
             mFrame = frame.retain();
             if (oldFrame != null) {
                 oldFrame.release();
             }
         }

         public Frame getFrame() {
             Frame result = mFrame.retain();
             if ((mFlags & SLOT_FLAG_STICKY) == 0) {
                 releaseFrame();
             }
             return result;
         }

         public void markWritable() {
             if (mFrame != null) {
                 mFrame.setReadOnly(false);
             }
         }
     }

     private static abstract class BackingCache {

         protected int mCacheMaxSize = DEFAULT_MAX_CACHE_SIZE;

         public abstract Backing fetchBacking(int mode, int access, int[] dimensions, int elemSize);

         public abstract boolean cacheBacking(Backing backing);

         public abstract void clear();

         public abstract int getSizeLeft();

         public void setSize(int size) {
             mCacheMaxSize = size;
         }

         public int getSize() {
             return mCacheMaxSize;
         }
     }

     private static class BackingCacheNone extends BackingCache {

         @Override
         public Backing fetchBacking(int mode, int access, int[] dimensions, int elemSize) {
             return null;
         }

         @Override
         public boolean cacheBacking(Backing backing) {
             return false;
         }

         @Override
         public void clear() {
         }

         @Override
         public int getSize() {
             return 0;
         }

         @Override
         public int getSizeLeft() {
             return 0;
         }
     }

     private static abstract class PriorityBackingCache extends BackingCache {
         private int mSize = 0;
         private PriorityQueue<Backing> mQueue;

         public PriorityBackingCache() {
             mQueue = new PriorityQueue<Backing>(4, new Comparator<Backing>() {
                 @Override
                 public int compare(Backing left, Backing right) {
                     return left.cachePriority - right.cachePriority;
                 }
             });
         }

         @Override
         public Backing fetchBacking(int mode, int access, int[] dimensions, int elemSize) {
             for (Backing backing : mQueue) {
                 int backingAccess = (mode == Frame.MODE_WRITE)
                     ? backing.writeAccess()
                     : backing.readAccess();
                 if ((backingAccess & access) == access
                     && dimensionsCompatible(backing.getDimensions(), dimensions)
                     && (elemSize == backing.getElementSize())) {
                     mQueue.remove(backing);
                     mSize -= backing.getSize();
                     onFetchBacking(backing);
                     return backing;
                 }
             }
             //Log.w("FrameManager", "Could not find backing for dimensions " + Arrays.toString(dimensions));
             return null;
         }

         @Override
         public boolean cacheBacking(Backing backing) {
             if (reserve(backing.getSize())) {
                 onCacheBacking(backing);
                 mQueue.add(backing);
                 return true;
             }
             return false;
         }

         @Override
         public void clear() {
             mQueue.clear();
             mSize = 0;
         }

         @Override
         public int getSizeLeft() {
             return mCacheMaxSize - mSize;
         }

         protected abstract void onCacheBacking(Backing backing);

         protected abstract void onFetchBacking(Backing backing);

         private boolean reserve(int size) {
             //Log.i("FM", "Reserving " + size + " bytes (max: " + mCacheMaxSize + " bytes).");
             //Log.i("FM", "Current size " + mSize);
             if (size > mCacheMaxSize) {
                 return false;
             }
             mSize += size;
             while (mSize > mCacheMaxSize) {
                 Backing dropped = mQueue.poll();
                 mSize -= dropped.getSize();
                 //Log.i("FM", "Dropping  " + dropped + " with priority "
                 //    + dropped.cachePriority + ". New size: " + mSize + "!");
                 dropped.destroy();
             }
             return true;
         }


     }

     private static class BackingCacheLru extends PriorityBackingCache {
         private int mTimestamp = 0;

         @Override
         protected void onCacheBacking(Backing backing) {
             backing.cachePriority = 0;
         }

         @Override
         protected void onFetchBacking(Backing backing) {
             ++mTimestamp;
             backing.cachePriority = mTimestamp;
         }
     }

     private static class BackingCacheLfu extends PriorityBackingCache {
         @Override
         protected void onCacheBacking(Backing backing) {
             backing.cachePriority = 0;
         }

         @Override
         protected void onFetchBacking(Backing backing) {
             ++backing.cachePriority;
         }
     }

     public static FrameManager current() {
         GraphRunner runner = GraphRunner.current();
         return runner != null ? runner.getFrameManager() : null;
     }

     /**
      * Returns the context that the FrameManager is bound to.
      *
      * @return the MffContext instance that the FrameManager is bound to.
      */
     public MffContext getContext() {
         return mRunner.getContext();
     }

     /**
      * Returns the GraphRunner that the FrameManager is bound to.
      *
      * @return the GraphRunner instance that the FrameManager is bound to.
      */
     public GraphRunner getRunner() {
         return mRunner;
     }

     /**
      * Sets the size of the cache.
      *
      * Resizes the cache to the specified size in bytes.
      *
      * @param bytes the new size in bytes.
      */
     public void setCacheSize(int bytes) {
         mCache.setSize(bytes);
     }

     /**
      * Returns the size of the cache.
      *
      * @return the size of the cache in bytes.
      */
     public int getCacheSize() {
         return mCache.getSize();
     }

     /**
      * Imports a frame from another FrameManager.
      *
      * This will return a frame with the contents of the given frame for use in this FrameManager.
      * Note, that there is a substantial cost involved in moving a Frame from one FrameManager to
      * another. This may be called from any thread. After the frame has been imported, it may be
      * used in the runner that uses this FrameManager. As the new frame may share data with the
      * provided frame, that frame must be read-only.
      *
      * @param frame The frame to import
      */
     public Frame importFrame(Frame frame) {
         if (!frame.isReadOnly()) {
             throw new IllegalArgumentException("Frame " + frame + " must be read-only to import "
                     + "into another FrameManager!");
         }
         return frame.makeCpuCopy(this);
     }

     /**
      * Adds a new frame slot to the frame manager.
      * Filters can reference frame slots to pass frames between graphs or runs. If the name
      * specified here is already taken the frame slot is overwritten. You can only
      * modify frame-slots while no graph of the frame manager is running.
      *
      * @param name The name of the slot.
      * @param type The type of Frame that will be assigned to this slot.
      * @param flags A mask of {@code SLOT} flags.
      */
     public void addFrameSlot(String name, FrameType type, int flags) {
         assertNotRunning();
         FrameSlot oldSlot = mFrameSlots.get(name);
         if (oldSlot != null) {
             removeFrameSlot(name);
         }
         FrameSlot slot = new FrameSlot(type, flags);
         mFrameSlots.put(name, slot);
     }

     /**
      * Removes a frame slot from the frame manager.
      * Any frame within the slot is released. You can only modify frame-slots while no graph
      * of the frame manager is running.
      *
      * @param name The name of the slot
      * @throws IllegalArgumentException if no such slot exists.
      */
     public void removeFrameSlot(String name) {
         assertNotRunning();
         FrameSlot slot = getSlot(name);
         slot.releaseFrame();
         mFrameSlots.remove(slot);
     }

     /**
      * TODO: Document!
      */
     public void storeFrame(Frame frame, String slotName) {
         assertInGraphRun();
         getSlot(slotName).assignFrame(frame);
     }

     /**
      * TODO: Document!
      */
     public Frame fetchFrame(String slotName) {
         assertInGraphRun();
         return getSlot(slotName).getFrame();
     }

     /**
      * Clears the Frame cache.
      */
     public void clearCache() {
         mCache.clear();
     }

     /**
      * Create a new FrameManager instance.
      *
      * Creates a new FrameManager instance in the specified context and employing a cache with the
      * specified cache type (see the cache type constants defined by the FrameManager class).
      *
      * @param runner the GraphRunner to bind the FrameManager to.
      * @param cacheType the type of cache to use.
      */
     FrameManager(GraphRunner runner, int cacheType) {
         mRunner = runner;
         switch (cacheType) {
             case FRAME_CACHE_NONE:
                 mCache = new BackingCacheNone();
                 break;
             case FRAME_CACHE_LRU:
                 mCache = new BackingCacheLru();
                 break;
             case FRAME_CACHE_LFU:
                 mCache = new BackingCacheLfu();
                 break;
             default:
                 throw new IllegalArgumentException("Unknown cache-type " + cacheType + "!");
         }
     }

     Backing fetchBacking(int mode, int access, int[] dimensions, int elemSize) {
         return mCache.fetchBacking(mode, access, dimensions, elemSize);
     }

     void onBackingCreated(Backing backing) {
         if (backing != null) {
             mBackings.add(backing);
             // Log.i("FrameManager", "RM: Now have " + mBackings.size() + " backings");
         }
     }

     void onBackingAvailable(Backing backing) {
         if (!backing.shouldCache() || !mCache.cacheBacking(backing)) {
             backing.destroy();
             mBackings.remove(backing);
             //Log.i("FrameManager", "RM: Now have " + mBackings.size() + " backings (" + mCache.getSizeLeft() + ")");
         }
     }

     /**
      * Destroying all references makes any Frames that contain them invalid.
      */
     void destroyBackings() {
         for (Backing backing : mBackings) {
             backing.destroy();
         }
         mBackings.clear();
         mCache.clear();
     }

     FrameSlot getSlot(String name) {
         FrameSlot slot = mFrameSlots.get(name);
         if (slot == null) {
             throw new IllegalArgumentException("Unknown frame slot '" + name + "'!");
         }
         return slot;
     }

     void onBeginRun() {
         for (FrameSlot slot : mFrameSlots.values()) {
             slot.markWritable();
         }
     }

     // Internals ///////////////////////////////////////////////////////////////////////////////////
     private static boolean dimensionsCompatible(int[] dimA, int[] dimB) {
         return dimA == null || dimB == null || Arrays.equals(dimA, dimB);
     }

     private void assertNotRunning() {
         if (mRunner.isRunning()) {
             throw new IllegalStateException("Attempting to modify FrameManager while graph is "
                 + "running!");
         }
     }

     private void assertInGraphRun() {
         if (!mRunner.isRunning() || GraphRunner.current() != mRunner) {
             throw new IllegalStateException("Attempting to access FrameManager Frame data "
                 + "outside of graph run-loop!");
         }
     }

 }
	/*
	* Copyright (C) 2011 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package androidx.media.filterfw;

	import androidx.media.filterfw.BackingStore.Backing;

	import java.util.Arrays;
	import java.util.Comparator;
	import java.util.HashMap;
	import java.util.HashSet;
	import java.util.Map;
	import java.util.PriorityQueue;
	import java.util.Set;

	/**
	* The FrameManager tracks, caches, allocates and deallocates frame data.
	* All Frame instances are managed by a FrameManager, and belong to exactly one of these. Frames
	* cannot be shared across FrameManager instances, however multiple MffContexts may use the same
	* FrameManager.
	*
	* Additionally, frame managers allow attaching Frames under a specified key. This allows decoupling
	* filter-graphs by instructing one node to attach a frame under a specific key, and another to
	* fetch the frame under the same key.
	*/
	public class FrameManager {

	/** The default max cache size is set to 12 MB */
	public final static int DEFAULT_MAX_CACHE_SIZE = 12 * 1024 * 1024;

	/** Frame caching policy: No caching */
	public final static int FRAME_CACHE_NONE = 0;
	/** Frame caching policy: Drop least recently used frame buffers */
	public final static int FRAME_CACHE_LRU = 1;
	/** Frame caching policy: Drop least frequently used frame buffers */
	public final static int FRAME_CACHE_LFU = 2;

	/** Slot Flag: No flags set */
	public final static int SLOT_FLAGS_NONE = 0x00;
	/** Slot Flag: Sticky flag set: Frame will remain in slot after fetch. */
	public final static int SLOT_FLAG_STICKY = 0x01;

	private GraphRunner mRunner;
	private Set<Backing> mBackings = new HashSet<Backing>();
	private BackingCache mCache;

	private Map<String, FrameSlot> mFrameSlots = new HashMap<String, FrameSlot>();

	static class FrameSlot {
	private FrameType mType;
	private int mFlags;
	private Frame mFrame = null;

	public FrameSlot(FrameType type, int flags) {
	mType = type;
	mFlags = flags;
	}

	public FrameType getType() {
	return mType;
	}

	public boolean hasFrame() {
	return mFrame != null;
	}

	public void releaseFrame() {
	if (mFrame != null) {
	mFrame.release();
	mFrame = null;
	}
	}

	// TODO: Type check
	public void assignFrame(Frame frame) {
	Frame oldFrame = mFrame;
	mFrame = frame.retain();
	if (oldFrame != null) {
	oldFrame.release();
	}
	}

	public Frame getFrame() {
	Frame result = mFrame.retain();
	if ((mFlags & SLOT_FLAG_STICKY) == 0) {
	releaseFrame();
	}
	return result;
	}

	public void markWritable() {
	if (mFrame != null) {
	mFrame.setReadOnly(false);
	}
	}
	}

	private static abstract class BackingCache {

	protected int mCacheMaxSize = DEFAULT_MAX_CACHE_SIZE;

	public abstract Backing fetchBacking(int mode, int access, int[] dimensions, int elemSize);

	public abstract boolean cacheBacking(Backing backing);

	public abstract void clear();

	public abstract int getSizeLeft();

	public void setSize(int size) {
	mCacheMaxSize = size;
	}

	public int getSize() {
	return mCacheMaxSize;
	}
	}

	private static class BackingCacheNone extends BackingCache {

	@Override
	public Backing fetchBacking(int mode, int access, int[] dimensions, int elemSize) {
	return null;
	}

	@Override
	public boolean cacheBacking(Backing backing) {
	return false;
	}

	@Override
	public void clear() {
	}

	@Override
	public int getSize() {
	return 0;
	}

	@Override
	public int getSizeLeft() {
	return 0;
	}
	}

	private static abstract class PriorityBackingCache extends BackingCache {
	private int mSize = 0;
	private PriorityQueue<Backing> mQueue;

	public PriorityBackingCache() {
	mQueue = new PriorityQueue<Backing>(4, new Comparator<Backing>() {
	@Override
	public int compare(Backing left, Backing right) {
	return left.cachePriority - right.cachePriority;
	}
	});
	}

	@Override
	public Backing fetchBacking(int mode, int access, int[] dimensions, int elemSize) {
	for (Backing backing : mQueue) {
	int backingAccess = (mode == Frame.MODE_WRITE)
	? backing.writeAccess()
	: backing.readAccess();
	if ((backingAccess & access) == access
	&& dimensionsCompatible(backing.getDimensions(), dimensions)
	&& (elemSize == backing.getElementSize())) {
	mQueue.remove(backing);
	mSize -= backing.getSize();
	onFetchBacking(backing);
	return backing;
	}
	}
	//Log.w("FrameManager", "Could not find backing for dimensions " + Arrays.toString(dimensions));
	return null;
	}

	@Override
	public boolean cacheBacking(Backing backing) {
	if (reserve(backing.getSize())) {
	onCacheBacking(backing);
	mQueue.add(backing);
	return true;
	}
	return false;
	}

	@Override
	public void clear() {
	mQueue.clear();
	mSize = 0;
	}

	@Override
	public int getSizeLeft() {
	return mCacheMaxSize - mSize;
	}

	protected abstract void onCacheBacking(Backing backing);

	protected abstract void onFetchBacking(Backing backing);

	private boolean reserve(int size) {
	//Log.i("FM", "Reserving " + size + " bytes (max: " + mCacheMaxSize + " bytes).");
	//Log.i("FM", "Current size " + mSize);
	if (size > mCacheMaxSize) {
	return false;
	}
	mSize += size;
	while (mSize > mCacheMaxSize) {
	Backing dropped = mQueue.poll();
	mSize -= dropped.getSize();
	//Log.i("FM", "Dropping " + dropped + " with priority "
	// + dropped.cachePriority + ". New size: " + mSize + "!");
	dropped.destroy();
	}
	return true;
	}


	}

	private static class BackingCacheLru extends PriorityBackingCache {
	private int mTimestamp = 0;

	@Override
	protected void onCacheBacking(Backing backing) {
	backing.cachePriority = 0;
	}

	@Override
	protected void onFetchBacking(Backing backing) {
	++mTimestamp;
	backing.cachePriority = mTimestamp;
	}
	}

	private static class BackingCacheLfu extends PriorityBackingCache {
	@Override
	protected void onCacheBacking(Backing backing) {
	backing.cachePriority = 0;
	}

	@Override
	protected void onFetchBacking(Backing backing) {
	++backing.cachePriority;
	}
	}

	public static FrameManager current() {
	GraphRunner runner = GraphRunner.current();
	return runner != null ? runner.getFrameManager() : null;
	}

	/**
	* Returns the context that the FrameManager is bound to.
	*
	* @return the MffContext instance that the FrameManager is bound to.
	*/
	public MffContext getContext() {
	return mRunner.getContext();
	}

	/**
	* Returns the GraphRunner that the FrameManager is bound to.
	*
	* @return the GraphRunner instance that the FrameManager is bound to.
	*/
	public GraphRunner getRunner() {
	return mRunner;
	}

	/**
	* Sets the size of the cache.
	*
	* Resizes the cache to the specified size in bytes.
	*
	* @param bytes the new size in bytes.
	*/
	public void setCacheSize(int bytes) {
	mCache.setSize(bytes);
	}

	/**
	* Returns the size of the cache.
	*
	* @return the size of the cache in bytes.
	*/
	public int getCacheSize() {
	return mCache.getSize();
	}

	/**
	* Imports a frame from another FrameManager.
	*
	* This will return a frame with the contents of the given frame for use in this FrameManager.
	* Note, that there is a substantial cost involved in moving a Frame from one FrameManager to
	* another. This may be called from any thread. After the frame has been imported, it may be
	* used in the runner that uses this FrameManager. As the new frame may share data with the
	* provided frame, that frame must be read-only.
	*
	* @param frame The frame to import
	*/
	public Frame importFrame(Frame frame) {
	if (!frame.isReadOnly()) {
	throw new IllegalArgumentException("Frame " + frame + " must be read-only to import "
	+ "into another FrameManager!");
	}
	return frame.makeCpuCopy(this);
	}

	/**
	* Adds a new frame slot to the frame manager.
	* Filters can reference frame slots to pass frames between graphs or runs. If the name
	* specified here is already taken the frame slot is overwritten. You can only
	* modify frame-slots while no graph of the frame manager is running.
	*
	* @param name The name of the slot.
	* @param type The type of Frame that will be assigned to this slot.
	* @param flags A mask of {@code SLOT} flags.
	*/
	public void addFrameSlot(String name, FrameType type, int flags) {
	assertNotRunning();
	FrameSlot oldSlot = mFrameSlots.get(name);
	if (oldSlot != null) {
	removeFrameSlot(name);
	}
	FrameSlot slot = new FrameSlot(type, flags);
	mFrameSlots.put(name, slot);
	}

	/**
	* Removes a frame slot from the frame manager.
	* Any frame within the slot is released. You can only modify frame-slots while no graph
	* of the frame manager is running.
	*
	* @param name The name of the slot
	* @throws IllegalArgumentException if no such slot exists.
	*/
	public void removeFrameSlot(String name) {
	assertNotRunning();
	FrameSlot slot = getSlot(name);
	slot.releaseFrame();
	mFrameSlots.remove(slot);
	}

	/**
	* TODO: Document!
	*/
	public void storeFrame(Frame frame, String slotName) {
	assertInGraphRun();
	getSlot(slotName).assignFrame(frame);
	}

	/**
	* TODO: Document!
	*/
	public Frame fetchFrame(String slotName) {
	assertInGraphRun();
	return getSlot(slotName).getFrame();
	}

	/**
	* Clears the Frame cache.
	*/
	public void clearCache() {
	mCache.clear();
	}

	/**
	* Create a new FrameManager instance.
	*
	* Creates a new FrameManager instance in the specified context and employing a cache with the
	* specified cache type (see the cache type constants defined by the FrameManager class).
	*
	* @param runner the GraphRunner to bind the FrameManager to.
	* @param cacheType the type of cache to use.
	*/
	FrameManager(GraphRunner runner, int cacheType) {
	mRunner = runner;
	switch (cacheType) {
	case FRAME_CACHE_NONE:
	mCache = new BackingCacheNone();
	break;
	case FRAME_CACHE_LRU:
	mCache = new BackingCacheLru();
	break;
	case FRAME_CACHE_LFU:
	mCache = new BackingCacheLfu();
	break;
	default:
	throw new IllegalArgumentException("Unknown cache-type " + cacheType + "!");
	}
	}

	Backing fetchBacking(int mode, int access, int[] dimensions, int elemSize) {
	return mCache.fetchBacking(mode, access, dimensions, elemSize);
	}

	void onBackingCreated(Backing backing) {
	if (backing != null) {
	mBackings.add(backing);
	// Log.i("FrameManager", "RM: Now have " + mBackings.size() + " backings");
	}
	}

	void onBackingAvailable(Backing backing) {
	if (!backing.shouldCache() \|\| !mCache.cacheBacking(backing)) {
	backing.destroy();
	mBackings.remove(backing);
	//Log.i("FrameManager", "RM: Now have " + mBackings.size() + " backings (" + mCache.getSizeLeft() + ")");
	}
	}

	/**
	* Destroying all references makes any Frames that contain them invalid.
	*/
	void destroyBackings() {
	for (Backing backing : mBackings) {
	backing.destroy();
	}
	mBackings.clear();
	mCache.clear();
	}

	FrameSlot getSlot(String name) {
	FrameSlot slot = mFrameSlots.get(name);
	if (slot == null) {
	throw new IllegalArgumentException("Unknown frame slot '" + name + "'!");
	}
	return slot;
	}

	void onBeginRun() {
	for (FrameSlot slot : mFrameSlots.values()) {
	slot.markWritable();
	}
	}

	// Internals ///////////////////////////////////////////////////////////////////////////////////
	private static boolean dimensionsCompatible(int[] dimA, int[] dimB) {
	return dimA == null \|\| dimB == null \|\| Arrays.equals(dimA, dimB);
	}

	private void assertNotRunning() {
	if (mRunner.isRunning()) {
	throw new IllegalStateException("Attempting to modify FrameManager while graph is "
	+ "running!");
	}
	}

	private void assertInGraphRun() {
	if (!mRunner.isRunning() \|\| GraphRunner.current() != mRunner) {
	throw new IllegalStateException("Attempting to access FrameManager Frame data "
	+ "outside of graph run-loop!");
	}
	}

	}