tests/tests/hardware/src/android/hardware/camera2/cts/rs/Script.java - platform/cts - Git at Google

 /*
  * Copyright 2014 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 android.hardware.camera2.cts.rs;

 import static android.hardware.camera2.cts.helpers.Preconditions.*;

 import android.hardware.camera2.cts.helpers.UncheckedCloseable;
 import android.renderscript.Allocation;
 import android.renderscript.RenderScript;
 import android.util.Log;

 import java.util.HashMap;

 /**
  * Base class for all renderscript script abstractions.
  *
  * <p>Each script has exactly one input and one output allocation, and is able to execute
  * one {@link android.renderscript.Script} script file.</p>
  *
  * <p>Each script owns it's input allocation, but not the output allocation.</p>
  *
  * <p>Subclasses of this class must implement exactly one of two constructors:
  * <ul>
  * <li>{@code ScriptSubclass(AllocationInfo inputInfo)}
  *  - if it expects 0 parameters
  * <li>{@code ScriptSubclass(AllocationInfo inputInfo, ParameterMap<T> parameterMap))}
  *  - if it expects 1 or more parameters
  * </ul>
  *
  * @param <T> A concrete subclass of {@link android.renderscript.Script}
  */
 public abstract class Script<T extends android.renderscript.Script> implements UncheckedCloseable {

     /**
      * A type-safe heterogenous parameter map for script parameters.
      *
      * @param <ScriptT> A concrete subclass of {@link Script}.
      */
     public static class ParameterMap<ScriptT extends Script<?>> {
         private final HashMap<Script.ScriptParameter<ScriptT, ?>, Object> mParameterMap =
                 new HashMap<Script.ScriptParameter<ScriptT, ?>, Object>();

         /**
          * Create a new parameter map with 0 parameters.</p>
          */
         public ParameterMap() {}

         /**
          * Get the value associated with the given parameter key.
          *
          * @param parameter A type-safe key corresponding to a parameter.
          *
          * @return The value, or {@code null} if none was set.
          *
          * @param <T> The type of the value
          *
          * @throws NullPointerException if parameter was {@code null}
          */
         @SuppressWarnings("unchecked")
         public <T> T get(Script.ScriptParameter<ScriptT, T> parameter) {
             checkNotNull("parameter", parameter);

             return (T) mParameterMap.get(parameter);
         }

         /**
          * Sets the value associated with the given parameter key.
          *
          * @param parameter A type-safe key corresponding to a parameter.
          * @param value The value
          *
          * @param <T> The type of the value
          *
          * @throws NullPointerException if parameter was {@code null}
          * @throws NullPointerException if value was {@code null}
          */
         public <T> void set(Script.ScriptParameter<ScriptT, T> parameter, T value) {
             checkNotNull("parameter", parameter);
             checkNotNull("value", value);

             if (!parameter.getValueClass().isInstance(value)) {
                 throw new IllegalArgumentException(
                         "Runtime type mismatch between " + parameter + " and value " + value);
             }

             mParameterMap.put(parameter, value);
         }

         /**
          * Whether or not at least one parameter has been {@link #set}.
          *
          * @return true if there is at least one element in the map
          */
         public boolean isEmpty() {
             return mParameterMap.isEmpty();
         }

         /**
          * Check if the parameter has been {@link #set} to a value.
          *
          * @param parameter A type-safe key corresponding to a parameter.
          * @return true if there is a value corresponding to this parameter, false otherwise.
          */
         public boolean contains(Script.ScriptParameter<ScriptT, ?> parameter) {
             checkNotNull("parameter", parameter);

             return mParameterMap.containsKey(parameter);
         }
     }

     /**
      * A type-safe parameter key to be used with {@link ParameterMap}.
      *
      * @param <J> A concrete subclass of {@link Script}.
      * @param <K> The type of the value that the parameter holds.
      */
     public static class ScriptParameter<J extends Script<?>, K> {
         private final Class<J> mScriptClass;
         private final Class<K> mValueClass;

         ScriptParameter(Class<J> jClass, Class<K> kClass) {
             checkNotNull("jClass", jClass);
             checkNotNull("kClass", kClass);

             mScriptClass = jClass;
             mValueClass = kClass;
         }

         /**
          * Get the runtime class associated with the value.
          */
         public Class<K> getValueClass() {
             return mValueClass;
         }

         /**
          * Compare with another object.
          *
          * <p>Two script parameters are considered equal only if their script class and value
          * class are both equal.</p>
          */
         @SuppressWarnings("unchecked")
         @Override
         public boolean equals(Object other) {
             if (other instanceof ScriptParameter) {
                 ScriptParameter<J, K> otherParam = (ScriptParameter<J,K>) other;

                 return mScriptClass.equals(otherParam.mScriptClass) &&
                         mValueClass.equals(otherParam.mValueClass);
             }

             return false;
         }

         /**
          * Gets the hash code for this object.
          */
         @Override
         public int hashCode() {
             return mScriptClass.hashCode() ^ mValueClass.hashCode();
         }
     }

     private static final String TAG = "Script";
     private static final boolean VERBOSE = Log.isLoggable(TAG, Log.VERBOSE);

     protected final AllocationCache mCache = RenderScriptSingleton.getCache();
     protected final RenderScript mRS = RenderScriptSingleton.getRS();

     protected final AllocationInfo mInputInfo;
     protected final AllocationInfo mOutputInfo;

     protected Allocation mOutputAllocation;
     protected Allocation mInputAllocation;

     protected final T mScript;
     private boolean mClosed = false;

     /**
      * Gets the {@link AllocationInfo info} associated with this script's input.
      *
      * @return A non-{@code null} {@link AllocationInfo} object.
      *
      * @throws IllegalStateException If the script has already been {@link #close closed}.
      */
     public AllocationInfo getInputInfo() {
         checkNotClosed();

         return mInputInfo;
     }
     /**
      * Gets the {@link AllocationInfo info} associated with this script's output.
      *
      * @return A non-{@code null} {@link AllocationInfo} object.
      *
      * @throws IllegalStateException If the script has already been {@link #close closed}.
      */
     public AllocationInfo getOutputInfo() {
         checkNotClosed();

         return mOutputInfo;
     }

     /**
      * Set the input.
      *
      * <p>Must be called before executing any scripts.</p>
      *
      * @throws IllegalStateException If the script has already been {@link #close closed}.
      */
     void setInput(Allocation allocation) {
         checkNotClosed();
         checkNotNull("allocation", allocation);
         checkEquals("allocation info", AllocationInfo.newInstance(allocation),
                 "input info", mInputInfo);

         // Scripts own the input, so return old input to cache if the input changes
         if (mInputAllocation != allocation) {
             mCache.returnToCacheIfNotNull(mInputAllocation);
         }

         mInputAllocation = allocation;
         updateScriptInput();
     }

     protected abstract void updateScriptInput();

     /**
      * Set the output.
      *
      * <p>Must be called before executing any scripts.</p>
      *
      * @throws IllegalStateException If the script has already been {@link #close closed}.
      */
     void setOutput(Allocation allocation) {
         checkNotClosed();
         checkNotNull("allocation", allocation);
         checkEquals("allocation info", AllocationInfo.newInstance(allocation),
                 "output info", mOutputInfo);

         // Scripts do not own the output, simply set a reference to the new one.
         mOutputAllocation = allocation;
     }

     protected Script(AllocationInfo inputInfo, AllocationInfo outputInfo, T rsScript) {
         checkNotNull("inputInfo", inputInfo);
         checkNotNull("outputInfo", outputInfo);
         checkNotNull("rsScript", rsScript);

         mInputInfo = inputInfo;
         mOutputInfo = outputInfo;
         mScript = rsScript;

         if (VERBOSE) {
             Log.v(TAG, String.format("%s - inputInfo = %s, outputInfo = %s, rsScript = %s",
                     getName(), inputInfo, outputInfo, rsScript));
         }
     }

     /**
      * Get the {@link Allocation} associated with this script's input.</p>
      *
      * @return The input {@link Allocation}, which is never {@code null}.
      *
      * @throws IllegalStateException If the script has already been {@link #close closed}.
      */
     public Allocation getInput() {
         checkNotClosed();

         return mInputAllocation;
     }
     /**
      * Get the {@link Allocation} associated with this script's output.</p>
      *
      * @return The output {@link Allocation}, which is never {@code null}.
      *
      * @throws IllegalStateException If the script has already been {@link #close closed}.
      */
     public Allocation getOutput() {
         checkNotClosed();

         return mOutputAllocation;
     }

     /**
      * Execute the script's kernel against the input/output {@link Allocation allocations}.
      *
      * <p>Once this is complete, the output will have the new data available (for either
      * the next script, or to read out with a copy).</p>
      *
      * @throws IllegalStateException If the script has already been {@link #close closed}.
      */
     public void execute() {
         checkNotClosed();

         if (mInputAllocation == null || mOutputAllocation == null) {
             throw new IllegalStateException("Both inputs and outputs must have been set");
         }

         executeUnchecked();
     }

     /**
      * Get the name of this script.
      *
      * <p>The name is the short hand name of the concrete class backing this script.</p>
      *
      * <p>This method works even if the script has already been {@link #close closed}.</p>
      *
      * @return A string representing the script name.
      */
     public String getName() {
         return getClass().getSimpleName();
     }

     protected abstract void executeUnchecked();

     protected void checkNotClosed() {
         if (mClosed) {
             throw new IllegalStateException("Script has been closed");
         }
     }

     /**
      * Destroy the underlying script object and return the input allocation back to the
      * {@link AllocationCache cache}.
      *
      * <p>This method has no effect if called more than once.</p>
      */
     @Override
     public void close() {
         if (mClosed) return;

         // Scripts own the input allocation. They do NOT own outputs.
         mCache.returnToCacheIfNotNull(mInputAllocation);

         mScript.destroy();

         mClosed = true;
     }

     @Override
     protected void finalize() throws Throwable {
         try {
             close();
         } finally {
             super.finalize();
         }
     }

     protected static RenderScript getRS() {
         return RenderScriptSingleton.getRS();
     }
 }
	/*
	* Copyright 2014 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 android.hardware.camera2.cts.rs;

	import static android.hardware.camera2.cts.helpers.Preconditions.*;

	import android.hardware.camera2.cts.helpers.UncheckedCloseable;
	import android.renderscript.Allocation;
	import android.renderscript.RenderScript;
	import android.util.Log;

	import java.util.HashMap;

	/**
	* Base class for all renderscript script abstractions.
	*
	* <p>Each script has exactly one input and one output allocation, and is able to execute
	* one {@link android.renderscript.Script} script file.</p>
	*
	* <p>Each script owns it's input allocation, but not the output allocation.</p>
	*
	* <p>Subclasses of this class must implement exactly one of two constructors:
	* <ul>
	* <li>{@code ScriptSubclass(AllocationInfo inputInfo)}
	* - if it expects 0 parameters
	* <li>{@code ScriptSubclass(AllocationInfo inputInfo, ParameterMap<T> parameterMap))}
	* - if it expects 1 or more parameters
	* </ul>
	*
	* @param <T> A concrete subclass of {@link android.renderscript.Script}
	*/
	public abstract class Script<T extends android.renderscript.Script> implements UncheckedCloseable {

	/**
	* A type-safe heterogenous parameter map for script parameters.
	*
	* @param <ScriptT> A concrete subclass of {@link Script}.
	*/
	public static class ParameterMap<ScriptT extends Script<?>> {
	private final HashMap<Script.ScriptParameter<ScriptT, ?>, Object> mParameterMap =
	new HashMap<Script.ScriptParameter<ScriptT, ?>, Object>();

	/**
	* Create a new parameter map with 0 parameters.</p>
	*/
	public ParameterMap() {}

	/**
	* Get the value associated with the given parameter key.
	*
	* @param parameter A type-safe key corresponding to a parameter.
	*
	* @return The value, or {@code null} if none was set.
	*
	* @param <T> The type of the value
	*
	* @throws NullPointerException if parameter was {@code null}
	*/
	@SuppressWarnings("unchecked")
	public <T> T get(Script.ScriptParameter<ScriptT, T> parameter) {
	checkNotNull("parameter", parameter);

	return (T) mParameterMap.get(parameter);
	}

	/**
	* Sets the value associated with the given parameter key.
	*
	* @param parameter A type-safe key corresponding to a parameter.
	* @param value The value
	*
	* @param <T> The type of the value
	*
	* @throws NullPointerException if parameter was {@code null}
	* @throws NullPointerException if value was {@code null}
	*/
	public <T> void set(Script.ScriptParameter<ScriptT, T> parameter, T value) {
	checkNotNull("parameter", parameter);
	checkNotNull("value", value);

	if (!parameter.getValueClass().isInstance(value)) {
	throw new IllegalArgumentException(
	"Runtime type mismatch between " + parameter + " and value " + value);
	}

	mParameterMap.put(parameter, value);
	}

	/**
	* Whether or not at least one parameter has been {@link #set}.
	*
	* @return true if there is at least one element in the map
	*/
	public boolean isEmpty() {
	return mParameterMap.isEmpty();
	}

	/**
	* Check if the parameter has been {@link #set} to a value.
	*
	* @param parameter A type-safe key corresponding to a parameter.
	* @return true if there is a value corresponding to this parameter, false otherwise.
	*/
	public boolean contains(Script.ScriptParameter<ScriptT, ?> parameter) {
	checkNotNull("parameter", parameter);

	return mParameterMap.containsKey(parameter);
	}
	}

	/**
	* A type-safe parameter key to be used with {@link ParameterMap}.
	*
	* @param <J> A concrete subclass of {@link Script}.
	* @param <K> The type of the value that the parameter holds.
	*/
	public static class ScriptParameter<J extends Script<?>, K> {
	private final Class<J> mScriptClass;
	private final Class<K> mValueClass;

	ScriptParameter(Class<J> jClass, Class<K> kClass) {
	checkNotNull("jClass", jClass);
	checkNotNull("kClass", kClass);

	mScriptClass = jClass;
	mValueClass = kClass;
	}

	/**
	* Get the runtime class associated with the value.
	*/
	public Class<K> getValueClass() {
	return mValueClass;
	}

	/**
	* Compare with another object.
	*
	* <p>Two script parameters are considered equal only if their script class and value
	* class are both equal.</p>
	*/
	@SuppressWarnings("unchecked")
	@Override
	public boolean equals(Object other) {
	if (other instanceof ScriptParameter) {
	ScriptParameter<J, K> otherParam = (ScriptParameter<J,K>) other;

	return mScriptClass.equals(otherParam.mScriptClass) &&
	mValueClass.equals(otherParam.mValueClass);
	}

	return false;
	}

	/**
	* Gets the hash code for this object.
	*/
	@Override
	public int hashCode() {
	return mScriptClass.hashCode() ^ mValueClass.hashCode();
	}
	}

	private static final String TAG = "Script";
	private static final boolean VERBOSE = Log.isLoggable(TAG, Log.VERBOSE);

	protected final AllocationCache mCache = RenderScriptSingleton.getCache();
	protected final RenderScript mRS = RenderScriptSingleton.getRS();

	protected final AllocationInfo mInputInfo;
	protected final AllocationInfo mOutputInfo;

	protected Allocation mOutputAllocation;
	protected Allocation mInputAllocation;

	protected final T mScript;
	private boolean mClosed = false;

	/**
	* Gets the {@link AllocationInfo info} associated with this script's input.
	*
	* @return A non-{@code null} {@link AllocationInfo} object.
	*
	* @throws IllegalStateException If the script has already been {@link #close closed}.
	*/
	public AllocationInfo getInputInfo() {
	checkNotClosed();

	return mInputInfo;
	}
	/**
	* Gets the {@link AllocationInfo info} associated with this script's output.
	*
	* @return A non-{@code null} {@link AllocationInfo} object.
	*
	* @throws IllegalStateException If the script has already been {@link #close closed}.
	*/
	public AllocationInfo getOutputInfo() {
	checkNotClosed();

	return mOutputInfo;
	}

	/**
	* Set the input.
	*
	* <p>Must be called before executing any scripts.</p>
	*
	* @throws IllegalStateException If the script has already been {@link #close closed}.
	*/
	void setInput(Allocation allocation) {
	checkNotClosed();
	checkNotNull("allocation", allocation);
	checkEquals("allocation info", AllocationInfo.newInstance(allocation),
	"input info", mInputInfo);

	// Scripts own the input, so return old input to cache if the input changes
	if (mInputAllocation != allocation) {
	mCache.returnToCacheIfNotNull(mInputAllocation);
	}

	mInputAllocation = allocation;
	updateScriptInput();
	}

	protected abstract void updateScriptInput();

	/**
	* Set the output.
	*
	* <p>Must be called before executing any scripts.</p>
	*
	* @throws IllegalStateException If the script has already been {@link #close closed}.
	*/
	void setOutput(Allocation allocation) {
	checkNotClosed();
	checkNotNull("allocation", allocation);
	checkEquals("allocation info", AllocationInfo.newInstance(allocation),
	"output info", mOutputInfo);

	// Scripts do not own the output, simply set a reference to the new one.
	mOutputAllocation = allocation;
	}

	protected Script(AllocationInfo inputInfo, AllocationInfo outputInfo, T rsScript) {
	checkNotNull("inputInfo", inputInfo);
	checkNotNull("outputInfo", outputInfo);
	checkNotNull("rsScript", rsScript);

	mInputInfo = inputInfo;
	mOutputInfo = outputInfo;
	mScript = rsScript;

	if (VERBOSE) {
	Log.v(TAG, String.format("%s - inputInfo = %s, outputInfo = %s, rsScript = %s",
	getName(), inputInfo, outputInfo, rsScript));
	}
	}

	/**
	* Get the {@link Allocation} associated with this script's input.</p>
	*
	* @return The input {@link Allocation}, which is never {@code null}.
	*
	* @throws IllegalStateException If the script has already been {@link #close closed}.
	*/
	public Allocation getInput() {
	checkNotClosed();

	return mInputAllocation;
	}
	/**
	* Get the {@link Allocation} associated with this script's output.</p>
	*
	* @return The output {@link Allocation}, which is never {@code null}.
	*
	* @throws IllegalStateException If the script has already been {@link #close closed}.
	*/
	public Allocation getOutput() {
	checkNotClosed();

	return mOutputAllocation;
	}

	/**
	* Execute the script's kernel against the input/output {@link Allocation allocations}.
	*
	* <p>Once this is complete, the output will have the new data available (for either
	* the next script, or to read out with a copy).</p>
	*
	* @throws IllegalStateException If the script has already been {@link #close closed}.
	*/
	public void execute() {
	checkNotClosed();

	if (mInputAllocation == null \|\| mOutputAllocation == null) {
	throw new IllegalStateException("Both inputs and outputs must have been set");
	}

	executeUnchecked();
	}

	/**
	* Get the name of this script.
	*
	* <p>The name is the short hand name of the concrete class backing this script.</p>
	*
	* <p>This method works even if the script has already been {@link #close closed}.</p>
	*
	* @return A string representing the script name.
	*/
	public String getName() {
	return getClass().getSimpleName();
	}

	protected abstract void executeUnchecked();

	protected void checkNotClosed() {
	if (mClosed) {
	throw new IllegalStateException("Script has been closed");
	}
	}

	/**
	* Destroy the underlying script object and return the input allocation back to the
	* {@link AllocationCache cache}.
	*
	* <p>This method has no effect if called more than once.</p>
	*/
	@Override
	public void close() {
	if (mClosed) return;

	// Scripts own the input allocation. They do NOT own outputs.
	mCache.returnToCacheIfNotNull(mInputAllocation);

	mScript.destroy();

	mClosed = true;
	}

	@Override
	protected void finalize() throws Throwable {
	try {
	close();
	} finally {
	super.finalize();
	}
	}

	protected static RenderScript getRS() {
	return RenderScriptSingleton.getRS();
	}
	}