| /* |
| * 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 android.filterfw; |
| |
| import android.content.Context; |
| import android.filterfw.core.AsyncRunner; |
| import android.filterfw.core.FilterGraph; |
| import android.filterfw.core.FilterContext; |
| import android.filterfw.core.FrameManager; |
| import android.filterfw.core.GraphRunner; |
| import android.filterfw.core.RoundRobinScheduler; |
| import android.filterfw.core.SyncRunner; |
| import android.filterfw.io.GraphIOException; |
| import android.filterfw.io.GraphReader; |
| import android.filterfw.io.TextGraphReader; |
| |
| import java.util.ArrayList; |
| |
| /** |
| * A GraphEnvironment provides a simple front-end to filter graph setup and execution using the |
| * mobile filter framework. Typically, you use a GraphEnvironment in the following fashion: |
| * 1. Instantiate a new GraphEnvironment instance. |
| * 2. Perform any configuration, such as adding graph references and setting a GL environment. |
| * 3. Load a graph file using loadGraph() or add a graph using addGraph(). |
| * 4. Obtain a GraphRunner instance using getRunner(). |
| * 5. Execute the obtained runner. |
| * Note that it is possible to add multiple graphs and runners to a single GraphEnvironment. |
| * |
| * @hide |
| */ |
| public class GraphEnvironment extends MffEnvironment { |
| |
| public static final int MODE_ASYNCHRONOUS = 1; |
| public static final int MODE_SYNCHRONOUS = 2; |
| |
| private GraphReader mGraphReader; |
| private ArrayList<GraphHandle> mGraphs = new ArrayList<GraphHandle>(); |
| |
| private class GraphHandle { |
| private FilterGraph mGraph; |
| private AsyncRunner mAsyncRunner; |
| private SyncRunner mSyncRunner; |
| |
| public GraphHandle(FilterGraph graph) { |
| mGraph = graph; |
| } |
| |
| public FilterGraph getGraph() { |
| return mGraph; |
| } |
| |
| public AsyncRunner getAsyncRunner(FilterContext environment) { |
| if (mAsyncRunner == null) { |
| mAsyncRunner = new AsyncRunner(environment, RoundRobinScheduler.class); |
| mAsyncRunner.setGraph(mGraph); |
| } |
| return mAsyncRunner; |
| } |
| |
| public GraphRunner getSyncRunner(FilterContext environment) { |
| if (mSyncRunner == null) { |
| mSyncRunner = new SyncRunner(environment, mGraph, RoundRobinScheduler.class); |
| } |
| return mSyncRunner; |
| } |
| } |
| |
| /** |
| * Create a new GraphEnvironment with default components. |
| */ |
| public GraphEnvironment() { |
| super(null); |
| } |
| |
| /** |
| * Create a new GraphEnvironment with a custom FrameManager and GraphReader. Specifying null |
| * for either of these, will auto-create a default instance. |
| * |
| * @param frameManager The FrameManager to use, or null to auto-create one. |
| * @param reader The GraphReader to use for graph loading, or null to auto-create one. |
| * Note, that the reader will not be created until it is required. Pass |
| * null if you will not load any graph files. |
| */ |
| public GraphEnvironment(FrameManager frameManager, GraphReader reader) { |
| super(frameManager); |
| mGraphReader = reader; |
| } |
| |
| /** |
| * Returns the used graph reader. This will create one, if a reader has not been set already. |
| */ |
| public GraphReader getGraphReader() { |
| if (mGraphReader == null) { |
| mGraphReader = new TextGraphReader(); |
| } |
| return mGraphReader; |
| } |
| |
| /** |
| * Add graph references to resolve during graph reading. The references added here are shared |
| * among all graphs. |
| * |
| * @param references An alternating argument list of keys (Strings) and values. |
| */ |
| public void addReferences(Object... references) { |
| getGraphReader().addReferencesByKeysAndValues(references); |
| } |
| |
| /** |
| * Loads a graph file from the specified resource and adds it to this environment. |
| * |
| * @param context The context in which to read the resource. |
| * @param resourceId The ID of the graph resource to load. |
| * @return A unique ID for the graph. |
| */ |
| public int loadGraph(Context context, int resourceId) { |
| // Read the file into a graph |
| FilterGraph graph = null; |
| try { |
| graph = getGraphReader().readGraphResource(context, resourceId); |
| } catch (GraphIOException e) { |
| throw new RuntimeException("Could not read graph: " + e.getMessage()); |
| } |
| |
| // Add graph to our list of graphs |
| return addGraph(graph); |
| } |
| |
| /** |
| * Add a graph to the environment. Consider using loadGraph() if you are loading a graph from |
| * a graph file. |
| * |
| * @param graph The graph to add to the environment. |
| * @return A unique ID for the added graph. |
| */ |
| public int addGraph(FilterGraph graph) { |
| GraphHandle graphHandle = new GraphHandle(graph); |
| mGraphs.add(graphHandle); |
| return mGraphs.size() - 1; |
| } |
| |
| /** |
| * Access a specific graph of this environment given a graph ID (previously returned from |
| * loadGraph() or addGraph()). Throws an InvalidArgumentException if no graph with the |
| * specified ID could be found. |
| * |
| * @param graphId The ID of the graph to get. |
| * @return The graph with the specified ID. |
| */ |
| public FilterGraph getGraph(int graphId) { |
| if (graphId < 0 || graphId >= mGraphs.size()) { |
| throw new IllegalArgumentException( |
| "Invalid graph ID " + graphId + " specified in runGraph()!"); |
| } |
| return mGraphs.get(graphId).getGraph(); |
| } |
| |
| /** |
| * Get a GraphRunner instance for the graph with the specified ID. The GraphRunner instance can |
| * be used to execute the graph. Throws an InvalidArgumentException if no graph with the |
| * specified ID could be found. |
| * |
| * @param graphId The ID of the graph to get. |
| * @param executionMode The mode of graph execution. Currently this can be either |
| MODE_SYNCHRONOUS or MODE_ASYNCHRONOUS. |
| * @return A GraphRunner instance for this graph. |
| */ |
| public GraphRunner getRunner(int graphId, int executionMode) { |
| switch (executionMode) { |
| case MODE_ASYNCHRONOUS: |
| return mGraphs.get(graphId).getAsyncRunner(getContext()); |
| |
| case MODE_SYNCHRONOUS: |
| return mGraphs.get(graphId).getSyncRunner(getContext()); |
| |
| default: |
| throw new RuntimeException( |
| "Invalid execution mode " + executionMode + " specified in getRunner()!"); |
| } |
| } |
| |
| } |