$(call add-clean-step, rm -rf $(OUT_DIR)/target/common/obj/JAVA_LIBRARIES/filterpack_ui_intermediates)
$(call add-clean-step, rm -rf $(OUT_DIR)/target/common/obj/JAVA_LIBRARIES/filterpack_videosrc_intermediates)
$(call add-clean-step, rm -rf $(PRODUCT_OUT)/obj/SHARED_LIBRARIES/libaudioutils_intermediates)
+$(call add-clean-step, rm -rf $(OUT_DIR)/target/common/obj/JAVA_LIBRARIES/filterfw_intermediates)
# ************************************************
# NEWER CLEAN STEPS MUST BE AT THE END OF THE LIST
+++ /dev/null
-# 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.
-#
-
-FILTERFW_PATH:= $(call my-dir)
-
-# for shared defintion of libfilterfw_to_document
-include $(FILTERFW_PATH)/Docs.mk
-
-#
-# Build all native libraries
-#
-include $(call all-subdir-makefiles)
-
-#
-# Build Java library from filterfw core and all open-source filterpacks
-#
-
-LOCAL_PATH := $(FILTERFW_PATH)
-include $(CLEAR_VARS)
-
-LOCAL_MODULE_TAGS := optional
-
-LOCAL_SRC_FILES := $(call libfilterfw_to_document,$(LOCAL_PATH))
-
-LOCAL_MODULE := filterfw
-
-LOCAL_JNI_SHARED_LIBRARIES := libfilterfw libfilterpack_imageproc
-
-LOCAL_PROGUARD_ENABLED := disabled
-
-LOCAL_NO_STANDARD_LIBRARIES := true
-LOCAL_JAVA_LIBRARIES := core core-junit ext framework # to avoid circular dependency
-
-include $(BUILD_JAVA_LIBRARY)
-
-#
-# Local droiddoc for faster libfilterfw docs testing
-#
-#
-# Run with:
-# m libfilterfw-docs
-#
-# Main output:
-# out/target/common/docs/libfilterfw/reference/packages.html
-#
-# All text for proofreading (or running tools over):
-# out/target/common/docs/libfilterfw-proofread.txt
-#
-# TODO list of missing javadoc, etc:
-# out/target/common/docs/libfilterfw-docs-todo.html
-#
-# Rerun:
-# rm -rf out/target/common/docs/libfilterfw-timestamp && m libfilterfw-docs
-#
-
-LOCAL_PATH := $(FILTERFW_PATH)
-include $(CLEAR_VARS)
-
-LOCAL_SRC_FILES:=$(call libfilterfw_to_document,$(LOCAL_PATH))
-
-# rerun doc generation without recompiling the java
-LOCAL_JAVA_LIBRARIES:=
-LOCAL_MODULE_CLASS:=JAVA_LIBRARIES
-
-LOCAL_MODULE := libfilterfw
-
-LOCAL_DROIDDOC_OPTIONS:= \
- -offlinemode \
- -title "libfilterfw" \
- -proofread $(OUT_DOCS)/$(LOCAL_MODULE)-proofread.txt \
- -todo ../$(LOCAL_MODULE)-docs-todo.html \
- -hdf android.whichdoc offline
-
-LOCAL_DROIDDOC_CUSTOM_TEMPLATE_DIR:=build/tools/droiddoc/templates-sdk
-
-include $(BUILD_DROIDDOC)
+++ /dev/null
-# -*- mode: makefile -*-
-#
-# 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.
-#
-
-# List of mobile filter framework directories to include in documentation/API/SDK.
-# Shared between mobile filter framework and frameworks/base.
-
-define libfilterfw-all-java-files-under
-$(patsubst ./%,%, \
- $(shell cd $(1) ; \
- find $(2) -name "*.java" -and -not -name ".*") \
- )
-endef
-
-# List of mobile filter framework source files to include in the public API/SDK.
-#
-#
-# $(1): directory for search (to support use from frameworks/base)
-define libfilterfw_to_document
- $(call libfilterfw-all-java-files-under,$(1), \
- filterfw/java \
- effect/java \
- filterpacks/java )
-endef
+++ /dev/null
-/*
- * 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.media.effect;
-
-
-/**
- * <p>Effects are high-performance transformations that can be applied to image frames. These are
- * passed in the form of OpenGL ES 2.0 texture names. Typical frames could be images loaded from
- * disk, or frames from the camera or other video streams.</p>
- *
- * <p>To create an Effect you must first create an EffectContext. You can obtain an instance of the
- * context's EffectFactory by calling
- * {@link android.media.effect.EffectContext#getFactory() getFactory()}. The EffectFactory allows
- * you to instantiate specific Effects.</p>
- *
- * <p>The application is responsible for creating an EGL context, and making it current before
- * applying an effect. An effect is bound to a single EffectContext, which in turn is bound to a
- * single EGL context. If your EGL context is destroyed, the EffectContext becomes invalid and any
- * effects bound to this context can no longer be used.</p>
- *
- */
-public abstract class Effect {
-
- /**
- * Get the effect name.
- *
- * Returns the unique name of the effect, which matches the name used for instantiating this
- * effect by the EffectFactory.
- *
- * @return The name of the effect.
- */
- public abstract String getName();
-
- /**
- * Apply an effect to GL textures.
- *
- * <p>Apply the Effect on the specified input GL texture, and write the result into the
- * output GL texture. The texture names passed must be valid in the current GL context.</p>
- *
- * <p>The input texture must be a valid texture name with the given width and height and must be
- * bound to a GL_TEXTURE_2D texture image (usually done by calling the glTexImage2D() function).
- * Multiple mipmap levels may be provided.</p>
- *
- * <p>If the output texture has not been bound to a texture image, it will be automatically
- * bound by the effect as a GL_TEXTURE_2D. It will contain one mipmap level (0), which will have
- * the same size as the input. No other mipmap levels are defined. If the output texture was
- * bound already, and its size does not match the input texture size, the result may be clipped
- * or only partially fill the texture.</p>
- *
- * <p>Note, that regardless of whether a texture image was originally provided or not, both the
- * input and output textures are owned by the caller. That is, the caller is responsible for
- * calling glDeleteTextures() to deallocate the input and output textures.</p>
- *
- * @param inputTexId The GL texture name of a valid and bound input texture.
- * @param width The width of the input texture in pixels.
- * @param height The height of the input texture in pixels.
- * @param outputTexId The GL texture name of the output texture.
- */
- public abstract void apply(int inputTexId, int width, int height, int outputTexId);
-
- /**
- * Set a filter parameter.
- *
- * Consult the effect documentation for a list of supported parameter keys for each effect.
- *
- * @param parameterKey The name of the parameter to adjust.
- * @param value The new value to set the parameter to.
- * @throws InvalidArgumentException if parameterName is not a recognized name, or the value is
- * not a valid value for this parameter.
- */
- public abstract void setParameter(String parameterKey, Object value);
-
- /**
- * Set an effect listener.
- *
- * Some effects may report state changes back to the host, if a listener is set. Consult the
- * individual effect documentation for more details.
- *
- * @param listener The listener to receive update callbacks on.
- */
- public void setUpdateListener(EffectUpdateListener listener) {
- }
-
- /**
- * Release an effect.
- *
- * <p>Releases the effect and any resources associated with it. You may call this if you need to
- * make sure acquired resources are no longer held by the effect. Releasing an effect makes it
- * invalid for reuse.</p>
- *
- * <p>Note that this method must be called with the EffectContext and EGL context current, as
- * the effect may release internal GL resources.</p>
- */
- public abstract void release();
-}
-
+++ /dev/null
-/*
- * 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.media.effect;
-
-import android.filterfw.core.CachedFrameManager;
-import android.filterfw.core.FilterContext;
-import android.filterfw.core.FilterFactory;
-import android.filterfw.core.GLEnvironment;
-import android.filterfw.core.GLFrame;
-import android.filterfw.core.FrameManager;
-import android.opengl.GLES20;
-
-/**
- * <p>An EffectContext keeps all necessary state information to run Effects within a Open GL ES 2.0
- * context.</p>
- *
- * <p>Every EffectContext is bound to one GL context. The application is responsible for creating
- * this EGL context, and making it current before applying any effect. If your EGL context is
- * destroyed, the EffectContext becomes invalid and any effects bound to this context can no longer
- * be used. If you switch to another EGL context, you must create a new EffectContext. Each Effect
- * is bound to a single EffectContext, and can only be executed in that context.</p>
- */
-public class EffectContext {
-
- private final int GL_STATE_FBO = 0;
- private final int GL_STATE_PROGRAM = 1;
- private final int GL_STATE_ARRAYBUFFER = 2;
- private final int GL_STATE_COUNT = 3;
-
- FilterContext mFilterContext;
-
- private EffectFactory mFactory;
-
- private int[] mOldState = new int[GL_STATE_COUNT];
-
- /**
- * Creates a context within the current GL context.
- *
- * <p>Binds the EffectContext to the current OpenGL context. All subsequent calls to the
- * EffectContext must be made in the GL context that was active during creation.
- * When you have finished using a context, you must call {@link #release()}. to dispose of all
- * resources associated with this context.</p>
- */
- public static EffectContext createWithCurrentGlContext() {
- EffectContext result = new EffectContext();
- result.initInCurrentGlContext();
- return result;
- }
-
- /**
- * Returns the EffectFactory for this context.
- *
- * <p>The EffectFactory returned from this method allows instantiating new effects within this
- * context.</p>
- *
- * @return The EffectFactory instance for this context.
- */
- public EffectFactory getFactory() {
- return mFactory;
- }
-
- /**
- * Releases the context.
- *
- * <p>Releases all the resources and effects associated with the EffectContext. This renders the
- * context and all the effects bound to this context invalid. You must no longer use the context
- * or any of its bound effects after calling release().</p>
- *
- * <p>Note that this method must be called with the proper EGL context made current, as the
- * EffectContext and its effects may release internal GL resources.</p>
- */
- public void release() {
- mFilterContext.tearDown();
- mFilterContext = null;
- }
-
- private EffectContext() {
- mFilterContext = new FilterContext();
- mFilterContext.setFrameManager(new CachedFrameManager());
- mFactory = new EffectFactory(this);
- }
-
- private void initInCurrentGlContext() {
- if (!GLEnvironment.isAnyContextActive()) {
- throw new RuntimeException("Attempting to initialize EffectContext with no active "
- + "GL context!");
- }
- GLEnvironment glEnvironment = new GLEnvironment();
- glEnvironment.initWithCurrentContext();
- mFilterContext.initGLEnvironment(glEnvironment);
- }
-
- final void assertValidGLState() {
- GLEnvironment glEnv = mFilterContext.getGLEnvironment();
- if (glEnv == null || !glEnv.isContextActive()) {
- if (GLEnvironment.isAnyContextActive()) {
- throw new RuntimeException("Applying effect in wrong GL context!");
- } else {
- throw new RuntimeException("Attempting to apply effect without valid GL context!");
- }
- }
- }
-
- final void saveGLState() {
- GLES20.glGetIntegerv(GLES20.GL_FRAMEBUFFER_BINDING, mOldState, GL_STATE_FBO);
- GLES20.glGetIntegerv(GLES20.GL_CURRENT_PROGRAM, mOldState, GL_STATE_PROGRAM);
- GLES20.glGetIntegerv(GLES20.GL_ARRAY_BUFFER_BINDING, mOldState, GL_STATE_ARRAYBUFFER);
- }
-
- final void restoreGLState() {
- GLES20.glBindFramebuffer(GLES20.GL_FRAMEBUFFER, mOldState[GL_STATE_FBO]);
- GLES20.glUseProgram(mOldState[GL_STATE_PROGRAM]);
- GLES20.glBindBuffer(GLES20.GL_ARRAY_BUFFER, mOldState[GL_STATE_ARRAYBUFFER]);
- }
-}
-
+++ /dev/null
-/*
- * 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.media.effect;
-
-import java.lang.reflect.Constructor;
-import java.util.HashMap;
-
-/**
- * <p>The EffectFactory class defines the list of available Effects, and provides functionality to
- * inspect and instantiate them. Some effects may not be available on all platforms, so before
- * creating a certain effect, the application should confirm that the effect is supported on this
- * platform by calling {@link #isEffectSupported(String)}.</p>
- */
-public class EffectFactory {
-
- private EffectContext mEffectContext;
-
- private final static String[] EFFECT_PACKAGES = {
- "android.media.effect.effects.", // Default effect package
- "" // Allows specifying full class path
- };
-
- /** List of Effects */
- /**
- * <p>Copies the input texture to the output.</p>
- * <p>Available parameters: None</p>
- * @hide
- */
- public final static String EFFECT_IDENTITY = "IdentityEffect";
-
- /**
- * <p>Adjusts the brightness of the image.</p>
- * <p>Available parameters:</p>
- * <table>
- * <tr><td>Parameter name</td><td>Meaning</td><td>Valid values</td></tr>
- * <tr><td><code>brightness</code></td>
- * <td>The brightness multiplier.</td>
- * <td>Positive float. 1.0 means no change;
- larger values will increase brightness.</td>
- * </tr>
- * </table>
- */
- public final static String EFFECT_BRIGHTNESS =
- "android.media.effect.effects.BrightnessEffect";
-
- /**
- * <p>Adjusts the contrast of the image.</p>
- * <p>Available parameters:</p>
- * <table>
- * <tr><td>Parameter name</td><td>Meaning</td><td>Valid values</td></tr>
- * <tr><td><code>contrast</code></td>
- * <td>The contrast multiplier.</td>
- * <td>Float. 1.0 means no change;
- larger values will increase contrast.</td>
- * </tr>
- * </table>
- */
- public final static String EFFECT_CONTRAST =
- "android.media.effect.effects.ContrastEffect";
-
- /**
- * <p>Applies a fisheye lens distortion to the image.</p>
- * <p>Available parameters:</p>
- * <table>
- * <tr><td>Parameter name</td><td>Meaning</td><td>Valid values</td></tr>
- * <tr><td><code>scale</code></td>
- * <td>The scale of the distortion.</td>
- * <td>Float, between 0 and 1. Zero means no distortion.</td>
- * </tr>
- * </table>
- */
- public final static String EFFECT_FISHEYE =
- "android.media.effect.effects.FisheyeEffect";
-
- /**
- * <p>Replaces the background of the input frames with frames from a
- * selected video. Requires an initial learning period with only the
- * background visible before the effect becomes active. The effect will wait
- * until it does not see any motion in the scene before learning the
- * background and starting the effect.</p>
- *
- * <p>Available parameters:</p>
- * <table>
- * <tr><td>Parameter name</td><td>Meaning</td><td>Valid values</td></tr>
- * <tr><td><code>source</code></td>
- * <td>A URI for the background video to use. This parameter must be
- * supplied before calling apply() for the first time.</td>
- * <td>String, such as from
- * {@link android.net.Uri#toString Uri.toString()}</td>
- * </tr>
- * </table>
- *
- * <p>If the update listener is set for this effect using
- * {@link Effect#setUpdateListener}, it will be called when the effect has
- * finished learning the background, with a null value for the info
- * parameter.</p>
- */
- public final static String EFFECT_BACKDROPPER =
- "android.media.effect.effects.BackDropperEffect";
-
- /**
- * <p>Attempts to auto-fix the image based on histogram equalization.</p>
- * <p>Available parameters:</p>
- * <table>
- * <tr><td>Parameter name</td><td>Meaning</td><td>Valid values</td></tr>
- * <tr><td><code>scale</code></td>
- * <td>The scale of the adjustment.</td>
- * <td>Float, between 0 and 1. Zero means no adjustment, while 1 indicates the maximum
- * amount of adjustment.</td>
- * </tr>
- * </table>
- */
- public final static String EFFECT_AUTOFIX =
- "android.media.effect.effects.AutoFixEffect";
-
- /**
- * <p>Adjusts the range of minimal and maximal color pixel intensities.</p>
- * <p>Available parameters:</p>
- * <table>
- * <tr><td>Parameter name</td><td>Meaning</td><td>Valid values</td></tr>
- * <tr><td><code>black</code></td>
- * <td>The value of the minimal pixel.</td>
- * <td>Float, between 0 and 1.</td>
- * </tr>
- * <tr><td><code>white</code></td>
- * <td>The value of the maximal pixel.</td>
- * <td>Float, between 0 and 1.</td>
- * </tr>
- * </table>
- */
- public final static String EFFECT_BLACKWHITE =
- "android.media.effect.effects.BlackWhiteEffect";
-
- /**
- * <p>Crops an upright rectangular area from the image. If the crop region falls outside of
- * the image bounds, the results are undefined.</p>
- * <p>Available parameters:</p>
- * <table>
- * <tr><td>Parameter name</td><td>Meaning</td><td>Valid values</td></tr>
- * <tr><td><code>xorigin</code></td>
- * <td>The origin's x-value.</td>
- * <td>Integer, between 0 and width of the image.</td>
- * </tr>
- * <tr><td><code>yorigin</code></td>
- * <td>The origin's y-value.</td>
- * <td>Integer, between 0 and height of the image.</td>
- * </tr>
- * <tr><td><code>width</code></td>
- * <td>The width of the cropped image.</td>
- * <td>Integer, between 1 and the width of the image minus xorigin.</td>
- * </tr>
- * <tr><td><code>height</code></td>
- * <td>The height of the cropped image.</td>
- * <td>Integer, between 1 and the height of the image minus yorigin.</td>
- * </tr>
- * </table>
- */
- public final static String EFFECT_CROP =
- "android.media.effect.effects.CropEffect";
-
- /**
- * <p>Applies a cross process effect on image, in which the red and green channels are
- * enhanced while the blue channel is restricted.</p>
- * <p>Available parameters: None</p>
- */
- public final static String EFFECT_CROSSPROCESS =
- "android.media.effect.effects.CrossProcessEffect";
-
- /**
- * <p>Applies black and white documentary style effect on image..</p>
- * <p>Available parameters: None</p>
- */
- public final static String EFFECT_DOCUMENTARY =
- "android.media.effect.effects.DocumentaryEffect";
-
-
- /**
- * <p>Overlays a bitmap (with premultiplied alpha channel) onto the input image. The bitmap
- * is stretched to fit the input image.</p>
- * <p>Available parameters:</p>
- * <table>
- * <tr><td>Parameter name</td><td>Meaning</td><td>Valid values</td></tr>
- * <tr><td><code>bitmap</code></td>
- * <td>The overlay bitmap.</td>
- * <td>A non-null Bitmap instance.</td>
- * </tr>
- * </table>
- */
- public final static String EFFECT_BITMAPOVERLAY =
- "android.media.effect.effects.BitmapOverlayEffect";
-
- /**
- * <p>Representation of photo using only two color tones.</p>
- * <p>Available parameters:</p>
- * <table>
- * <tr><td>Parameter name</td><td>Meaning</td><td>Valid values</td></tr>
- * <tr><td><code>first_color</code></td>
- * <td>The first color tone.</td>
- * <td>Integer, representing an ARGB color with 8 bits per channel. May be created using
- * {@link android.graphics.Color Color} class.</td>
- * </tr>
- * <tr><td><code>second_color</code></td>
- * <td>The second color tone.</td>
- * <td>Integer, representing an ARGB color with 8 bits per channel. May be created using
- * {@link android.graphics.Color Color} class.</td>
- * </tr>
- * </table>
- */
- public final static String EFFECT_DUOTONE =
- "android.media.effect.effects.DuotoneEffect";
-
- /**
- * <p>Applies back-light filling to the image.</p>
- * <p>Available parameters:</p>
- * <table>
- * <tr><td>Parameter name</td><td>Meaning</td><td>Valid values</td></tr>
- * <tr><td><code>strength</code></td>
- * <td>The strength of the backlight.</td>
- * <td>Float, between 0 and 1. Zero means no change.</td>
- * </tr>
- * </table>
- */
- public final static String EFFECT_FILLLIGHT =
- "android.media.effect.effects.FillLightEffect";
-
- /**
- * <p>Flips image vertically and/or horizontally.</p>
- * <p>Available parameters:</p>
- * <table>
- * <tr><td>Parameter name</td><td>Meaning</td><td>Valid values</td></tr>
- * <tr><td><code>vertical</code></td>
- * <td>Whether to flip image vertically.</td>
- * <td>Boolean</td>
- * </tr>
- * <tr><td><code>horizontal</code></td>
- * <td>Whether to flip image horizontally.</td>
- * <td>Boolean</td>
- * </tr>
- * </table>
- */
- public final static String EFFECT_FLIP =
- "android.media.effect.effects.FlipEffect";
-
- /**
- * <p>Applies film grain effect to image.</p>
- * <p>Available parameters:</p>
- * <table>
- * <tr><td>Parameter name</td><td>Meaning</td><td>Valid values</td></tr>
- * <tr><td><code>strength</code></td>
- * <td>The strength of the grain effect.</td>
- * <td>Float, between 0 and 1. Zero means no change.</td>
- * </tr>
- * </table>
- */
- public final static String EFFECT_GRAIN =
- "android.media.effect.effects.GrainEffect";
-
- /**
- * <p>Converts image to grayscale.</p>
- * <p>Available parameters: None</p>
- */
- public final static String EFFECT_GRAYSCALE =
- "android.media.effect.effects.GrayscaleEffect";
-
- /**
- * <p>Applies lomo-camera style effect to image.</p>
- * <p>Available parameters: None</p>
- */
- public final static String EFFECT_LOMOISH =
- "android.media.effect.effects.LomoishEffect";
-
- /**
- * <p>Inverts the image colors.</p>
- * <p>Available parameters: None</p>
- */
- public final static String EFFECT_NEGATIVE =
- "android.media.effect.effects.NegativeEffect";
-
- /**
- * <p>Applies posterization effect to image.</p>
- * <p>Available parameters: None</p>
- */
- public final static String EFFECT_POSTERIZE =
- "android.media.effect.effects.PosterizeEffect";
-
- /**
- * <p>Removes red eyes on specified region.</p>
- * <p>Available parameters:</p>
- * <table>
- * <tr><td>Parameter name</td><td>Meaning</td><td>Valid values</td></tr>
- * <tr><td><code>centers</code></td>
- * <td>Multiple center points (x, y) of the red eye regions.</td>
- * <td>An array of floats, where (f[2*i], f[2*i+1]) specifies the center of the i'th eye.
- * Coordinate values are expected to be normalized between 0 and 1.</td>
- * </tr>
- * </table>
- */
- public final static String EFFECT_REDEYE =
- "android.media.effect.effects.RedEyeEffect";
-
- /**
- * <p>Rotates the image. The output frame size must be able to fit the rotated version of
- * the input image. Note that the rotation snaps to a the closest multiple of 90 degrees.</p>
- * <p>Available parameters:</p>
- * <table>
- * <tr><td>Parameter name</td><td>Meaning</td><td>Valid values</td></tr>
- * <tr><td><code>angle</code></td>
- * <td>The angle of rotation in degrees.</td>
- * <td>Integer value. This will be rounded to the nearest multiple of 90.</td>
- * </tr>
- * </table>
- */
- public final static String EFFECT_ROTATE =
- "android.media.effect.effects.RotateEffect";
-
- /**
- * <p>Adjusts color saturation of image.</p>
- * <p>Available parameters:</p>
- * <table>
- * <tr><td>Parameter name</td><td>Meaning</td><td>Valid values</td></tr>
- * <tr><td><code>scale</code></td>
- * <td>The scale of color saturation.</td>
- * <td>Float, between -1 and 1. 0 means no change, while -1 indicates full desaturation,
- * i.e. grayscale.</td>
- * </tr>
- * </table>
- */
- public final static String EFFECT_SATURATE =
- "android.media.effect.effects.SaturateEffect";
-
- /**
- * <p>Converts image to sepia tone.</p>
- * <p>Available parameters: None</p>
- */
- public final static String EFFECT_SEPIA =
- "android.media.effect.effects.SepiaEffect";
-
- /**
- * <p>Sharpens the image.</p>
- * <p>Available parameters:</p>
- * <table>
- * <tr><td>Parameter name</td><td>Meaning</td><td>Valid values</td></tr>
- * <tr><td><code>scale</code></td>
- * <td>The degree of sharpening.</td>
- * <td>Float, between 0 and 1. 0 means no change.</td>
- * </tr>
- * </table>
- */
- public final static String EFFECT_SHARPEN =
- "android.media.effect.effects.SharpenEffect";
-
- /**
- * <p>Rotates the image according to the specified angle, and crops the image so that no
- * non-image portions are visible.</p>
- * <p>Available parameters:</p>
- * <table>
- * <tr><td>Parameter name</td><td>Meaning</td><td>Valid values</td></tr>
- * <tr><td><code>angle</code></td>
- * <td>The angle of rotation.</td>
- * <td>Float, between -45 and +45.</td>
- * </tr>
- * </table>
- */
- public final static String EFFECT_STRAIGHTEN =
- "android.media.effect.effects.StraightenEffect";
-
- /**
- * <p>Adjusts color temperature of the image.</p>
- * <p>Available parameters:</p>
- * <table>
- * <tr><td>Parameter name</td><td>Meaning</td><td>Valid values</td></tr>
- * <tr><td><code>scale</code></td>
- * <td>The value of color temperature.</td>
- * <td>Float, between 0 and 1, with 0 indicating cool, and 1 indicating warm. A value of
- * of 0.5 indicates no change.</td>
- * </tr>
- * </table>
- */
- public final static String EFFECT_TEMPERATURE =
- "android.media.effect.effects.ColorTemperatureEffect";
-
- /**
- * <p>Tints the photo with specified color.</p>
- * <p>Available parameters:</p>
- * <table>
- * <tr><td>Parameter name</td><td>Meaning</td><td>Valid values</td></tr>
- * <tr><td><code>tint</code></td>
- * <td>The color of the tint.</td>
- * <td>Integer, representing an ARGB color with 8 bits per channel. May be created using
- * {@link android.graphics.Color Color} class.</td>
- * </tr>
- * </table>
- */
- public final static String EFFECT_TINT =
- "android.media.effect.effects.TintEffect";
-
- /**
- * <p>Adds a vignette effect to image, i.e. fades away the outer image edges.</p>
- * <p>Available parameters:</p>
- * <table>
- * <tr><td>Parameter name</td><td>Meaning</td><td>Valid values</td></tr>
- * <tr><td><code>scale</code></td>
- * <td>The scale of vignetting.</td>
- * <td>Float, between 0 and 1. 0 means no change.</td>
- * </tr>
- * </table>
- */
- public final static String EFFECT_VIGNETTE =
- "android.media.effect.effects.VignetteEffect";
-
- EffectFactory(EffectContext effectContext) {
- mEffectContext = effectContext;
- }
-
- /**
- * Instantiate a new effect with the given effect name.
- *
- * <p>The effect's parameters will be set to their default values.</p>
- *
- * <p>Note that the EGL context associated with the current EffectContext need not be made
- * current when creating an effect. This allows the host application to instantiate effects
- * before any EGL context has become current.</p>
- *
- * @param effectName The name of the effect to create.
- * @return A new Effect instance.
- * @throws IllegalArgumentException if the effect with the specified name is not supported or
- * not known.
- */
- public Effect createEffect(String effectName) {
- Class effectClass = getEffectClassByName(effectName);
- if (effectClass == null) {
- throw new IllegalArgumentException("Cannot instantiate unknown effect '" +
- effectName + "'!");
- }
- return instantiateEffect(effectClass, effectName);
- }
-
- /**
- * Check if an effect is supported on this platform.
- *
- * <p>Some effects may only be available on certain platforms. Use this method before
- * instantiating an effect to make sure it is supported.</p>
- *
- * @param effectName The name of the effect.
- * @return true, if the effect is supported on this platform.
- * @throws IllegalArgumentException if the effect name is not known.
- */
- public static boolean isEffectSupported(String effectName) {
- return getEffectClassByName(effectName) != null;
- }
-
- private static Class getEffectClassByName(String className) {
- Class effectClass = null;
-
- // Get context's classloader; otherwise cannot load non-framework effects
- ClassLoader contextClassLoader = Thread.currentThread().getContextClassLoader();
-
- // Look for the class in the imported packages
- for (String packageName : EFFECT_PACKAGES) {
- try {
- effectClass = contextClassLoader.loadClass(packageName + className);
- } catch (ClassNotFoundException e) {
- continue;
- }
- // Exit loop if class was found.
- if (effectClass != null) {
- break;
- }
- }
- return effectClass;
- }
-
- private Effect instantiateEffect(Class effectClass, String name) {
- // Make sure this is an Effect subclass
- try {
- effectClass.asSubclass(Effect.class);
- } catch (ClassCastException e) {
- throw new IllegalArgumentException("Attempting to allocate effect '" + effectClass
- + "' which is not a subclass of Effect!", e);
- }
-
- // Look for the correct constructor
- Constructor effectConstructor = null;
- try {
- effectConstructor = effectClass.getConstructor(EffectContext.class, String.class);
- } catch (NoSuchMethodException e) {
- throw new RuntimeException("The effect class '" + effectClass + "' does not have "
- + "the required constructor.", e);
- }
-
- // Construct the effect
- Effect effect = null;
- try {
- effect = (Effect)effectConstructor.newInstance(mEffectContext, name);
- } catch (Throwable t) {
- throw new RuntimeException("There was an error constructing the effect '" + effectClass
- + "'!", t);
- }
-
- return effect;
- }
-}
+++ /dev/null
-/*
- * 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.media.effect;
-
-/**
- * Some effects may issue callbacks to inform the host of changes to the effect state. This is the
- * listener interface for receiving those callbacks.
- */
-public interface EffectUpdateListener {
-
- /**
- * Called when the effect state is updated.
- *
- * @param effect The effect that has been updated.
- * @param info A value that gives more information about the update. See the effect's
- * documentation for more details on what this object is.
- */
- public void onEffectUpdated(Effect effect, Object info);
-
-}
-
+++ /dev/null
-/*
- * 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.media.effect;
-
-import android.filterfw.core.CachedFrameManager;
-import android.filterfw.core.FilterContext;
-import android.filterfw.core.FilterFactory;
-import android.filterfw.core.GLEnvironment;
-import android.filterfw.core.GLFrame;
-import android.filterfw.core.Frame;
-import android.filterfw.core.FrameFormat;
-import android.filterfw.core.FrameManager;
-import android.filterfw.format.ImageFormat;
-
-/**
- * The FilterEffect class is the base class for all Effects based on Filters from the Mobile
- * Filter Framework (MFF).
- * @hide
- */
-public abstract class FilterEffect extends Effect {
-
- protected EffectContext mEffectContext;
- private String mName;
-
- /**
- * Protected constructor as FilterEffects should be created by Factory.
- */
- protected FilterEffect(EffectContext context, String name) {
- mEffectContext = context;
- mName = name;
- }
-
- /**
- * Get the effect name.
- *
- * Returns the unique name of the effect, which matches the name used for instantiating this
- * effect by the EffectFactory.
- *
- * @return The name of the effect.
- */
- @Override
- public String getName() {
- return mName;
- }
-
- // Helper Methods for subclasses ///////////////////////////////////////////////////////////////
- /**
- * Call this before manipulating the GL context. Will assert that the GL environment is in a
- * valid state, and save it.
- */
- protected void beginGLEffect() {
- mEffectContext.assertValidGLState();
- mEffectContext.saveGLState();
- }
-
- /**
- * Call this after manipulating the GL context. Restores the previous GL state.
- */
- protected void endGLEffect() {
- mEffectContext.restoreGLState();
- }
-
- /**
- * Returns the active filter context for this effect.
- */
- protected FilterContext getFilterContext() {
- return mEffectContext.mFilterContext;
- }
-
- /**
- * Converts a texture into a Frame.
- */
- protected Frame frameFromTexture(int texId, int width, int height) {
- FrameManager manager = getFilterContext().getFrameManager();
- FrameFormat format = ImageFormat.create(width, height,
- ImageFormat.COLORSPACE_RGBA,
- FrameFormat.TARGET_GPU);
- Frame frame = manager.newBoundFrame(format,
- GLFrame.EXISTING_TEXTURE_BINDING,
- texId);
- frame.setTimestamp(Frame.TIMESTAMP_UNKNOWN);
- return frame;
- }
-
-}
-
+++ /dev/null
-/*
- * 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.media.effect;
-
-import android.filterfw.core.Filter;
-import android.filterfw.core.FilterGraph;
-import android.filterfw.core.GraphRunner;
-import android.filterfw.core.SimpleScheduler;
-import android.filterfw.core.SyncRunner;
-import android.media.effect.Effect;
-import android.media.effect.FilterEffect;
-import android.media.effect.EffectContext;
-import android.filterfw.io.GraphIOException;
-import android.filterfw.io.GraphReader;
-import android.filterfw.io.TextGraphReader;
-
-import android.util.Log;
-
-/**
- * Effect subclass for effects based on a single Filter. Subclasses need only invoke the
- * constructor with the correct arguments to obtain an Effect implementation.
- *
- * @hide
- */
-public class FilterGraphEffect extends FilterEffect {
-
- private static final String TAG = "FilterGraphEffect";
-
- protected String mInputName;
- protected String mOutputName;
- protected GraphRunner mRunner;
- protected FilterGraph mGraph;
- protected Class mSchedulerClass;
-
- /**
- * Constructs a new FilterGraphEffect.
- *
- * @param name The name of this effect (used to create it in the EffectFactory).
- * @param graphString The graph string to create the graph.
- * @param inputName The name of the input GLTextureSource filter.
- * @param outputName The name of the output GLTextureSource filter.
- */
- public FilterGraphEffect(EffectContext context,
- String name,
- String graphString,
- String inputName,
- String outputName,
- Class scheduler) {
- super(context, name);
-
- mInputName = inputName;
- mOutputName = outputName;
- mSchedulerClass = scheduler;
- createGraph(graphString);
-
- }
-
- private void createGraph(String graphString) {
- GraphReader reader = new TextGraphReader();
- try {
- mGraph = reader.readGraphString(graphString);
- } catch (GraphIOException e) {
- throw new RuntimeException("Could not setup effect", e);
- }
-
- if (mGraph == null) {
- throw new RuntimeException("Could not setup effect");
- }
- mRunner = new SyncRunner(getFilterContext(), mGraph, mSchedulerClass);
- }
-
- @Override
- public void apply(int inputTexId, int width, int height, int outputTexId) {
- beginGLEffect();
- Filter src = mGraph.getFilter(mInputName);
- if (src != null) {
- src.setInputValue("texId", inputTexId);
- src.setInputValue("width", width);
- src.setInputValue("height", height);
- } else {
- throw new RuntimeException("Internal error applying effect");
- }
- Filter dest = mGraph.getFilter(mOutputName);
- if (dest != null) {
- dest.setInputValue("texId", outputTexId);
- } else {
- throw new RuntimeException("Internal error applying effect");
- }
- try {
- mRunner.run();
- } catch (RuntimeException e) {
- throw new RuntimeException("Internal error applying effect: ", e);
- }
- endGLEffect();
- }
-
- @Override
- public void setParameter(String parameterKey, Object value) {
- }
-
- @Override
- public void release() {
- mGraph.tearDown(getFilterContext());
- mGraph = null;
- }
-}
+++ /dev/null
-/*
- * 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.media.effect;
-
-import android.filterfw.core.Filter;
-import android.filterfw.core.FilterFactory;
-import android.filterfw.core.FilterFunction;
-import android.filterfw.core.Frame;
-import android.media.effect.Effect;
-import android.media.effect.EffectContext;
-
-import android.util.Log;
-
-/**
- * Effect subclass for effects based on a single Filter. Subclasses need only invoke the
- * constructor with the correct arguments to obtain an Effect implementation.
- *
- * @hide
- */
-public class SingleFilterEffect extends FilterEffect {
-
- protected FilterFunction mFunction;
- protected String mInputName;
- protected String mOutputName;
-
- /**
- * Constructs a new FilterFunctionEffect.
- *
- * @param name The name of this effect (used to create it in the EffectFactory).
- * @param filterClass The class of the filter to wrap.
- * @param inputName The name of the input image port.
- * @param outputName The name of the output image port.
- * @param finalParameters Key-value pairs of final input port assignments.
- */
- public SingleFilterEffect(EffectContext context,
- String name,
- Class filterClass,
- String inputName,
- String outputName,
- Object... finalParameters) {
- super(context, name);
-
- mInputName = inputName;
- mOutputName = outputName;
-
- String filterName = filterClass.getSimpleName();
- FilterFactory factory = FilterFactory.sharedFactory();
- Filter filter = factory.createFilterByClass(filterClass, filterName);
- filter.initWithAssignmentList(finalParameters);
-
- mFunction = new FilterFunction(getFilterContext(), filter);
- }
-
- @Override
- public void apply(int inputTexId, int width, int height, int outputTexId) {
- beginGLEffect();
-
- Frame inputFrame = frameFromTexture(inputTexId, width, height);
- Frame outputFrame = frameFromTexture(outputTexId, width, height);
-
- Frame resultFrame = mFunction.executeWithArgList(mInputName, inputFrame);
-
- outputFrame.setDataFromFrame(resultFrame);
-
- inputFrame.release();
- outputFrame.release();
- resultFrame.release();
-
- endGLEffect();
- }
-
- @Override
- public void setParameter(String parameterKey, Object value) {
- mFunction.setInputValue(parameterKey, value);
- }
-
- @Override
- public void release() {
- mFunction.tearDown();
- mFunction = null;
- }
-}
-
+++ /dev/null
-/*
- * 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.media.effect;
-
-import android.filterfw.core.Filter;
-import android.filterfw.core.FilterFactory;
-import android.filterfw.core.FilterFunction;
-import android.filterfw.core.Frame;
-import android.media.effect.Effect;
-import android.media.effect.EffectContext;
-
-import android.util.Log;
-
-/**
- * Effect subclass for effects based on a single Filter with output size differnet
- * from input. Subclasses need only invoke the constructor with the correct arguments
- * to obtain an Effect implementation.
- *
- * @hide
- */
-public class SizeChangeEffect extends SingleFilterEffect {
-
- public SizeChangeEffect(EffectContext context,
- String name,
- Class filterClass,
- String inputName,
- String outputName,
- Object... finalParameters) {
- super(context, name, filterClass, inputName, outputName, finalParameters);
- }
-
- @Override
- public void apply(int inputTexId, int width, int height, int outputTexId) {
- beginGLEffect();
-
- Frame inputFrame = frameFromTexture(inputTexId, width, height);
- Frame resultFrame = mFunction.executeWithArgList(mInputName, inputFrame);
-
- int outputWidth = resultFrame.getFormat().getWidth();
- int outputHeight = resultFrame.getFormat().getHeight();
-
- Frame outputFrame = frameFromTexture(outputTexId, outputWidth, outputHeight);
- outputFrame.setDataFromFrame(resultFrame);
-
- inputFrame.release();
- outputFrame.release();
- resultFrame.release();
-
- endGLEffect();
- }
-}
+++ /dev/null
-/*
- * 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.media.effect.effects;
-
-import android.media.effect.EffectContext;
-import android.media.effect.SingleFilterEffect;
-import android.filterpacks.imageproc.AutoFixFilter;
-
-/**
- * @hide
- */
-public class AutoFixEffect extends SingleFilterEffect {
- public AutoFixEffect(EffectContext context, String name) {
- super(context, name, AutoFixFilter.class, "image", "image");
- }
-}
+++ /dev/null
-/*
- * 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.media.effect.effects;
-
-import android.filterfw.core.Filter;
-import android.filterfw.core.OneShotScheduler;
-import android.media.effect.EffectContext;
-import android.media.effect.FilterGraphEffect;
-import android.media.effect.EffectUpdateListener;
-
-import android.filterpacks.videoproc.BackDropperFilter;
-import android.filterpacks.videoproc.BackDropperFilter.LearningDoneListener;
-
-/**
- * Background replacement Effect.
- *
- * Replaces the background of the input video stream with a selected video
- * Learns the background when it first starts up;
- * needs unobstructed view of background when this happens.
- *
- * Effect parameters:
- * source: A URI for the background video
- * Listener: Called when learning period is complete
- *
- * @hide
- */
-public class BackDropperEffect extends FilterGraphEffect {
- private static final String mGraphDefinition =
- "@import android.filterpacks.base;\n" +
- "@import android.filterpacks.videoproc;\n" +
- "@import android.filterpacks.videosrc;\n" +
- "\n" +
- "@filter GLTextureSource foreground {\n" +
- " texId = 0;\n" + // Will be set by base class
- " width = 0;\n" +
- " height = 0;\n" +
- " repeatFrame = true;\n" +
- "}\n" +
- "\n" +
- "@filter MediaSource background {\n" +
- " sourceUrl = \"no_file_specified\";\n" +
- " waitForNewFrame = false;\n" +
- " sourceIsUrl = true;\n" +
- "}\n" +
- "\n" +
- "@filter BackDropperFilter replacer {\n" +
- " autowbToggle = 1;\n" +
- "}\n" +
- "\n" +
- "@filter GLTextureTarget output {\n" +
- " texId = 0;\n" +
- "}\n" +
- "\n" +
- "@connect foreground[frame] => replacer[video];\n" +
- "@connect background[video] => replacer[background];\n" +
- "@connect replacer[video] => output[frame];\n";
-
- private EffectUpdateListener mEffectListener = null;
-
- private LearningDoneListener mLearningListener = new LearningDoneListener() {
- public void onLearningDone(BackDropperFilter filter) {
- if (mEffectListener != null) {
- mEffectListener.onEffectUpdated(BackDropperEffect.this, null);
- }
- }
- };
-
- public BackDropperEffect(EffectContext context, String name) {
- super(context, name, mGraphDefinition, "foreground", "output", OneShotScheduler.class);
-
- Filter replacer = mGraph.getFilter("replacer");
- replacer.setInputValue("learningDoneListener", mLearningListener);
- }
-
- @Override
- public void setParameter(String parameterKey, Object value) {
- if (parameterKey.equals("source")) {
- Filter background = mGraph.getFilter("background");
- background.setInputValue("sourceUrl", value);
- }
- }
-
- @Override
- public void setUpdateListener(EffectUpdateListener listener) {
- mEffectListener = listener;
- }
-
-}
\ No newline at end of file
+++ /dev/null
-/*
- * 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.media.effect.effects;
-
-import android.media.effect.EffectContext;
-import android.media.effect.SingleFilterEffect;
-import android.filterpacks.imageproc.BitmapOverlayFilter;
-
-/**
- * @hide
- */
-public class BitmapOverlayEffect extends SingleFilterEffect {
- public BitmapOverlayEffect(EffectContext context, String name) {
- super(context, name, BitmapOverlayFilter.class, "image", "image");
- }
-}
+++ /dev/null
-/*
- * 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.media.effect.effects;
-
-import android.media.effect.EffectContext;
-import android.media.effect.SingleFilterEffect;
-import android.filterpacks.imageproc.BlackWhiteFilter;
-
-/**
- * @hide
- */
-public class BlackWhiteEffect extends SingleFilterEffect {
- public BlackWhiteEffect(EffectContext context, String name) {
- super(context, name, BlackWhiteFilter.class, "image", "image");
- }
-}
+++ /dev/null
-/*
- * 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.media.effect.effects;
-
-import android.media.effect.EffectContext;
-import android.media.effect.SingleFilterEffect;
-import android.filterpacks.imageproc.BrightnessFilter;
-
-/**
- * @hide
- */
-public class BrightnessEffect extends SingleFilterEffect {
- public BrightnessEffect(EffectContext context, String name) {
- super(context, name, BrightnessFilter.class, "image", "image");
- }
-}
-
+++ /dev/null
-/*
- * 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.media.effect.effects;
-
-import android.media.effect.EffectContext;
-import android.media.effect.SingleFilterEffect;
-import android.filterpacks.imageproc.ColorTemperatureFilter;
-
-/**
- * @hide
- */
-public class ColorTemperatureEffect extends SingleFilterEffect {
- public ColorTemperatureEffect(EffectContext context, String name) {
- super(context, name, ColorTemperatureFilter.class, "image", "image");
- }
-}
+++ /dev/null
-/*
- * 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.media.effect.effects;
-
-import android.media.effect.EffectContext;
-import android.media.effect.SingleFilterEffect;
-import android.filterpacks.imageproc.ContrastFilter;
-
-/**
- * @hide
- */
-public class ContrastEffect extends SingleFilterEffect {
- public ContrastEffect(EffectContext context, String name) {
- super(context, name, ContrastFilter.class, "image", "image");
- }
-}
-
+++ /dev/null
-/*
- * 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.media.effect.effects;
-
-import android.media.effect.EffectContext;
-import android.media.effect.SizeChangeEffect;
-import android.media.effect.SingleFilterEffect;
-import android.filterpacks.imageproc.CropRectFilter;
-
-/**
- * @hide
- */
-//public class CropEffect extends SingleFilterEffect {
-public class CropEffect extends SizeChangeEffect {
- public CropEffect(EffectContext context, String name) {
- super(context, name, CropRectFilter.class, "image", "image");
- }
-}
+++ /dev/null
-/*
- * 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.media.effect.effects;
-
-import android.media.effect.EffectContext;
-import android.media.effect.SingleFilterEffect;
-import android.filterpacks.imageproc.CrossProcessFilter;
-
-/**
- * @hide
- */
-public class CrossProcessEffect extends SingleFilterEffect {
- public CrossProcessEffect(EffectContext context, String name) {
- super(context, name, CrossProcessFilter.class, "image", "image");
- }
-}
+++ /dev/null
-/*
- * 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.media.effect.effects;
-
-import android.media.effect.EffectContext;
-import android.media.effect.SingleFilterEffect;
-import android.filterpacks.imageproc.DocumentaryFilter;
-
-/**
- * @hide
- */
-public class DocumentaryEffect extends SingleFilterEffect {
- public DocumentaryEffect(EffectContext context, String name) {
- super(context, name, DocumentaryFilter.class, "image", "image");
- }
-}
+++ /dev/null
-/*
- * 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.media.effect.effects;
-
-import android.media.effect.EffectContext;
-import android.media.effect.SingleFilterEffect;
-import android.filterpacks.imageproc.DuotoneFilter;
-
-/**
- * @hide
- */
-public class DuotoneEffect extends SingleFilterEffect {
- public DuotoneEffect(EffectContext context, String name) {
- super(context, name, DuotoneFilter.class, "image", "image");
- }
-}
+++ /dev/null
-/*
- * 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.media.effect.effects;
-
-import android.media.effect.EffectContext;
-import android.media.effect.SingleFilterEffect;
-import android.filterpacks.imageproc.FillLightFilter;
-
-/**
- * @hide
- */
-public class FillLightEffect extends SingleFilterEffect {
- public FillLightEffect(EffectContext context, String name) {
- super(context, name, FillLightFilter.class, "image", "image");
- }
-}
+++ /dev/null
-/*
- * 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.media.effect.effects;
-
-import android.media.effect.EffectContext;
-import android.media.effect.SingleFilterEffect;
-import android.filterpacks.imageproc.FisheyeFilter;
-
-/**
- * @hide
- */
-public class FisheyeEffect extends SingleFilterEffect {
- public FisheyeEffect(EffectContext context, String name) {
- super(context, name, FisheyeFilter.class, "image", "image");
- }
-}
-
+++ /dev/null
-/*
- * 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.media.effect.effects;
-
-import android.media.effect.EffectContext;
-import android.media.effect.SingleFilterEffect;
-import android.filterpacks.imageproc.FlipFilter;
-
-/**
- * @hide
- */
-public class FlipEffect extends SingleFilterEffect {
- public FlipEffect(EffectContext context, String name) {
- super(context, name, FlipFilter.class, "image", "image");
- }
-}
+++ /dev/null
-/*
- * 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.media.effect.effects;
-
-import android.media.effect.EffectContext;
-import android.media.effect.SingleFilterEffect;
-import android.filterpacks.imageproc.GrainFilter;
-
-/**
- * @hide
- */
-public class GrainEffect extends SingleFilterEffect {
- public GrainEffect(EffectContext context, String name) {
- super(context, name, GrainFilter.class, "image", "image");
- }
-}
+++ /dev/null
-/*
- * 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.media.effect.effects;
-
-import android.media.effect.EffectContext;
-import android.media.effect.SingleFilterEffect;
-import android.filterpacks.imageproc.ToGrayFilter;
-
-/**
- * @hide
- */
-public class GrayscaleEffect extends SingleFilterEffect {
- public GrayscaleEffect(EffectContext context, String name) {
- super(context, name, ToGrayFilter.class, "image", "image");
- }
-}
+++ /dev/null
-/*
- * 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.media.effect.effects;
-
-import android.filterfw.core.Frame;
-import android.media.effect.EffectContext;
-import android.media.effect.FilterEffect;
-
-/**
- * @hide
- */
-public class IdentityEffect extends FilterEffect {
-
- public IdentityEffect(EffectContext context, String name) {
- super(context, name);
- }
-
- @Override
- public void apply(int inputTexId, int width, int height, int outputTexId) {
- beginGLEffect();
-
- Frame inputFrame = frameFromTexture(inputTexId, width, height);
- Frame outputFrame = frameFromTexture(outputTexId, width, height);
-
- outputFrame.setDataFromFrame(inputFrame);
-
- inputFrame.release();
- outputFrame.release();
-
- endGLEffect();
- }
-
- @Override
- public void setParameter(String parameterKey, Object value) {
- throw new IllegalArgumentException("Unknown parameter " + parameterKey
- + " for IdentityEffect!");
- }
-
- @Override
- public void release() {
- }
-}
-
+++ /dev/null
-/*
- * 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.media.effect.effects;
-
-import android.media.effect.EffectContext;
-import android.media.effect.SingleFilterEffect;
-import android.filterpacks.imageproc.LomoishFilter;
-
-/**
- * @hide
- */
-public class LomoishEffect extends SingleFilterEffect {
- public LomoishEffect(EffectContext context, String name) {
- super(context, name, LomoishFilter.class, "image", "image");
- }
-}
+++ /dev/null
-/*
- * 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.media.effect.effects;
-
-import android.media.effect.EffectContext;
-import android.media.effect.SingleFilterEffect;
-import android.filterpacks.imageproc.NegativeFilter;
-
-/**
- * @hide
- */
-public class NegativeEffect extends SingleFilterEffect {
- public NegativeEffect(EffectContext context, String name) {
- super(context, name, NegativeFilter.class, "image", "image");
- }
-}
+++ /dev/null
-/*
- * 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.media.effect.effects;
-
-import android.media.effect.EffectContext;
-import android.media.effect.SingleFilterEffect;
-import android.filterpacks.imageproc.PosterizeFilter;
-
-/**
- * @hide
- */
-public class PosterizeEffect extends SingleFilterEffect {
- public PosterizeEffect(EffectContext context, String name) {
- super(context, name, PosterizeFilter.class, "image", "image");
- }
-}
+++ /dev/null
-/*
- * 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.media.effect.effects;
-
-import android.media.effect.EffectContext;
-import android.media.effect.SingleFilterEffect;
-import android.filterpacks.imageproc.RedEyeFilter;
-
-/**
- * @hide
- */
-public class RedEyeEffect extends SingleFilterEffect {
- public RedEyeEffect(EffectContext context, String name) {
- super(context, name, RedEyeFilter.class, "image", "image");
- }
-}
+++ /dev/null
-/*
- * 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.media.effect.effects;
-
-import android.media.effect.EffectContext;
-import android.media.effect.SizeChangeEffect;
-import android.filterpacks.imageproc.RotateFilter;
-
-/**
- * @hide
- */
-public class RotateEffect extends SizeChangeEffect {
- public RotateEffect(EffectContext context, String name) {
- super(context, name, RotateFilter.class, "image", "image");
- }
-}
+++ /dev/null
-/*
- * 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.media.effect.effects;
-
-import android.media.effect.EffectContext;
-import android.media.effect.SingleFilterEffect;
-import android.filterpacks.imageproc.SaturateFilter;
-
-/**
- * @hide
- */
-public class SaturateEffect extends SingleFilterEffect {
- public SaturateEffect(EffectContext context, String name) {
- super(context, name, SaturateFilter.class, "image", "image");
- }
-}
+++ /dev/null
-/*
- * 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.media.effect.effects;
-
-import android.media.effect.EffectContext;
-import android.media.effect.SingleFilterEffect;
-import android.filterpacks.imageproc.SepiaFilter;
-
-/**
- * @hide
- */
-public class SepiaEffect extends SingleFilterEffect {
- public SepiaEffect(EffectContext context, String name) {
- super(context, name, SepiaFilter.class, "image", "image");
- }
-}
+++ /dev/null
-/*
- * 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.media.effect.effects;
-
-import android.media.effect.EffectContext;
-import android.media.effect.SingleFilterEffect;
-import android.filterpacks.imageproc.SharpenFilter;
-
-/**
- * @hide
- */
-public class SharpenEffect extends SingleFilterEffect {
- public SharpenEffect(EffectContext context, String name) {
- super(context, name, SharpenFilter.class, "image", "image");
- }
-}
+++ /dev/null
-/*
- * 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.media.effect.effects;
-
-import android.media.effect.EffectContext;
-import android.media.effect.SingleFilterEffect;
-import android.filterpacks.imageproc.StraightenFilter;
-
-/**
- * @hide
- */
-public class StraightenEffect extends SingleFilterEffect {
- public StraightenEffect(EffectContext context, String name) {
- super(context, name, StraightenFilter.class, "image", "image");
- }
-}
+++ /dev/null
-/*
- * 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.media.effect.effects;
-
-import android.media.effect.EffectContext;
-import android.media.effect.SingleFilterEffect;
-import android.filterpacks.imageproc.TintFilter;
-
-/**
- * @hide
- */
-public class TintEffect extends SingleFilterEffect {
- public TintEffect(EffectContext context, String name) {
- super(context, name, TintFilter.class, "image", "image");
- }
-}
+++ /dev/null
-/*
- * 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.media.effect.effects;
-
-import android.media.effect.EffectContext;
-import android.media.effect.SingleFilterEffect;
-import android.filterpacks.imageproc.VignetteFilter;
-
-/**
- * @hide
- */
-public class VignetteEffect extends SingleFilterEffect {
- public VignetteEffect(EffectContext context, String name) {
- super(context, name, VignetteFilter.class, "image", "image");
- }
-}
+++ /dev/null
-/*
- * 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.media.effect;
-
-/**
- * <h1>Effect Framework</h1>
- *
- * This package includes a collection of high-performance visual effects that make use of the
- * mobile filter framework subsystem.
- *
- * TODO: More Documentation
- *
- */
+++ /dev/null
-<HTML>
-<BODY>
-<p>Provides classes that allow you to apply a variety of visual effects to images and
-videos. For example, you can easily fix red-eye, convert an image to grayscale,
-adjust brightness, adjust saturation, rotate an image, apply a fisheye effect, and much more. The
-system performs all effects processing on the GPU to obtain maximum performance.</p>
-
-<p>For maximum performance, effects are applied directly to OpenGL textures, so your application
-must have a valid OpenGL context before it can use the effects APIs. The textures to which you apply
-effects may be from bitmaps, videos or even the camera. However, there are certain restrictions that
-textures must meet:</p>
-<ol>
-<li>They must be bound to a {@link android.opengl.GLES20#GL_TEXTURE_2D} texture image</li>
-<li>They must contain at least one mipmap level</li>
-</ol>
-
-<p>An {@link android.media.effect.Effect} object defines a single media effect that you can apply to
-an image frame. The basic workflow to create an {@link android.media.effect.Effect} is:</p>
-
-<ol>
-<li>Call {@link android.media.effect.EffectContext#createWithCurrentGlContext
-EffectContext.createWithCurrentGlContext()} from your OpenGL ES 2.0 context.</li>
-<li>Use the returned {@link android.media.effect.EffectContext} to call {@link
-android.media.effect.EffectContext#getFactory EffectContext.getFactory()}, which returns an instance
-of {@link android.media.effect.EffectFactory}.</li>
-<li>Call {@link android.media.effect.EffectFactory#createEffect createEffect()}, passing it an
-effect name from @link android.media.effect.EffectFactory}, such as {@link
-android.media.effect.EffectFactory#EFFECT_FISHEYE} or {@link
-android.media.effect.EffectFactory#EFFECT_VIGNETTE}.</li>
-</ol>
-
-<p>You can adjust an effect’s parameters by calling {@link android.media.effect.Effect#setParameter
-setParameter()} and passing a parameter name and parameter value. Each type of effect accepts
-different parameters, which are documented with the effect name. For example, {@link
-android.media.effect.EffectFactory#EFFECT_FISHEYE} has one parameter for the {@code scale} of the
-distortion.</p>
-
-<p>To apply an effect on a texture, call {@link android.media.effect.Effect#apply apply()} on the
-{@link
-android.media.effect.Effect} and pass in the input texture, its width and height, and the output
-texture. The input texture must be bound to a {@link android.opengl.GLES20#GL_TEXTURE_2D} texture
-image (usually done by calling the {@link android.opengl.GLES20#glTexImage2D glTexImage2D()}
-function). You may provide multiple mipmap levels. If the output texture has not been bound to a
-texture image, it will be automatically bound by the effect as a {@link
-android.opengl.GLES20#GL_TEXTURE_2D} and with one mipmap level (0), which will have the same
-size as the input.</p>
-
-<p class="note"><strong>Note:</strong> All effects listed in {@link
-android.media.effect.EffectFactory} are guaranteed to be supported. However, some additional effects
-available from external libraries are not supported by all devices, so you must first check if the
-desired effect from the external library is supported by calling {@link
-android.media.effect.EffectFactory#isEffectSupported isEffectSupported()}.</p>
-</BODY>
-</HTML>
+++ /dev/null
-# 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.
-#
-
-#####################
-# Build native sublibraries
-
-include $(all-subdir-makefiles)
-
-#####################
-# Build main libfilterfw
-
-include $(CLEAR_VARS)
-
-LOCAL_MODULE := libfilterfw
-
-LOCAL_MODULE_TAGS := optional
-
-LOCAL_WHOLE_STATIC_LIBRARIES := libfilterfw_jni \
- libfilterfw_native
-
-LOCAL_SHARED_LIBRARIES := libstlport \
- libGLESv2 \
- libEGL \
- libgui \
- libdl \
- libcutils \
- libutils \
- libandroid \
- libjnigraphics \
- libmedia \
- libmedia_native
-
-# Don't prelink this library. For more efficient code, you may want
-# to add this library to the prelink map and set this to true. However,
-# it's difficult to do this for applications that are not supplied as
-# part of a system image.
-LOCAL_PRELINK_MODULE := false
-
-include $(BUILD_SHARED_LIBRARY)
-
-
+++ /dev/null
-/*
- * 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.filterfw.core.Filter;
-import android.filterfw.core.FilterFactory;
-import android.filterfw.core.FilterFunction;
-import android.filterfw.core.Frame;
-import android.filterfw.core.FrameManager;
-
-/**
- * A FilterFunctionEnvironment provides a simple functional front-end to manually executing
- * filters. Use this environment if a graph-based approach is not convenient for your case.
- * Typically, a FilterFunctionEnvironment is used as follows:
- * 1. Instantiate a new FilterFunctionEnvironment instance.
- * 2. Perform any configuration, such as setting a GL environment.
- * 3. Wrap Filters into FilterFunctions by calling createFunction().
- * 4. Execute FilterFunctions individually and use the results for further processing.
- * Additionally, there is a convenience method to execute a number of filters in sequence.
- * @hide
- */
-public class FilterFunctionEnvironment extends MffEnvironment {
-
- /**
- * Create a new FilterFunctionEnvironment with the default components.
- */
- public FilterFunctionEnvironment() {
- super(null);
- }
-
- /**
- * Create a new FilterFunctionEnvironment with a custom FrameManager. Pass null to auto-create
- * a FrameManager.
- *
- * @param frameManager The FrameManager to use, or null to auto-create one.
- */
- public FilterFunctionEnvironment(FrameManager frameManager) {
- super(frameManager);
- }
-
- /**
- * Create a new FilterFunction from a specific filter class. The function is initialized with
- * the given key-value list of parameters. Note, that this function uses the default shared
- * FilterFactory to create the filter instance.
- *
- * @param filterClass The class of the filter to wrap. This must be a Filter subclass.
- * @param parameters An argument list of alternating key-value filter parameters.
- * @return A new FilterFunction instance.
- */
- public FilterFunction createFunction(Class filterClass, Object... parameters) {
- String filterName = "FilterFunction(" + filterClass.getSimpleName() + ")";
- Filter filter = FilterFactory.sharedFactory().createFilterByClass(filterClass, filterName);
- filter.initWithAssignmentList(parameters);
- return new FilterFunction(getContext(), filter);
- }
-
- /**
- * Convenience method to execute a sequence of filter functions. Note that every function in
- * the list MUST have one input and one output port, except the first filter (which must not
- * have any input ports) and the last filter (which may not have any output ports).
- *
- * @param functions A list of filter functions. The first filter must be a source filter.
- * @return The result of the last filter executed, or null if the last filter did not
- produce any output.
- *
- public Frame executeSequence(FilterFunction[] functions) {
- Frame oldFrame = null;
- Frame newFrame = null;
- for (FilterFunction filterFunction : functions) {
- if (oldFrame == null) {
- newFrame = filterFunction.executeWithArgList();
- } else {
- newFrame = filterFunction.executeWithArgList(oldFrame);
- oldFrame.release();
- }
- oldFrame = newFrame;
- }
- if (oldFrame != null) {
- oldFrame.release();
- }
- return newFrame;
- }*/
-
-}
+++ /dev/null
-/*
- * 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()!");
- }
- }
-
-}
+++ /dev/null
-/*
- * 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.filterfw.core.CachedFrameManager;
-import android.filterfw.core.FilterContext;
-import android.filterfw.core.FrameManager;
-import android.filterfw.core.GLEnvironment;
-
-/**
- * Base class for mobile filter framework (MFF) frontend environments. These convenience classes
- * allow using the filter framework without the requirement of performing manual setup of its
- * required components.
- *
- * @hide
- */
-public class MffEnvironment {
-
- private FilterContext mContext;
-
- /**
- * Protected constructor to initialize the environment's essential components. These are the
- * frame-manager and the filter-context. Passing in null for the frame-manager causes this
- * to be auto-created.
- *
- * @param frameManager The FrameManager to use or null to auto-create one.
- */
- protected MffEnvironment(FrameManager frameManager) {
- // Get or create the frame manager
- if (frameManager == null) {
- frameManager = new CachedFrameManager();
- }
-
- // Setup the environment
- mContext = new FilterContext();
- mContext.setFrameManager(frameManager);
-
- }
-
- /**
- * Returns the environment's filter-context.
- */
- public FilterContext getContext() {
- return mContext;
- }
-
- /**
- * Set the environment's GL environment to the specified environment. This does not activate
- * the environment.
- */
- public void setGLEnvironment(GLEnvironment glEnvironment) {
- mContext.initGLEnvironment(glEnvironment);
- }
-
- /**
- * Create and activate a new GL environment for use in this filter context.
- */
- public void createGLEnvironment() {
- GLEnvironment glEnvironment = new GLEnvironment();
- glEnvironment.initWithNewContext();
- setGLEnvironment(glEnvironment);
- }
-
- /**
- * Activate the GL environment for use in the current thread. A GL environment must have been
- * previously set or created using setGLEnvironment() or createGLEnvironment()! Call this after
- * having switched to a new thread for GL filter execution.
- */
- public void activateGLEnvironment() {
- GLEnvironment glEnv = mContext.getGLEnvironment();
- if (glEnv != null) {
- mContext.getGLEnvironment().activate();
- } else {
- throw new NullPointerException("No GLEnvironment in place to activate!");
- }
- }
-
- /**
- * Deactivate the GL environment from use in the current thread. A GL environment must have been
- * previously set or created using setGLEnvironment() or createGLEnvironment()! Call this before
- * running GL filters in another thread.
- */
- public void deactivateGLEnvironment() {
- GLEnvironment glEnv = mContext.getGLEnvironment();
- if (glEnv != null) {
- mContext.getGLEnvironment().deactivate();
- } else {
- throw new NullPointerException("No GLEnvironment in place to deactivate!");
- }
- }
-}
+++ /dev/null
-/*
- * 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.core;
-
-import android.os.AsyncTask;
-import android.os.Handler;
-
-import android.util.Log;
-
-import java.lang.InterruptedException;
-import java.lang.Runnable;
-import java.util.concurrent.CancellationException;
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.TimeoutException;
-import java.util.concurrent.TimeUnit;
-
-/**
- * @hide
- */
-public class AsyncRunner extends GraphRunner{
-
- private Class mSchedulerClass;
- private SyncRunner mRunner;
- private AsyncRunnerTask mRunTask;
-
- private OnRunnerDoneListener mDoneListener;
- private boolean isProcessing;
-
- private Exception mException;
-
- private class RunnerResult {
- public int status = RESULT_UNKNOWN;
- public Exception exception;
- }
-
- private class AsyncRunnerTask extends AsyncTask<SyncRunner, Void, RunnerResult> {
-
- private static final String TAG = "AsyncRunnerTask";
-
- @Override
- protected RunnerResult doInBackground(SyncRunner... runner) {
- RunnerResult result = new RunnerResult();
- try {
- if (runner.length > 1) {
- throw new RuntimeException("More than one runner received!");
- }
-
- runner[0].assertReadyToStep();
-
- // Preparation
- if (mLogVerbose) Log.v(TAG, "Starting background graph processing.");
- activateGlContext();
-
- if (mLogVerbose) Log.v(TAG, "Preparing filter graph for processing.");
- runner[0].beginProcessing();
-
- if (mLogVerbose) Log.v(TAG, "Running graph.");
-
- // Run loop
- result.status = RESULT_RUNNING;
- while (!isCancelled() && result.status == RESULT_RUNNING) {
- if (!runner[0].performStep()) {
- result.status = runner[0].determinePostRunState();
- if (result.status == GraphRunner.RESULT_SLEEPING) {
- runner[0].waitUntilWake();
- result.status = RESULT_RUNNING;
- }
- }
- }
-
- // Cleanup
- if (isCancelled()) {
- result.status = RESULT_STOPPED;
- }
- } catch (Exception exception) {
- result.exception = exception;
- result.status = RESULT_ERROR;
- }
-
- // Deactivate context.
- try {
- deactivateGlContext();
- } catch (Exception exception) {
- result.exception = exception;
- result.status = RESULT_ERROR;
- }
-
- if (mLogVerbose) Log.v(TAG, "Done with background graph processing.");
- return result;
- }
-
- @Override
- protected void onCancelled(RunnerResult result) {
- onPostExecute(result);
- }
-
- @Override
- protected void onPostExecute(RunnerResult result) {
- if (mLogVerbose) Log.v(TAG, "Starting post-execute.");
- setRunning(false);
- if (result == null) {
- // Cancelled before got to doInBackground
- result = new RunnerResult();
- result.status = RESULT_STOPPED;
- }
- setException(result.exception);
- if (result.status == RESULT_STOPPED || result.status == RESULT_ERROR) {
- if (mLogVerbose) Log.v(TAG, "Closing filters.");
- try {
- mRunner.close();
- } catch (Exception exception) {
- result.status = RESULT_ERROR;
- setException(exception);
- }
- }
- if (mDoneListener != null) {
- if (mLogVerbose) Log.v(TAG, "Calling graph done callback.");
- mDoneListener.onRunnerDone(result.status);
- }
- if (mLogVerbose) Log.v(TAG, "Completed post-execute.");
- }
- }
-
- private boolean mLogVerbose;
- private static final String TAG = "AsyncRunner";
-
- /** Create a new asynchronous graph runner with the given filter
- * context, and the given scheduler class.
- *
- * Must be created on the UI thread.
- */
- public AsyncRunner(FilterContext context, Class schedulerClass) {
- super(context);
-
- mSchedulerClass = schedulerClass;
- mLogVerbose = Log.isLoggable(TAG, Log.VERBOSE);
- }
-
- /** Create a new asynchronous graph runner with the given filter
- * context. Uses a default scheduler.
- *
- * Must be created on the UI thread.
- */
- public AsyncRunner(FilterContext context) {
- super(context);
-
- mSchedulerClass = SimpleScheduler.class;
- mLogVerbose = Log.isLoggable(TAG, Log.VERBOSE);
- }
-
- /** Set a callback to be called in the UI thread once the AsyncRunner
- * completes running a graph, whether the completion is due to a stop() call
- * or the filters running out of data to process.
- */
- @Override
- public void setDoneCallback(OnRunnerDoneListener listener) {
- mDoneListener = listener;
- }
-
- /** Sets the graph to be run. Will call prepare() on graph. Cannot be called
- * when a graph is already running.
- */
- synchronized public void setGraph(FilterGraph graph) {
- if (isRunning()) {
- throw new RuntimeException("Graph is already running!");
- }
- mRunner = new SyncRunner(mFilterContext, graph, mSchedulerClass);
- }
-
- @Override
- public FilterGraph getGraph() {
- return mRunner != null ? mRunner.getGraph() : null;
- }
-
- /** Execute the graph in a background thread. */
- @Override
- synchronized public void run() {
- if (mLogVerbose) Log.v(TAG, "Running graph.");
- setException(null);
-
- if (isRunning()) {
- throw new RuntimeException("Graph is already running!");
- }
- if (mRunner == null) {
- throw new RuntimeException("Cannot run before a graph is set!");
- }
- mRunTask = this.new AsyncRunnerTask();
-
- setRunning(true);
- mRunTask.execute(mRunner);
- }
-
- /** Stop graph execution. This is an asynchronous call; register a callback
- * with setDoneCallback to be notified of when the background processing has
- * been completed. Calling stop will close the filter graph. */
- @Override
- synchronized public void stop() {
- if (mRunTask != null && !mRunTask.isCancelled() ) {
- if (mLogVerbose) Log.v(TAG, "Stopping graph.");
- mRunTask.cancel(false);
- }
- }
-
- @Override
- synchronized public void close() {
- if (isRunning()) {
- throw new RuntimeException("Cannot close graph while it is running!");
- }
- if (mLogVerbose) Log.v(TAG, "Closing filters.");
- mRunner.close();
- }
-
- /** Check if background processing is happening */
- @Override
- synchronized public boolean isRunning() {
- return isProcessing;
- }
-
- @Override
- synchronized public Exception getError() {
- return mException;
- }
-
- synchronized private void setRunning(boolean running) {
- isProcessing = running;
- }
-
- synchronized private void setException(Exception exception) {
- mException = exception;
- }
-
-}
+++ /dev/null
-/*
- * 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.core;
-
-import android.filterfw.core.Frame;
-import android.filterfw.core.FrameFormat;
-import android.filterfw.core.SimpleFrameManager;
-
-import java.util.Map;
-import java.util.SortedMap;
-import java.util.TreeMap;
-
-/**
- * @hide
- */
-public class CachedFrameManager extends SimpleFrameManager {
-
- private SortedMap<Integer, Frame> mAvailableFrames;
- private int mStorageCapacity = 24 * 1024 * 1024; // Cap default storage to 24MB
- private int mStorageSize = 0;
- private int mTimeStamp = 0;
-
- public CachedFrameManager() {
- super();
- mAvailableFrames = new TreeMap<Integer, Frame>();
- }
-
- @Override
- public Frame newFrame(FrameFormat format) {
- Frame result = findAvailableFrame(format, Frame.NO_BINDING, 0);
- if (result == null) {
- result = super.newFrame(format);
- }
- result.setTimestamp(Frame.TIMESTAMP_NOT_SET);
- return result;
- }
-
- @Override
- public Frame newBoundFrame(FrameFormat format, int bindingType, long bindingId) {
- Frame result = findAvailableFrame(format, bindingType, bindingId);
- if (result == null) {
- result = super.newBoundFrame(format, bindingType, bindingId);
- }
- result.setTimestamp(Frame.TIMESTAMP_NOT_SET);
- return result;
- }
-
- @Override
- public Frame retainFrame(Frame frame) {
- return super.retainFrame(frame);
- }
-
- @Override
- public Frame releaseFrame(Frame frame) {
- if (frame.isReusable()) {
- int refCount = frame.decRefCount();
- if (refCount == 0 && frame.hasNativeAllocation()) {
- if (!storeFrame(frame)) {
- frame.releaseNativeAllocation();
- }
- return null;
- } else if (refCount < 0) {
- throw new RuntimeException("Frame reference count dropped below 0!");
- }
- } else {
- super.releaseFrame(frame);
- }
- return frame;
- }
-
- public void clearCache() {
- for (Frame frame : mAvailableFrames.values()) {
- frame.releaseNativeAllocation();
- }
- mAvailableFrames.clear();
- }
-
- @Override
- public void tearDown() {
- clearCache();
- }
-
- private boolean storeFrame(Frame frame) {
- synchronized(mAvailableFrames) {
- // Make sure this frame alone does not exceed capacity
- int frameSize = frame.getFormat().getSize();
- if (frameSize > mStorageCapacity) {
- return false;
- }
-
- // Drop frames if adding this frame would exceed capacity
- int newStorageSize = mStorageSize + frameSize;
- while (newStorageSize > mStorageCapacity) {
- dropOldestFrame();
- newStorageSize = mStorageSize + frameSize;
- }
-
- // Store new frame
- frame.onFrameStore();
- mStorageSize = newStorageSize;
- mAvailableFrames.put(mTimeStamp, frame);
- ++mTimeStamp;
- return true;
- }
- }
-
- private void dropOldestFrame() {
- int oldest = mAvailableFrames.firstKey();
- Frame frame = mAvailableFrames.get(oldest);
- mStorageSize -= frame.getFormat().getSize();
- frame.releaseNativeAllocation();
- mAvailableFrames.remove(oldest);
- }
-
- private Frame findAvailableFrame(FrameFormat format, int bindingType, long bindingId) {
- // Look for a frame that is compatible with the requested format
- synchronized(mAvailableFrames) {
- for (Map.Entry<Integer, Frame> entry : mAvailableFrames.entrySet()) {
- Frame frame = entry.getValue();
- // Check that format is compatible
- if (frame.getFormat().isReplaceableBy(format)) {
- // Check that binding is compatible (if frame is bound)
- if ((bindingType == frame.getBindingType())
- && (bindingType == Frame.NO_BINDING || bindingId == frame.getBindingId())) {
- // We found one! Take it out of the set of available frames and attach the
- // requested format to it.
- super.retainFrame(frame);
- mAvailableFrames.remove(entry.getKey());
- frame.onFrameFetch();
- frame.reset(format);
- mStorageSize -= format.getSize();
- return frame;
- }
- }
- }
- }
- return null;
- }
-
-}
+++ /dev/null
-/*
- * 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.core;
-
-import java.lang.reflect.Field;
-
-/**
- * @hide
- */
-public class FieldPort extends InputPort {
-
- protected Field mField;
- protected boolean mHasFrame;
- protected boolean mValueWaiting = false;
- protected Object mValue;
-
- public FieldPort(Filter filter, String name, Field field, boolean hasDefault) {
- super(filter, name);
- mField = field;
- mHasFrame = hasDefault;
- }
-
- @Override
- public void clear() {
- }
-
- @Override
- public void pushFrame(Frame frame) {
- setFieldFrame(frame, false);
- }
-
- @Override
- public void setFrame(Frame frame) {
- setFieldFrame(frame, true);
- }
-
- @Override
- public Object getTarget() {
- try {
- return mField.get(mFilter);
- } catch (IllegalAccessException e) {
- return null;
- }
- }
-
- @Override
- public synchronized void transfer(FilterContext context) {
- if (mValueWaiting) {
- try {
- mField.set(mFilter, mValue);
- } catch (IllegalAccessException e) {
- throw new RuntimeException(
- "Access to field '" + mField.getName() + "' was denied!");
- }
- mValueWaiting = false;
- if (context != null) {
- mFilter.notifyFieldPortValueUpdated(mName, context);
- }
- }
- }
-
- @Override
- public synchronized Frame pullFrame() {
- throw new RuntimeException("Cannot pull frame on " + this + "!");
- }
-
- @Override
- public synchronized boolean hasFrame() {
- return mHasFrame;
- }
-
- @Override
- public synchronized boolean acceptsFrame() {
- return !mValueWaiting;
- }
-
- @Override
- public String toString() {
- return "field " + super.toString();
- }
-
- protected synchronized void setFieldFrame(Frame frame, boolean isAssignment) {
- assertPortIsOpen();
- checkFrameType(frame, isAssignment);
-
- // Store the object value
- Object value = frame.getObjectValue();
- if ((value == null && mValue != null) || !value.equals(mValue)) {
- mValue = value;
- mValueWaiting = true;
- }
-
- // Since a frame was set, mark this port as having a frame to pull
- mHasFrame = true;
- }
-}
+++ /dev/null
-/*
- * 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.core;
-
-import android.filterfw.core.FilterContext;
-import android.filterfw.core.FilterPort;
-import android.filterfw.core.KeyValueMap;
-import android.filterfw.io.TextGraphReader;
-import android.filterfw.io.GraphIOException;
-import android.filterfw.format.ObjectFormat;
-import android.util.Log;
-
-import java.io.Serializable;
-import java.lang.annotation.Annotation;
-import java.lang.reflect.Field;
-import java.lang.Thread;
-import java.util.Collection;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Map.Entry;
-import java.util.LinkedList;
-import java.util.Set;
-
-/**
- * @hide
- */
-public abstract class Filter {
-
- static final int STATUS_PREINIT = 0;
- static final int STATUS_UNPREPARED = 1;
- static final int STATUS_PREPARED = 2;
- static final int STATUS_PROCESSING = 3;
- static final int STATUS_SLEEPING = 4;
- static final int STATUS_FINISHED = 5;
- static final int STATUS_ERROR = 6;
- static final int STATUS_RELEASED = 7;
-
- private String mName;
-
- private int mInputCount = -1;
- private int mOutputCount = -1;
-
- private HashMap<String, InputPort> mInputPorts;
- private HashMap<String, OutputPort> mOutputPorts;
-
- private HashSet<Frame> mFramesToRelease;
- private HashMap<String, Frame> mFramesToSet;
-
- private int mStatus = 0;
- private boolean mIsOpen = false;
- private int mSleepDelay;
-
- private long mCurrentTimestamp;
-
- private boolean mLogVerbose;
- private static final String TAG = "Filter";
-
- public Filter(String name) {
- mName = name;
- mFramesToRelease = new HashSet<Frame>();
- mFramesToSet = new HashMap<String, Frame>();
- mStatus = STATUS_PREINIT;
-
- mLogVerbose = Log.isLoggable(TAG, Log.VERBOSE);
- }
-
- /** Tests to see if a given filter is installed on the system. Requires
- * full filter package name, including filterpack.
- */
- public static final boolean isAvailable(String filterName) {
- ClassLoader contextClassLoader = Thread.currentThread().getContextClassLoader();
- Class filterClass;
- // First see if a class of that name exists
- try {
- filterClass = contextClassLoader.loadClass(filterName);
- } catch (ClassNotFoundException e) {
- return false;
- }
- // Then make sure it's a subclass of Filter.
- try {
- filterClass.asSubclass(Filter.class);
- } catch (ClassCastException e) {
- return false;
- }
- return true;
- }
-
- public final void initWithValueMap(KeyValueMap valueMap) {
- // Initialization
- initFinalPorts(valueMap);
-
- // Setup remaining ports
- initRemainingPorts(valueMap);
-
- // This indicates that final ports can no longer be set
- mStatus = STATUS_UNPREPARED;
- }
-
- public final void initWithAssignmentString(String assignments) {
- try {
- KeyValueMap valueMap = new TextGraphReader().readKeyValueAssignments(assignments);
- initWithValueMap(valueMap);
- } catch (GraphIOException e) {
- throw new IllegalArgumentException(e.getMessage());
- }
- }
-
- public final void initWithAssignmentList(Object... keyValues) {
- KeyValueMap valueMap = new KeyValueMap();
- valueMap.setKeyValues(keyValues);
- initWithValueMap(valueMap);
- }
-
- public final void init() throws ProtocolException {
- KeyValueMap valueMap = new KeyValueMap();
- initWithValueMap(valueMap);
- }
-
- public String getFilterClassName() {
- return getClass().getSimpleName();
- }
-
- public final String getName() {
- return mName;
- }
-
- public boolean isOpen() {
- return mIsOpen;
- }
-
- public void setInputFrame(String inputName, Frame frame) {
- FilterPort port = getInputPort(inputName);
- if (!port.isOpen()) {
- port.open();
- }
- port.setFrame(frame);
- }
-
- public final void setInputValue(String inputName, Object value) {
- setInputFrame(inputName, wrapInputValue(inputName, value));
- }
-
- protected void prepare(FilterContext context) {
- }
-
- protected void parametersUpdated(Set<String> updated) {
- }
-
- protected void delayNextProcess(int millisecs) {
- mSleepDelay = millisecs;
- mStatus = STATUS_SLEEPING;
- }
-
- public abstract void setupPorts();
-
- public FrameFormat getOutputFormat(String portName, FrameFormat inputFormat) {
- return null;
- }
-
- public final FrameFormat getInputFormat(String portName) {
- InputPort inputPort = getInputPort(portName);
- return inputPort.getSourceFormat();
- }
-
- public void open(FilterContext context) {
- }
-
- public abstract void process(FilterContext context);
-
- public final int getSleepDelay() {
- return 250;
- }
-
- public void close(FilterContext context) {
- }
-
- public void tearDown(FilterContext context) {
- }
-
- public final int getNumberOfConnectedInputs() {
- int c = 0;
- for (InputPort inputPort : mInputPorts.values()) {
- if (inputPort.isConnected()) {
- ++c;
- }
- }
- return c;
- }
-
- public final int getNumberOfConnectedOutputs() {
- int c = 0;
- for (OutputPort outputPort : mOutputPorts.values()) {
- if (outputPort.isConnected()) {
- ++c;
- }
- }
- return c;
- }
-
- public final int getNumberOfInputs() {
- return mOutputPorts == null ? 0 : mInputPorts.size();
- }
-
- public final int getNumberOfOutputs() {
- return mInputPorts == null ? 0 : mOutputPorts.size();
- }
-
- public final InputPort getInputPort(String portName) {
- if (mInputPorts == null) {
- throw new NullPointerException("Attempting to access input port '" + portName
- + "' of " + this + " before Filter has been initialized!");
- }
- InputPort result = mInputPorts.get(portName);
- if (result == null) {
- throw new IllegalArgumentException("Unknown input port '" + portName + "' on filter "
- + this + "!");
- }
- return result;
- }
-
- public final OutputPort getOutputPort(String portName) {
- if (mInputPorts == null) {
- throw new NullPointerException("Attempting to access output port '" + portName
- + "' of " + this + " before Filter has been initialized!");
- }
- OutputPort result = mOutputPorts.get(portName);
- if (result == null) {
- throw new IllegalArgumentException("Unknown output port '" + portName + "' on filter "
- + this + "!");
- }
- return result;
- }
-
- protected final void pushOutput(String name, Frame frame) {
- if (frame.getTimestamp() == Frame.TIMESTAMP_NOT_SET) {
- if (mLogVerbose) Log.v(TAG, "Default-setting output Frame timestamp on port " + name + " to " + mCurrentTimestamp);
- frame.setTimestamp(mCurrentTimestamp);
- }
- getOutputPort(name).pushFrame(frame);
- }
-
- protected final Frame pullInput(String name) {
- Frame result = getInputPort(name).pullFrame();
- if (mCurrentTimestamp == Frame.TIMESTAMP_UNKNOWN) {
- mCurrentTimestamp = result.getTimestamp();
- if (mLogVerbose) Log.v(TAG, "Default-setting current timestamp from input port " + name + " to " + mCurrentTimestamp);
- }
- // As result is retained, we add it to the release pool here
- mFramesToRelease.add(result);
-
- return result;
- }
-
- public void fieldPortValueUpdated(String name, FilterContext context) {
- }
-
- /**
- * Transfers any frame from an input port to its destination. This is useful to force a
- * transfer from a FieldPort or ProgramPort to its connected target (field or program variable).
- */
- protected void transferInputPortFrame(String name, FilterContext context) {
- getInputPort(name).transfer(context);
- }
-
- /**
- * Assigns all program variables to the ports they are connected to. Call this after
- * constructing a Program instance with attached ProgramPorts.
- */
- protected void initProgramInputs(Program program, FilterContext context) {
- if (program != null) {
- for (InputPort inputPort : mInputPorts.values()) {
- if (inputPort.getTarget() == program) {
- inputPort.transfer(context);
- }
- }
- }
- }
-
- /**
- * Adds an input port to the filter. You should call this from within setupPorts, if your
- * filter has input ports. No type-checking is performed on the input. If you would like to
- * check against a type mask, use
- * {@link #addMaskedInputPort(String, FrameFormat) addMaskedInputPort} instead.
- *
- * @param name the name of the input port
- */
- protected void addInputPort(String name) {
- addMaskedInputPort(name, null);
- }
-
- /**
- * Adds an input port to the filter. You should call this from within setupPorts, if your
- * filter has input ports. When type-checking is performed, the input format is
- * checked against the provided format mask. An exception is thrown in case of a conflict.
- *
- * @param name the name of the input port
- * @param formatMask a format mask, which filters the allowable input types
- */
- protected void addMaskedInputPort(String name, FrameFormat formatMask) {
- InputPort port = new StreamPort(this, name);
- if (mLogVerbose) Log.v(TAG, "Filter " + this + " adding " + port);
- mInputPorts.put(name, port);
- port.setPortFormat(formatMask);
- }
-
- /**
- * Adds an output port to the filter with a fixed output format. You should call this from
- * within setupPorts, if your filter has output ports. You cannot use this method, if your
- * output format depends on the input format (e.g. in a pass-through filter). In this case, use
- * {@link #addOutputBasedOnInput(String, String) addOutputBasedOnInput} instead.
- *
- * @param name the name of the output port
- * @param format the fixed output format of this port
- */
- protected void addOutputPort(String name, FrameFormat format) {
- OutputPort port = new OutputPort(this, name);
- if (mLogVerbose) Log.v(TAG, "Filter " + this + " adding " + port);
- port.setPortFormat(format);
- mOutputPorts.put(name, port);
- }
-
- /**
- * Adds an output port to the filter. You should call this from within setupPorts, if your
- * filter has output ports. Using this method indicates that the output format for this
- * particular port, depends on the format of an input port. You MUST also override
- * {@link #getOutputFormat(String, FrameFormat) getOutputFormat} to specify what format your
- * filter will output for a given input. If the output format of your filter port does not
- * depend on the input, use {@link #addOutputPort(String, FrameFormat) addOutputPort} instead.
- *
- * @param outputName the name of the output port
- * @param inputName the name of the input port, that this output depends on
- */
- protected void addOutputBasedOnInput(String outputName, String inputName) {
- OutputPort port = new OutputPort(this, outputName);
- if (mLogVerbose) Log.v(TAG, "Filter " + this + " adding " + port);
- port.setBasePort(getInputPort(inputName));
- mOutputPorts.put(outputName, port);
- }
-
- protected void addFieldPort(String name,
- Field field,
- boolean hasDefault,
- boolean isFinal) {
- // Make sure field is accessible
- field.setAccessible(true);
-
- // Create port for this input
- InputPort fieldPort = isFinal
- ? new FinalPort(this, name, field, hasDefault)
- : new FieldPort(this, name, field, hasDefault);
-
- // Create format for this input
- if (mLogVerbose) Log.v(TAG, "Filter " + this + " adding " + fieldPort);
- MutableFrameFormat format = ObjectFormat.fromClass(field.getType(),
- FrameFormat.TARGET_SIMPLE);
- fieldPort.setPortFormat(format);
-
- // Add port
- mInputPorts.put(name, fieldPort);
- }
-
- protected void addProgramPort(String name,
- String varName,
- Field field,
- Class varType,
- boolean hasDefault) {
- // Make sure field is accessible
- field.setAccessible(true);
-
- // Create port for this input
- InputPort programPort = new ProgramPort(this, name, varName, field, hasDefault);
-
- // Create format for this input
- if (mLogVerbose) Log.v(TAG, "Filter " + this + " adding " + programPort);
- MutableFrameFormat format = ObjectFormat.fromClass(varType,
- FrameFormat.TARGET_SIMPLE);
- programPort.setPortFormat(format);
-
- // Add port
- mInputPorts.put(name, programPort);
- }
-
- protected void closeOutputPort(String name) {
- getOutputPort(name).close();
- }
-
- /**
- * Specifies whether the filter should not be scheduled until a frame is available on that
- * input port. Note, that setting this to false, does not block a new frame from coming in
- * (though there is no necessity to pull that frame for processing).
- * @param portName the name of the input port.
- * @param waits true, if the filter should wait for a frame on this port.
- */
- protected void setWaitsOnInputPort(String portName, boolean waits) {
- getInputPort(portName).setBlocking(waits);
- }
-
- /**
- * Specifies whether the filter should not be scheduled until the output port is free, i.e.
- * there is no frame waiting on that output.
- * @param portName the name of the output port.
- * @param waits true, if the filter should wait for the port to become free.
- */
- protected void setWaitsOnOutputPort(String portName, boolean waits) {
- getOutputPort(portName).setBlocking(waits);
- }
-
- public String toString() {
- return "'" + getName() + "' (" + getFilterClassName() + ")";
- }
-
- // Core internal methods ///////////////////////////////////////////////////////////////////////
- final Collection<InputPort> getInputPorts() {
- return mInputPorts.values();
- }
-
- final Collection<OutputPort> getOutputPorts() {
- return mOutputPorts.values();
- }
-
- final synchronized int getStatus() {
- return mStatus;
- }
-
- final synchronized void unsetStatus(int flag) {
- mStatus &= ~flag;
- }
-
- final synchronized void performOpen(FilterContext context) {
- if (!mIsOpen) {
- if (mStatus == STATUS_UNPREPARED) {
- if (mLogVerbose) Log.v(TAG, "Preparing " + this);
- prepare(context);
- mStatus = STATUS_PREPARED;
- }
- if (mStatus == STATUS_PREPARED) {
- if (mLogVerbose) Log.v(TAG, "Opening " + this);
- open(context);
- mStatus = STATUS_PROCESSING;
- }
- if (mStatus != STATUS_PROCESSING) {
- throw new RuntimeException("Filter " + this + " was brought into invalid state during "
- + "opening (state: " + mStatus + ")!");
- }
- mIsOpen = true;
- }
- }
-
- final synchronized void performProcess(FilterContext context) {
- if (mStatus == STATUS_RELEASED) {
- throw new RuntimeException("Filter " + this + " is already torn down!");
- }
- transferInputFrames(context);
- if (mStatus < STATUS_PROCESSING) {
- performOpen(context);
- }
- if (mLogVerbose) Log.v(TAG, "Processing " + this);
- mCurrentTimestamp = Frame.TIMESTAMP_UNKNOWN;
- process(context);
- releasePulledFrames(context);
- if (filterMustClose()) {
- performClose(context);
- }
- }
-
- final synchronized void performClose(FilterContext context) {
- if (mIsOpen) {
- if (mLogVerbose) Log.v(TAG, "Closing " + this);
- mIsOpen = false;
- mStatus = STATUS_PREPARED;
- close(context);
- closePorts();
- }
- }
-
- final synchronized void performTearDown(FilterContext context) {
- performClose(context);
- if (mStatus != STATUS_RELEASED) {
- tearDown(context);
- mStatus = STATUS_RELEASED;
- }
- }
-
- synchronized final boolean canProcess() {
- if (mLogVerbose) Log.v(TAG, "Checking if can process: " + this + " (" + mStatus + ").");
- if (mStatus <= STATUS_PROCESSING) {
- return inputConditionsMet() && outputConditionsMet();
- } else {
- return false;
- }
- }
-
- final void openOutputs() {
- if (mLogVerbose) Log.v(TAG, "Opening all output ports on " + this + "!");
- for (OutputPort outputPort : mOutputPorts.values()) {
- if (!outputPort.isOpen()) {
- outputPort.open();
- }
- }
- }
-
- final void clearInputs() {
- for (InputPort inputPort : mInputPorts.values()) {
- inputPort.clear();
- }
- }
-
- final void clearOutputs() {
- for (OutputPort outputPort : mOutputPorts.values()) {
- outputPort.clear();
- }
- }
-
- final void notifyFieldPortValueUpdated(String name, FilterContext context) {
- if (mStatus == STATUS_PROCESSING || mStatus == STATUS_PREPARED) {
- fieldPortValueUpdated(name, context);
- }
- }
-
- final synchronized void pushInputFrame(String inputName, Frame frame) {
- FilterPort port = getInputPort(inputName);
- if (!port.isOpen()) {
- port.open();
- }
- port.pushFrame(frame);
- }
-
- final synchronized void pushInputValue(String inputName, Object value) {
- pushInputFrame(inputName, wrapInputValue(inputName, value));
- }
-
- // Filter internal methods /////////////////////////////////////////////////////////////////////
- private final void initFinalPorts(KeyValueMap values) {
- mInputPorts = new HashMap<String, InputPort>();
- mOutputPorts = new HashMap<String, OutputPort>();
- addAndSetFinalPorts(values);
- }
-
- private final void initRemainingPorts(KeyValueMap values) {
- addAnnotatedPorts();
- setupPorts(); // TODO: rename to addFilterPorts() ?
- setInitialInputValues(values);
- }
-
- private final void addAndSetFinalPorts(KeyValueMap values) {
- Class filterClass = getClass();
- Annotation annotation;
- for (Field field : filterClass.getDeclaredFields()) {
- if ((annotation = field.getAnnotation(GenerateFinalPort.class)) != null) {
- GenerateFinalPort generator = (GenerateFinalPort)annotation;
- String name = generator.name().isEmpty() ? field.getName() : generator.name();
- boolean hasDefault = generator.hasDefault();
- addFieldPort(name, field, hasDefault, true);
- if (values.containsKey(name)) {
- setImmediateInputValue(name, values.get(name));
- values.remove(name);
- } else if (!generator.hasDefault()) {
- throw new RuntimeException("No value specified for final input port '"
- + name + "' of filter " + this + "!");
- }
- }
- }
- }
-
- private final void addAnnotatedPorts() {
- Class filterClass = getClass();
- Annotation annotation;
- for (Field field : filterClass.getDeclaredFields()) {
- if ((annotation = field.getAnnotation(GenerateFieldPort.class)) != null) {
- GenerateFieldPort generator = (GenerateFieldPort)annotation;
- addFieldGenerator(generator, field);
- } else if ((annotation = field.getAnnotation(GenerateProgramPort.class)) != null) {
- GenerateProgramPort generator = (GenerateProgramPort)annotation;
- addProgramGenerator(generator, field);
- } else if ((annotation = field.getAnnotation(GenerateProgramPorts.class)) != null) {
- GenerateProgramPorts generators = (GenerateProgramPorts)annotation;
- for (GenerateProgramPort generator : generators.value()) {
- addProgramGenerator(generator, field);
- }
- }
- }
- }
-
- private final void addFieldGenerator(GenerateFieldPort generator, Field field) {
- String name = generator.name().isEmpty() ? field.getName() : generator.name();
- boolean hasDefault = generator.hasDefault();
- addFieldPort(name, field, hasDefault, false);
- }
-
- private final void addProgramGenerator(GenerateProgramPort generator, Field field) {
- String name = generator.name();
- String varName = generator.variableName().isEmpty() ? name
- : generator.variableName();
- Class varType = generator.type();
- boolean hasDefault = generator.hasDefault();
- addProgramPort(name, varName, field, varType, hasDefault);
- }
-
- private final void setInitialInputValues(KeyValueMap values) {
- for (Entry<String, Object> entry : values.entrySet()) {
- setInputValue(entry.getKey(), entry.getValue());
- }
- }
-
- private final void setImmediateInputValue(String name, Object value) {
- if (mLogVerbose) Log.v(TAG, "Setting immediate value " + value + " for port " + name + "!");
- FilterPort port = getInputPort(name);
- port.open();
- port.setFrame(SimpleFrame.wrapObject(value, null));
- }
-
- private final void transferInputFrames(FilterContext context) {
- for (InputPort inputPort : mInputPorts.values()) {
- inputPort.transfer(context);
- }
- }
-
- private final Frame wrapInputValue(String inputName, Object value) {
- MutableFrameFormat inputFormat = ObjectFormat.fromObject(value, FrameFormat.TARGET_SIMPLE);
- if (value == null) {
- // If the value is null, the format cannot guess the class, so we adjust it to the
- // class of the input port here
- FrameFormat portFormat = getInputPort(inputName).getPortFormat();
- Class portClass = (portFormat == null) ? null : portFormat.getObjectClass();
- inputFormat.setObjectClass(portClass);
- }
-
- // Serialize if serializable, and type is not an immutable primitive.
- boolean shouldSerialize = !(value instanceof Number)
- && !(value instanceof Boolean)
- && !(value instanceof String)
- && value instanceof Serializable;
-
- // Create frame wrapper
- Frame frame = shouldSerialize
- ? new SerializedFrame(inputFormat, null)
- : new SimpleFrame(inputFormat, null);
- frame.setObjectValue(value);
- return frame;
- }
-
- private final void releasePulledFrames(FilterContext context) {
- for (Frame frame : mFramesToRelease) {
- context.getFrameManager().releaseFrame(frame);
- }
- mFramesToRelease.clear();
- }
-
- private final boolean inputConditionsMet() {
- for (FilterPort port : mInputPorts.values()) {
- if (!port.isReady()) {
- if (mLogVerbose) Log.v(TAG, "Input condition not met: " + port + "!");
- return false;
- }
- }
- return true;
- }
-
- private final boolean outputConditionsMet() {
- for (FilterPort port : mOutputPorts.values()) {
- if (!port.isReady()) {
- if (mLogVerbose) Log.v(TAG, "Output condition not met: " + port + "!");
- return false;
- }
- }
- return true;
- }
-
- private final void closePorts() {
- if (mLogVerbose) Log.v(TAG, "Closing all ports on " + this + "!");
- for (InputPort inputPort : mInputPorts.values()) {
- inputPort.close();
- }
- for (OutputPort outputPort : mOutputPorts.values()) {
- outputPort.close();
- }
- }
-
- private final boolean filterMustClose() {
- for (InputPort inputPort : mInputPorts.values()) {
- if (inputPort.filterMustClose()) {
- if (mLogVerbose) Log.v(TAG, "Filter " + this + " must close due to port " + inputPort);
- return true;
- }
- }
- for (OutputPort outputPort : mOutputPorts.values()) {
- if (outputPort.filterMustClose()) {
- if (mLogVerbose) Log.v(TAG, "Filter " + this + " must close due to port " + outputPort);
- return true;
- }
- }
- return false;
- }
-}
+++ /dev/null
-/*
- * 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.core;
-
-import android.filterfw.core.Filter;
-import android.filterfw.core.Frame;
-import android.filterfw.core.FrameManager;
-import android.filterfw.core.GLEnvironment;
-
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Set;
-
-/**
- * @hide
- */
-public class FilterContext {
-
- private FrameManager mFrameManager;
- private GLEnvironment mGLEnvironment;
- private HashMap<String, Frame> mStoredFrames = new HashMap<String, Frame>();
- private Set<FilterGraph> mGraphs = new HashSet<FilterGraph>();
-
- public FrameManager getFrameManager() {
- return mFrameManager;
- }
-
- public void setFrameManager(FrameManager manager) {
- if (manager == null) {
- throw new NullPointerException("Attempting to set null FrameManager!");
- } else if (manager.getContext() != null) {
- throw new IllegalArgumentException("Attempting to set FrameManager which is already "
- + "bound to another FilterContext!");
- } else {
- mFrameManager = manager;
- mFrameManager.setContext(this);
- }
- }
-
- public GLEnvironment getGLEnvironment() {
- return mGLEnvironment;
- }
-
- public void initGLEnvironment(GLEnvironment environment) {
- if (mGLEnvironment == null) {
- mGLEnvironment = environment;
- } else {
- throw new RuntimeException("Attempting to re-initialize GL Environment for " +
- "FilterContext!");
- }
- }
-
- public interface OnFrameReceivedListener {
- public void onFrameReceived(Filter filter, Frame frame, Object userData);
- }
-
- public synchronized void storeFrame(String key, Frame frame) {
- Frame storedFrame = fetchFrame(key);
- if (storedFrame != null) {
- storedFrame.release();
- }
- frame.onFrameStore();
- mStoredFrames.put(key, frame.retain());
- }
-
- public synchronized Frame fetchFrame(String key) {
- Frame frame = mStoredFrames.get(key);
- if (frame != null) {
- frame.onFrameFetch();
- }
- return frame;
- }
-
- public synchronized void removeFrame(String key) {
- Frame frame = mStoredFrames.get(key);
- if (frame != null) {
- mStoredFrames.remove(key);
- frame.release();
- }
- }
-
- public synchronized void tearDown() {
- // Release stored frames
- for (Frame frame : mStoredFrames.values()) {
- frame.release();
- }
- mStoredFrames.clear();
-
- // Release graphs
- for (FilterGraph graph : mGraphs) {
- graph.tearDown(this);
- }
- mGraphs.clear();
-
- // Release frame manager
- if (mFrameManager != null) {
- mFrameManager.tearDown();
- mFrameManager = null;
- }
-
- // Release GL context
- if (mGLEnvironment != null) {
- mGLEnvironment.tearDown();
- mGLEnvironment = null;
- }
- }
-
- final void addGraph(FilterGraph graph) {
- mGraphs.add(graph);
- }
-}
+++ /dev/null
-/*
- * 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.core;
-
-import android.filterfw.core.Filter;
-import android.util.Log;
-
-import dalvik.system.PathClassLoader;
-
-import java.lang.reflect.Constructor;
-import java.lang.ClassLoader;
-import java.lang.Thread;
-import java.util.HashSet;
-
-/**
- * @hide
- */
-public class FilterFactory {
-
- private static FilterFactory mSharedFactory;
- private HashSet<String> mPackages = new HashSet<String>();
-
- private static ClassLoader mCurrentClassLoader;
- private static HashSet<String> mLibraries;
- private static Object mClassLoaderGuard;
-
- static {
- mCurrentClassLoader = Thread.currentThread().getContextClassLoader();
- mLibraries = new HashSet<String>();
- mClassLoaderGuard = new Object();
- }
-
- private static final String TAG = "FilterFactory";
- private static boolean mLogVerbose = Log.isLoggable(TAG, Log.VERBOSE);
-
- public static FilterFactory sharedFactory() {
- if (mSharedFactory == null) {
- mSharedFactory = new FilterFactory();
- }
- return mSharedFactory;
- }
-
- /**
- * Adds a new Java library to the list to be scanned for filters.
- * libraryPath must be an absolute path of the jar file. This needs to be
- * static because only one classloader per process can open a shared native
- * library, which a filter may well have.
- */
- public static void addFilterLibrary(String libraryPath) {
- if (mLogVerbose) Log.v(TAG, "Adding filter library " + libraryPath);
- synchronized(mClassLoaderGuard) {
- if (mLibraries.contains(libraryPath)) {
- if (mLogVerbose) Log.v(TAG, "Library already added");
- return;
- }
- mLibraries.add(libraryPath);
- // Chain another path loader to the current chain
- mCurrentClassLoader = new PathClassLoader(libraryPath, mCurrentClassLoader);
- }
- }
-
- public void addPackage(String packageName) {
- if (mLogVerbose) Log.v(TAG, "Adding package " + packageName);
- /* TODO: This should use a getPackage call in the caller's context, but no such method exists.
- Package pkg = Package.getPackage(packageName);
- if (pkg == null) {
- throw new IllegalArgumentException("Unknown filter package '" + packageName + "'!");
- }
- */
- mPackages.add(packageName);
- }
-
- public Filter createFilterByClassName(String className, String filterName) {
- if (mLogVerbose) Log.v(TAG, "Looking up class " + className);
- Class filterClass = null;
-
- // Look for the class in the imported packages
- for (String packageName : mPackages) {
- try {
- if (mLogVerbose) Log.v(TAG, "Trying "+packageName + "." + className);
- synchronized(mClassLoaderGuard) {
- filterClass = mCurrentClassLoader.loadClass(packageName + "." + className);
- }
- } catch (ClassNotFoundException e) {
- continue;
- }
- // Exit loop if class was found.
- if (filterClass != null) {
- break;
- }
- }
- if (filterClass == null) {
- throw new IllegalArgumentException("Unknown filter class '" + className + "'!");
- }
- return createFilterByClass(filterClass, filterName);
- }
-
- public Filter createFilterByClass(Class filterClass, String filterName) {
- // Make sure this is a Filter subclass
- try {
- filterClass.asSubclass(Filter.class);
- } catch (ClassCastException e) {
- throw new IllegalArgumentException("Attempting to allocate class '" + filterClass
- + "' which is not a subclass of Filter!");
- }
-
- // Look for the correct constructor
- Constructor filterConstructor = null;
- try {
- filterConstructor = filterClass.getConstructor(String.class);
- } catch (NoSuchMethodException e) {
- throw new IllegalArgumentException("The filter class '" + filterClass
- + "' does not have a constructor of the form <init>(String name)!");
- }
-
- // Construct the filter
- Filter filter = null;
- try {
- filter = (Filter)filterConstructor.newInstance(filterName);
- } catch (Throwable t) {
- // Condition checked below
- }
-
- if (filter == null) {
- throw new IllegalArgumentException("Could not construct the filter '"
- + filterName + "'!");
- }
- return filter;
- }
-}
+++ /dev/null
-/*
- * 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.core;
-
-import java.util.Map.Entry;
-
-/**
- * @hide
- */
-public class FilterFunction {
-
- private Filter mFilter;
- private FilterContext mFilterContext;
- private boolean mFilterIsSetup = false;
- private FrameHolderPort[] mResultHolders;
-
- private class FrameHolderPort extends StreamPort {
- public FrameHolderPort() {
- super(null, "holder");
- }
- }
-
- public FilterFunction(FilterContext context, Filter filter) {
- mFilterContext = context;
- mFilter = filter;
- }
-
- public Frame execute(KeyValueMap inputMap) {
- int filterOutCount = mFilter.getNumberOfOutputs();
-
- // Sanity checks
- if (filterOutCount > 1) {
- throw new RuntimeException("Calling execute on filter " + mFilter + " with multiple "
- + "outputs! Use executeMulti() instead!");
- }
-
- // Setup filter
- if (!mFilterIsSetup) {
- connectFilterOutputs();
- mFilterIsSetup = true;
- }
-
- // Make sure GL environment is active
- boolean didActivateGLEnv = false;
- GLEnvironment glEnv = mFilterContext.getGLEnvironment();
- if (glEnv != null && !glEnv.isActive()) {
- glEnv.activate();
- didActivateGLEnv = true;
- }
-
- // Setup the inputs
- for (Entry<String, Object> entry : inputMap.entrySet()) {
- if (entry.getValue() instanceof Frame) {
- mFilter.pushInputFrame(entry.getKey(), (Frame)entry.getValue());
- } else {
- mFilter.pushInputValue(entry.getKey(), entry.getValue());
- }
- }
-
- // Process the filter
- if (mFilter.getStatus() != Filter.STATUS_PROCESSING) {
- mFilter.openOutputs();
- }
-
- mFilter.performProcess(mFilterContext);
-
- // Create result handle
- Frame result = null;
- if (filterOutCount == 1 && mResultHolders[0].hasFrame()) {
- result = mResultHolders[0].pullFrame();
- }
-
- // Deactivate GL environment if activated
- if (didActivateGLEnv) {
- glEnv.deactivate();
- }
-
- return result;
- }
-
- public Frame executeWithArgList(Object... inputs) {
- return execute(KeyValueMap.fromKeyValues(inputs));
- }
-
- public void close() {
- mFilter.performClose(mFilterContext);
- }
-
- public FilterContext getContext() {
- return mFilterContext;
- }
-
- public Filter getFilter() {
- return mFilter;
- }
-
- public void setInputFrame(String input, Frame frame) {
- mFilter.setInputFrame(input, frame);
- }
-
- public void setInputValue(String input, Object value) {
- mFilter.setInputValue(input, value);
- }
-
- public void tearDown() {
- mFilter.performTearDown(mFilterContext);
- mFilter = null;
- }
-
- @Override
- public String toString() {
- return mFilter.getName();
- }
-
- private void connectFilterOutputs() {
- int i = 0;
- mResultHolders = new FrameHolderPort[mFilter.getNumberOfOutputs()];
- for (OutputPort outputPort : mFilter.getOutputPorts()) {
- mResultHolders[i] = new FrameHolderPort();
- outputPort.connectTo(mResultHolders[i]);
- ++i;
- }
- }
-}
+++ /dev/null
-/*
- * 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.core;
-
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Iterator;
-import java.util.LinkedList;
-import java.util.Map.Entry;
-import java.util.Set;
-import java.util.Stack;
-
-import android.filterfw.core.FilterContext;
-import android.filterfw.core.KeyValueMap;
-import android.filterpacks.base.FrameBranch;
-import android.filterpacks.base.NullFilter;
-
-import android.util.Log;
-
-/**
- * @hide
- */
-public class FilterGraph {
-
- private HashSet<Filter> mFilters = new HashSet<Filter>();
- private HashMap<String, Filter> mNameMap = new HashMap<String, Filter>();
- private HashMap<OutputPort, LinkedList<InputPort>> mPreconnections = new
- HashMap<OutputPort, LinkedList<InputPort>>();
-
- public static final int AUTOBRANCH_OFF = 0;
- public static final int AUTOBRANCH_SYNCED = 1;
- public static final int AUTOBRANCH_UNSYNCED = 2;
-
- public static final int TYPECHECK_OFF = 0;
- public static final int TYPECHECK_DYNAMIC = 1;
- public static final int TYPECHECK_STRICT = 2;
-
- private boolean mIsReady = false;
- private int mAutoBranchMode = AUTOBRANCH_OFF;
- private int mTypeCheckMode = TYPECHECK_STRICT;
- private boolean mDiscardUnconnectedOutputs = false;
-
- private boolean mLogVerbose;
- private String TAG = "FilterGraph";
-
- public FilterGraph() {
- mLogVerbose = Log.isLoggable(TAG, Log.VERBOSE);
- }
-
- public boolean addFilter(Filter filter) {
- if (!containsFilter(filter)) {
- mFilters.add(filter);
- mNameMap.put(filter.getName(), filter);
- return true;
- }
- return false;
- }
-
- public boolean containsFilter(Filter filter) {
- return mFilters.contains(filter);
- }
-
- public Filter getFilter(String name) {
- return mNameMap.get(name);
- }
-
- public void connect(Filter source,
- String outputName,
- Filter target,
- String inputName) {
- if (source == null || target == null) {
- throw new IllegalArgumentException("Passing null Filter in connect()!");
- } else if (!containsFilter(source) || !containsFilter(target)) {
- throw new RuntimeException("Attempting to connect filter not in graph!");
- }
-
- OutputPort outPort = source.getOutputPort(outputName);
- InputPort inPort = target.getInputPort(inputName);
- if (outPort == null) {
- throw new RuntimeException("Unknown output port '" + outputName + "' on Filter " +
- source + "!");
- } else if (inPort == null) {
- throw new RuntimeException("Unknown input port '" + inputName + "' on Filter " +
- target + "!");
- }
-
- preconnect(outPort, inPort);
- }
-
- public void connect(String sourceName,
- String outputName,
- String targetName,
- String inputName) {
- Filter source = getFilter(sourceName);
- Filter target = getFilter(targetName);
- if (source == null) {
- throw new RuntimeException(
- "Attempting to connect unknown source filter '" + sourceName + "'!");
- } else if (target == null) {
- throw new RuntimeException(
- "Attempting to connect unknown target filter '" + targetName + "'!");
- }
- connect(source, outputName, target, inputName);
- }
-
- public Set<Filter> getFilters() {
- return mFilters;
- }
-
- public void beginProcessing() {
- if (mLogVerbose) Log.v(TAG, "Opening all filter connections...");
- for (Filter filter : mFilters) {
- filter.openOutputs();
- }
- mIsReady = true;
- }
-
- public void flushFrames() {
- for (Filter filter : mFilters) {
- filter.clearOutputs();
- }
- }
-
- public void closeFilters(FilterContext context) {
- if (mLogVerbose) Log.v(TAG, "Closing all filters...");
- for (Filter filter : mFilters) {
- filter.performClose(context);
- }
- mIsReady = false;
- }
-
- public boolean isReady() {
- return mIsReady;
- }
-
- public void setAutoBranchMode(int autoBranchMode) {
- mAutoBranchMode = autoBranchMode;
- }
-
- public void setDiscardUnconnectedOutputs(boolean discard) {
- mDiscardUnconnectedOutputs = discard;
- }
-
- public void setTypeCheckMode(int typeCheckMode) {
- mTypeCheckMode = typeCheckMode;
- }
-
- public void tearDown(FilterContext context) {
- if (!mFilters.isEmpty()) {
- flushFrames();
- for (Filter filter : mFilters) {
- filter.performTearDown(context);
- }
- mFilters.clear();
- mNameMap.clear();
- mIsReady = false;
- }
- }
-
- private boolean readyForProcessing(Filter filter, Set<Filter> processed) {
- // Check if this has been already processed
- if (processed.contains(filter)) {
- return false;
- }
-
- // Check if all dependencies have been processed
- for (InputPort port : filter.getInputPorts()) {
- Filter dependency = port.getSourceFilter();
- if (dependency != null && !processed.contains(dependency)) {
- return false;
- }
- }
- return true;
- }
-
- private void runTypeCheck() {
- Stack<Filter> filterStack = new Stack<Filter>();
- Set<Filter> processedFilters = new HashSet<Filter>();
- filterStack.addAll(getSourceFilters());
-
- while (!filterStack.empty()) {
- // Get current filter and mark as processed
- Filter filter = filterStack.pop();
- processedFilters.add(filter);
-
- // Anchor output formats
- updateOutputs(filter);
-
- // Perform type check
- if (mLogVerbose) Log.v(TAG, "Running type check on " + filter + "...");
- runTypeCheckOn(filter);
-
- // Push connected filters onto stack
- for (OutputPort port : filter.getOutputPorts()) {
- Filter target = port.getTargetFilter();
- if (target != null && readyForProcessing(target, processedFilters)) {
- filterStack.push(target);
- }
- }
- }
-
- // Make sure all ports were setup
- if (processedFilters.size() != getFilters().size()) {
- throw new RuntimeException("Could not schedule all filters! Is your graph malformed?");
- }
- }
-
- private void updateOutputs(Filter filter) {
- for (OutputPort outputPort : filter.getOutputPorts()) {
- InputPort inputPort = outputPort.getBasePort();
- if (inputPort != null) {
- FrameFormat inputFormat = inputPort.getSourceFormat();
- FrameFormat outputFormat = filter.getOutputFormat(outputPort.getName(),
- inputFormat);
- if (outputFormat == null) {
- throw new RuntimeException("Filter did not return an output format for "
- + outputPort + "!");
- }
- outputPort.setPortFormat(outputFormat);
- }
- }
- }
-
- private void runTypeCheckOn(Filter filter) {
- for (InputPort inputPort : filter.getInputPorts()) {
- if (mLogVerbose) Log.v(TAG, "Type checking port " + inputPort);
- FrameFormat sourceFormat = inputPort.getSourceFormat();
- FrameFormat targetFormat = inputPort.getPortFormat();
- if (sourceFormat != null && targetFormat != null) {
- if (mLogVerbose) Log.v(TAG, "Checking " + sourceFormat + " against " + targetFormat + ".");
-
- boolean compatible = true;
- switch (mTypeCheckMode) {
- case TYPECHECK_OFF:
- inputPort.setChecksType(false);
- break;
- case TYPECHECK_DYNAMIC:
- compatible = sourceFormat.mayBeCompatibleWith(targetFormat);
- inputPort.setChecksType(true);
- break;
- case TYPECHECK_STRICT:
- compatible = sourceFormat.isCompatibleWith(targetFormat);
- inputPort.setChecksType(false);
- break;
- }
-
- if (!compatible) {
- throw new RuntimeException("Type mismatch: Filter " + filter + " expects a "
- + "format of type " + targetFormat + " but got a format of type "
- + sourceFormat + "!");
- }
- }
- }
- }
-
- private void checkConnections() {
- // TODO
- }
-
- private void discardUnconnectedOutputs() {
- // Connect unconnected ports to Null filters
- LinkedList<Filter> addedFilters = new LinkedList<Filter>();
- for (Filter filter : mFilters) {
- int id = 0;
- for (OutputPort port : filter.getOutputPorts()) {
- if (!port.isConnected()) {
- if (mLogVerbose) Log.v(TAG, "Autoconnecting unconnected " + port + " to Null filter.");
- NullFilter nullFilter = new NullFilter(filter.getName() + "ToNull" + id);
- nullFilter.init();
- addedFilters.add(nullFilter);
- port.connectTo(nullFilter.getInputPort("frame"));
- ++id;
- }
- }
- }
- // Add all added filters to this graph
- for (Filter filter : addedFilters) {
- addFilter(filter);
- }
- }
-
- private void removeFilter(Filter filter) {
- mFilters.remove(filter);
- mNameMap.remove(filter.getName());
- }
-
- private void preconnect(OutputPort outPort, InputPort inPort) {
- LinkedList<InputPort> targets;
- targets = mPreconnections.get(outPort);
- if (targets == null) {
- targets = new LinkedList<InputPort>();
- mPreconnections.put(outPort, targets);
- }
- targets.add(inPort);
- }
-
- private void connectPorts() {
- int branchId = 1;
- for (Entry<OutputPort, LinkedList<InputPort>> connection : mPreconnections.entrySet()) {
- OutputPort outputPort = connection.getKey();
- LinkedList<InputPort> inputPorts = connection.getValue();
- if (inputPorts.size() == 1) {
- outputPort.connectTo(inputPorts.get(0));
- } else if (mAutoBranchMode == AUTOBRANCH_OFF) {
- throw new RuntimeException("Attempting to connect " + outputPort + " to multiple "
- + "filter ports! Enable auto-branching to allow this.");
- } else {
- if (mLogVerbose) Log.v(TAG, "Creating branch for " + outputPort + "!");
- FrameBranch branch = null;
- if (mAutoBranchMode == AUTOBRANCH_SYNCED) {
- branch = new FrameBranch("branch" + branchId++);
- } else {
- throw new RuntimeException("TODO: Unsynced branches not implemented yet!");
- }
- KeyValueMap branchParams = new KeyValueMap();
- branch.initWithAssignmentList("outputs", inputPorts.size());
- addFilter(branch);
- outputPort.connectTo(branch.getInputPort("in"));
- Iterator<InputPort> inputPortIter = inputPorts.iterator();
- for (OutputPort branchOutPort : ((Filter)branch).getOutputPorts()) {
- branchOutPort.connectTo(inputPortIter.next());
- }
- }
- }
- mPreconnections.clear();
- }
-
- private HashSet<Filter> getSourceFilters() {
- HashSet<Filter> sourceFilters = new HashSet<Filter>();
- for (Filter filter : getFilters()) {
- if (filter.getNumberOfConnectedInputs() == 0) {
- if (mLogVerbose) Log.v(TAG, "Found source filter: " + filter);
- sourceFilters.add(filter);
- }
- }
- return sourceFilters;
- }
-
- // Core internal methods /////////////////////////////////////////////////////////////////////////
- void setupFilters() {
- if (mDiscardUnconnectedOutputs) {
- discardUnconnectedOutputs();
- }
- connectPorts();
- checkConnections();
- runTypeCheck();
- }
-}
+++ /dev/null
-/*
- * 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.core;
-
-import android.filterfw.core.Filter;
-import android.filterfw.core.FrameFormat;
-import android.util.Log;
-
-/**
- * @hide
- */
-public abstract class FilterPort {
-
- protected Filter mFilter;
- protected String mName;
- protected FrameFormat mPortFormat;
- protected boolean mIsBlocking = true;
- protected boolean mIsOpen = false;
- protected boolean mChecksType = false;
- private boolean mLogVerbose;
- private static final String TAG = "FilterPort";
-
- public FilterPort(Filter filter, String name) {
- mName = name;
- mFilter = filter;
- mLogVerbose = Log.isLoggable(TAG, Log.VERBOSE);
- }
-
- public boolean isAttached() {
- return mFilter != null;
- }
-
- public FrameFormat getPortFormat() {
- return mPortFormat;
- }
-
- public void setPortFormat(FrameFormat format) {
- mPortFormat = format;
- }
-
- public Filter getFilter() {
- return mFilter;
- }
-
- public String getName() {
- return mName;
- }
-
- public void setBlocking(boolean blocking) {
- mIsBlocking = blocking;
- }
-
- public void setChecksType(boolean checksType) {
- mChecksType = checksType;
- }
-
- public void open() {
- if (!mIsOpen) {
- if (mLogVerbose) Log.v(TAG, "Opening " + this);
- }
- mIsOpen = true;
- }
-
- public void close() {
- if (mIsOpen) {
- if (mLogVerbose) Log.v(TAG, "Closing " + this);
- }
- mIsOpen = false;
- }
-
- public boolean isOpen() {
- return mIsOpen;
- }
-
- public boolean isBlocking() {
- return mIsBlocking;
- }
-
- public abstract boolean filterMustClose();
-
- public abstract boolean isReady();
-
- public abstract void pushFrame(Frame frame);
-
- public abstract void setFrame(Frame frame);
-
- public abstract Frame pullFrame();
-
- public abstract boolean hasFrame();
-
- public abstract void clear();
-
- public String toString() {
- return "port '" + mName + "' of " + mFilter;
- }
-
- protected void assertPortIsOpen() {
- if (!isOpen()) {
- throw new RuntimeException("Illegal operation on closed " + this + "!");
- }
- }
-
- protected void checkFrameType(Frame frame, boolean forceCheck) {
- if ((mChecksType || forceCheck)
- && mPortFormat != null
- && !frame.getFormat().isCompatibleWith(mPortFormat)) {
- throw new RuntimeException("Frame passed to " + this + " is of incorrect type! "
- + "Expected " + mPortFormat + " but got " + frame.getFormat());
- }
- }
-
- protected void checkFrameManager(Frame frame, FilterContext context) {
- if (frame.getFrameManager() != null
- && frame.getFrameManager() != context.getFrameManager()) {
- throw new RuntimeException("Frame " + frame + " is managed by foreign FrameManager! ");
- }
- }
-}
-
+++ /dev/null
-/*
- * 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.core;
-
-import android.content.Context;
-import android.util.AttributeSet;
-import android.view.SurfaceHolder;
-import android.view.SurfaceView;
-
-/**
- * @hide
- */
-public class FilterSurfaceView extends SurfaceView implements SurfaceHolder.Callback {
-
- private static int STATE_ALLOCATED = 0;
- private static int STATE_CREATED = 1;
- private static int STATE_INITIALIZED = 2;
-
- private int mState = STATE_ALLOCATED;
- private SurfaceHolder.Callback mListener;
- private GLEnvironment mGLEnv;
- private int mFormat;
- private int mWidth;
- private int mHeight;
- private int mSurfaceId = -1;
-
- public FilterSurfaceView(Context context) {
- super(context);
- getHolder().addCallback(this);
- }
-
- public FilterSurfaceView(Context context, AttributeSet attrs) {
- super(context, attrs);
- getHolder().addCallback(this);
- }
-
- public synchronized void bindToListener(SurfaceHolder.Callback listener, GLEnvironment glEnv) {
- // Make sure we are not bound already
- if (listener == null) {
- throw new NullPointerException("Attempting to bind null filter to SurfaceView!");
- } else if (mListener != null && mListener != listener) {
- throw new RuntimeException(
- "Attempting to bind filter " + listener + " to SurfaceView with another open "
- + "filter " + mListener + " attached already!");
- }
-
- // Set listener
- mListener = listener;
-
- // Set GLEnv
- if (mGLEnv != null && mGLEnv != glEnv) {
- mGLEnv.unregisterSurfaceId(mSurfaceId);
- }
- mGLEnv = glEnv;
-
- // Check if surface has been created already
- if (mState >= STATE_CREATED) {
- // Register with env (double registration will be ignored by GLEnv, so we can simply
- // try to do it here).
- registerSurface();
-
- // Forward surface created to listener
- mListener.surfaceCreated(getHolder());
-
- // Forward surface changed to listener
- if (mState == STATE_INITIALIZED) {
- mListener.surfaceChanged(getHolder(), mFormat, mWidth, mHeight);
- }
- }
- }
-
- public synchronized void unbind() {
- mListener = null;
- }
-
- public synchronized int getSurfaceId() {
- return mSurfaceId;
- }
-
- public synchronized GLEnvironment getGLEnv() {
- return mGLEnv;
- }
-
- @Override
- public synchronized void surfaceCreated(SurfaceHolder holder) {
- mState = STATE_CREATED;
-
- // Register with GLEnvironment if we have it already
- if (mGLEnv != null) {
- registerSurface();
- }
-
- // Forward callback to listener
- if (mListener != null) {
- mListener.surfaceCreated(holder);
- }
- }
-
- @Override
- public synchronized void surfaceChanged(SurfaceHolder holder,
- int format,
- int width,
- int height) {
- // Remember these values
- mFormat = format;
- mWidth = width;
- mHeight = height;
- mState = STATE_INITIALIZED;
-
- // Forward to renderer
- if (mListener != null) {
- mListener.surfaceChanged(holder, format, width, height);
- }
- }
-
- @Override
- public synchronized void surfaceDestroyed(SurfaceHolder holder) {
- mState = STATE_ALLOCATED;
-
- // Forward to renderer
- if (mListener != null) {
- mListener.surfaceDestroyed(holder);
- }
-
- // Get rid of internal objects associated with this surface
- unregisterSurface();
- }
-
- private void registerSurface() {
- mSurfaceId = mGLEnv.registerSurface(getHolder().getSurface());
- if (mSurfaceId < 0) {
- throw new RuntimeException("Could not register Surface: " + getHolder().getSurface() +
- " in FilterSurfaceView!");
- }
- }
- private void unregisterSurface() {
- if (mGLEnv != null && mSurfaceId > 0) {
- mGLEnv.unregisterSurfaceId(mSurfaceId);
- }
- }
-
-}
+++ /dev/null
-/*
- * 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.core;
-
-import java.lang.reflect.Field;
-
-/**
- * @hide
- */
-public class FinalPort extends FieldPort {
-
- public FinalPort(Filter filter, String name, Field field, boolean hasDefault) {
- super(filter, name, field, hasDefault);
- }
-
- @Override
- protected synchronized void setFieldFrame(Frame frame, boolean isAssignment) {
- assertPortIsOpen();
- checkFrameType(frame, isAssignment);
- if (mFilter.getStatus() != Filter.STATUS_PREINIT) {
- throw new RuntimeException("Attempting to modify " + this + "!");
- } else {
- super.setFieldFrame(frame, isAssignment);
- super.transfer(null);
- }
- }
-
- @Override
- public String toString() {
- return "final " + super.toString();
- }
-
-}
+++ /dev/null
-/*
- * 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.core;
-
-import android.filterfw.core.FrameFormat;
-import android.filterfw.core.FrameManager;
-import android.graphics.Bitmap;
-import android.util.Log;
-
-import java.nio.ByteBuffer;
-
-/**
- * @hide
- */
-public abstract class Frame {
-
- public final static int NO_BINDING = 0;
-
- public final static long TIMESTAMP_NOT_SET = -2;
- public final static long TIMESTAMP_UNKNOWN = -1;
-
- private FrameFormat mFormat;
- private FrameManager mFrameManager;
- private boolean mReadOnly = false;
- private boolean mReusable = false;
- private int mRefCount = 1;
- private int mBindingType = NO_BINDING;
- private long mBindingId = 0;
- private long mTimestamp = TIMESTAMP_NOT_SET;
-
- Frame(FrameFormat format, FrameManager frameManager) {
- mFormat = format.mutableCopy();
- mFrameManager = frameManager;
- }
-
- Frame(FrameFormat format, FrameManager frameManager, int bindingType, long bindingId) {
- mFormat = format.mutableCopy();
- mFrameManager = frameManager;
- mBindingType = bindingType;
- mBindingId = bindingId;
- }
-
- public FrameFormat getFormat() {
- return mFormat;
- }
-
- public int getCapacity() {
- return getFormat().getSize();
- }
-
- public boolean isReadOnly() {
- return mReadOnly;
- }
-
- public int getBindingType() {
- return mBindingType;
- }
-
- public long getBindingId() {
- return mBindingId;
- }
-
- public void setObjectValue(Object object) {
- assertFrameMutable();
-
- // Attempt to set the value using a specific setter (which may be more optimized), and
- // fall back to the setGenericObjectValue(...) in case of no match.
- if (object instanceof int[]) {
- setInts((int[])object);
- } else if (object instanceof float[]) {
- setFloats((float[])object);
- } else if (object instanceof ByteBuffer) {
- setData((ByteBuffer)object);
- } else if (object instanceof Bitmap) {
- setBitmap((Bitmap)object);
- } else {
- setGenericObjectValue(object);
- }
- }
-
- public abstract Object getObjectValue();
-
- public abstract void setInts(int[] ints);
-
- public abstract int[] getInts();
-
- public abstract void setFloats(float[] floats);
-
- public abstract float[] getFloats();
-
- public abstract void setData(ByteBuffer buffer, int offset, int length);
-
- public void setData(ByteBuffer buffer) {
- setData(buffer, 0, buffer.limit());
- }
-
- public void setData(byte[] bytes, int offset, int length) {
- setData(ByteBuffer.wrap(bytes, offset, length));
- }
-
- public abstract ByteBuffer getData();
-
- public abstract void setBitmap(Bitmap bitmap);
-
- public abstract Bitmap getBitmap();
-
- public void setTimestamp(long timestamp) {
- mTimestamp = timestamp;
- }
-
- public long getTimestamp() {
- return mTimestamp;
- }
-
- public void setDataFromFrame(Frame frame) {
- setData(frame.getData());
- }
-
- protected boolean requestResize(int[] newDimensions) {
- return false;
- }
-
- public int getRefCount() {
- return mRefCount;
- }
-
- public Frame release() {
- if (mFrameManager != null) {
- return mFrameManager.releaseFrame(this);
- } else {
- return this;
- }
- }
-
- public Frame retain() {
- if (mFrameManager != null) {
- return mFrameManager.retainFrame(this);
- } else {
- return this;
- }
- }
-
- public FrameManager getFrameManager() {
- return mFrameManager;
- }
-
- protected void assertFrameMutable() {
- if (isReadOnly()) {
- throw new RuntimeException("Attempting to modify read-only frame!");
- }
- }
-
- protected void setReusable(boolean reusable) {
- mReusable = reusable;
- }
-
- protected void setFormat(FrameFormat format) {
- mFormat = format.mutableCopy();
- }
-
- protected void setGenericObjectValue(Object value) {
- throw new RuntimeException(
- "Cannot set object value of unsupported type: " + value.getClass());
- }
-
- protected static Bitmap convertBitmapToRGBA(Bitmap bitmap) {
- if (bitmap.getConfig() == Bitmap.Config.ARGB_8888) {
- return bitmap;
- } else {
- Bitmap result = bitmap.copy(Bitmap.Config.ARGB_8888, false);
- if (result == null) {
- throw new RuntimeException("Error converting bitmap to RGBA!");
- } else if (result.getRowBytes() != result.getWidth() * 4) {
- throw new RuntimeException("Unsupported row byte count in bitmap!");
- }
- return result;
- }
- }
-
- protected void reset(FrameFormat newFormat) {
- mFormat = newFormat.mutableCopy();
- mReadOnly = false;
- mRefCount = 1;
- }
-
- /**
- * Called just before a frame is stored, such as when storing to a cache or context.
- */
- protected void onFrameStore() {
- }
-
- /**
- * Called when a frame is fetched from an internal store such as a cache.
- */
- protected void onFrameFetch() {
- }
-
- // Core internal methods ///////////////////////////////////////////////////////////////////////
- protected abstract boolean hasNativeAllocation();
-
- protected abstract void releaseNativeAllocation();
-
- final int incRefCount() {
- ++mRefCount;
- return mRefCount;
- }
-
- final int decRefCount() {
- --mRefCount;
- return mRefCount;
- }
-
- final boolean isReusable() {
- return mReusable;
- }
-
- final void markReadOnly() {
- mReadOnly = true;
- }
-
-}
+++ /dev/null
-/*
- * 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.core;
-
-import android.filterfw.core.KeyValueMap;
-import android.filterfw.core.MutableFrameFormat;
-
-import java.util.Arrays;
-import java.util.Map.Entry;
-
-/**
- * @hide
- */
-public class FrameFormat {
-
- public static final int TYPE_UNSPECIFIED = 0;
- public static final int TYPE_BIT = 1;
- public static final int TYPE_BYTE = 2;
- public static final int TYPE_INT16 = 3;
- public static final int TYPE_INT32 = 4;
- public static final int TYPE_FLOAT = 5;
- public static final int TYPE_DOUBLE = 6;
- public static final int TYPE_POINTER = 7;
- public static final int TYPE_OBJECT = 8;
-
- public static final int TARGET_UNSPECIFIED = 0;
- public static final int TARGET_SIMPLE = 1;
- public static final int TARGET_NATIVE = 2;
- public static final int TARGET_GPU = 3;
- public static final int TARGET_VERTEXBUFFER = 4;
- public static final int TARGET_RS = 5;
-
- public static final int SIZE_UNSPECIFIED = 0;
-
- // TODO: When convenience formats are used, consider changing this to 0 and have the convenience
- // intializers use a proper BPS.
- public static final int BYTES_PER_SAMPLE_UNSPECIFIED = 1;
-
- protected static final int SIZE_UNKNOWN = -1;
-
- protected int mBaseType = TYPE_UNSPECIFIED;
- protected int mBytesPerSample = 1;
- protected int mSize = SIZE_UNKNOWN;
- protected int mTarget = TARGET_UNSPECIFIED;
- protected int[] mDimensions;
- protected KeyValueMap mMetaData;
- protected Class mObjectClass;
-
- protected FrameFormat() {
- }
-
- public FrameFormat(int baseType, int target) {
- mBaseType = baseType;
- mTarget = target;
- initDefaults();
- }
-
- public static FrameFormat unspecified() {
- return new FrameFormat(TYPE_UNSPECIFIED, TARGET_UNSPECIFIED);
- }
-
- public int getBaseType() {
- return mBaseType;
- }
-
- public boolean isBinaryDataType() {
- return mBaseType >= TYPE_BIT && mBaseType <= TYPE_DOUBLE;
- }
-
- public int getBytesPerSample() {
- return mBytesPerSample;
- }
-
- public int getValuesPerSample() {
- return mBytesPerSample / bytesPerSampleOf(mBaseType);
- }
-
- public int getTarget() {
- return mTarget;
- }
-
- public int[] getDimensions() {
- return mDimensions;
- }
-
- public int getDimension(int i) {
- return mDimensions[i];
- }
-
- public int getDimensionCount() {
- return mDimensions == null ? 0 : mDimensions.length;
- }
-
- public boolean hasMetaKey(String key) {
- return mMetaData != null ? mMetaData.containsKey(key) : false;
- }
-
- public boolean hasMetaKey(String key, Class expectedClass) {
- if (mMetaData != null && mMetaData.containsKey(key)) {
- if (!expectedClass.isAssignableFrom(mMetaData.get(key).getClass())) {
- throw new RuntimeException(
- "FrameFormat meta-key '" + key + "' is of type " +
- mMetaData.get(key).getClass() + " but expected to be of type " +
- expectedClass + "!");
- }
- return true;
- }
- return false;
- }
-
- public Object getMetaValue(String key) {
- return mMetaData != null ? mMetaData.get(key) : null;
- }
-
- public int getNumberOfDimensions() {
- return mDimensions != null ? mDimensions.length : 0;
- }
-
- public int getLength() {
- return (mDimensions != null && mDimensions.length >= 1) ? mDimensions[0] : -1;
- }
-
- public int getWidth() {
- return getLength();
- }
-
- public int getHeight() {
- return (mDimensions != null && mDimensions.length >= 2) ? mDimensions[1] : -1;
- }
-
- public int getDepth() {
- return (mDimensions != null && mDimensions.length >= 3) ? mDimensions[2] : -1;
- }
-
- public int getSize() {
- if (mSize == SIZE_UNKNOWN) mSize = calcSize(mDimensions);
- return mSize;
- }
-
- public Class getObjectClass() {
- return mObjectClass;
- }
-
- public MutableFrameFormat mutableCopy() {
- MutableFrameFormat result = new MutableFrameFormat();
- result.setBaseType(getBaseType());
- result.setTarget(getTarget());
- result.setBytesPerSample(getBytesPerSample());
- result.setDimensions(getDimensions());
- result.setObjectClass(getObjectClass());
- result.mMetaData = mMetaData == null ? null : (KeyValueMap)mMetaData.clone();
- return result;
- }
-
- @Override
- public boolean equals(Object object) {
- if (this == object) {
- return true;
- }
-
- if (!(object instanceof FrameFormat)) {
- return false;
- }
-
- FrameFormat format = (FrameFormat)object;
- return format.mBaseType == mBaseType &&
- format.mTarget == mTarget &&
- format.mBytesPerSample == mBytesPerSample &&
- Arrays.equals(format.mDimensions, mDimensions) &&
- format.mMetaData.equals(mMetaData);
- }
-
- @Override
- public int hashCode() {
- return 4211 ^ mBaseType ^ mBytesPerSample ^ getSize();
- }
-
- public boolean isCompatibleWith(FrameFormat specification) {
- // Check base type
- if (specification.getBaseType() != TYPE_UNSPECIFIED
- && getBaseType() != specification.getBaseType()) {
- return false;
- }
-
- // Check target
- if (specification.getTarget() != TARGET_UNSPECIFIED
- && getTarget() != specification.getTarget()) {
- return false;
- }
-
- // Check bytes per sample
- if (specification.getBytesPerSample() != BYTES_PER_SAMPLE_UNSPECIFIED
- && getBytesPerSample() != specification.getBytesPerSample()) {
- return false;
- }
-
- // Check number of dimensions
- if (specification.getDimensionCount() > 0
- && getDimensionCount() != specification.getDimensionCount()) {
- return false;
- }
-
- // Check dimensions
- for (int i = 0; i < specification.getDimensionCount(); ++i) {
- int specDim = specification.getDimension(i);
- if (specDim != SIZE_UNSPECIFIED && getDimension(i) != specDim) {
- return false;
- }
- }
-
- // Check class
- if (specification.getObjectClass() != null) {
- if (getObjectClass() == null
- || !specification.getObjectClass().isAssignableFrom(getObjectClass())) {
- return false;
- }
- }
-
- // Check meta-data
- if (specification.mMetaData != null) {
- for (String specKey : specification.mMetaData.keySet()) {
- if (mMetaData == null
- || !mMetaData.containsKey(specKey)
- || !mMetaData.get(specKey).equals(specification.mMetaData.get(specKey))) {
- return false;
- }
- }
- }
-
- // Passed all the tests
- return true;
- }
-
- public boolean mayBeCompatibleWith(FrameFormat specification) {
- // Check base type
- if (specification.getBaseType() != TYPE_UNSPECIFIED
- && getBaseType() != TYPE_UNSPECIFIED
- && getBaseType() != specification.getBaseType()) {
- return false;
- }
-
- // Check target
- if (specification.getTarget() != TARGET_UNSPECIFIED
- && getTarget() != TARGET_UNSPECIFIED
- && getTarget() != specification.getTarget()) {
- return false;
- }
-
- // Check bytes per sample
- if (specification.getBytesPerSample() != BYTES_PER_SAMPLE_UNSPECIFIED
- && getBytesPerSample() != BYTES_PER_SAMPLE_UNSPECIFIED
- && getBytesPerSample() != specification.getBytesPerSample()) {
- return false;
- }
-
- // Check number of dimensions
- if (specification.getDimensionCount() > 0
- && getDimensionCount() > 0
- && getDimensionCount() != specification.getDimensionCount()) {
- return false;
- }
-
- // Check dimensions
- for (int i = 0; i < specification.getDimensionCount(); ++i) {
- int specDim = specification.getDimension(i);
- if (specDim != SIZE_UNSPECIFIED
- && getDimension(i) != SIZE_UNSPECIFIED
- && getDimension(i) != specDim) {
- return false;
- }
- }
-
- // Check class
- if (specification.getObjectClass() != null && getObjectClass() != null) {
- if (!specification.getObjectClass().isAssignableFrom(getObjectClass())) {
- return false;
- }
- }
-
- // Check meta-data
- if (specification.mMetaData != null && mMetaData != null) {
- for (String specKey : specification.mMetaData.keySet()) {
- if (mMetaData.containsKey(specKey)
- && !mMetaData.get(specKey).equals(specification.mMetaData.get(specKey))) {
- return false;
- }
- }
- }
-
- // Passed all the tests
- return true;
- }
-
- public static int bytesPerSampleOf(int baseType) {
- // Defaults based on base-type
- switch (baseType) {
- case TYPE_BIT:
- case TYPE_BYTE:
- return 1;
- case TYPE_INT16:
- return 2;
- case TYPE_INT32:
- case TYPE_FLOAT:
- case TYPE_POINTER:
- return 4;
- case TYPE_DOUBLE:
- return 8;
- default:
- return 1;
- }
- }
-
- public static String dimensionsToString(int[] dimensions) {
- StringBuffer buffer = new StringBuffer();
- if (dimensions != null) {
- int n = dimensions.length;
- for (int i = 0; i < n; ++i) {
- if (dimensions[i] == SIZE_UNSPECIFIED) {
- buffer.append("[]");
- } else {
- buffer.append("[" + String.valueOf(dimensions[i]) + "]");
- }
- }
- }
- return buffer.toString();
- }
-
- public static String baseTypeToString(int baseType) {
- switch (baseType) {
- case TYPE_UNSPECIFIED: return "unspecified";
- case TYPE_BIT: return "bit";
- case TYPE_BYTE: return "byte";
- case TYPE_INT16: return "int";
- case TYPE_INT32: return "int";
- case TYPE_FLOAT: return "float";
- case TYPE_DOUBLE: return "double";
- case TYPE_POINTER: return "pointer";
- case TYPE_OBJECT: return "object";
- default: return "unknown";
- }
- }
-
- public static String targetToString(int target) {
- switch (target) {
- case TARGET_UNSPECIFIED: return "unspecified";
- case TARGET_SIMPLE: return "simple";
- case TARGET_NATIVE: return "native";
- case TARGET_GPU: return "gpu";
- case TARGET_VERTEXBUFFER: return "vbo";
- case TARGET_RS: return "renderscript";
- default: return "unknown";
- }
- }
-
- public static String metaDataToString(KeyValueMap metaData) {
- if (metaData == null) {
- return "";
- } else {
- StringBuffer buffer = new StringBuffer();
- buffer.append("{ ");
- for (Entry<String, Object> entry : metaData.entrySet()) {
- buffer.append(entry.getKey() + ": " + entry.getValue() + " ");
- }
- buffer.append("}");
- return buffer.toString();
- }
- }
-
- public static int readTargetString(String targetString) {
- if (targetString.equalsIgnoreCase("CPU") || targetString.equalsIgnoreCase("NATIVE")) {
- return FrameFormat.TARGET_NATIVE;
- } else if (targetString.equalsIgnoreCase("GPU")) {
- return FrameFormat.TARGET_GPU;
- } else if (targetString.equalsIgnoreCase("SIMPLE")) {
- return FrameFormat.TARGET_SIMPLE;
- } else if (targetString.equalsIgnoreCase("VERTEXBUFFER")) {
- return FrameFormat.TARGET_VERTEXBUFFER;
- } else if (targetString.equalsIgnoreCase("UNSPECIFIED")) {
- return FrameFormat.TARGET_UNSPECIFIED;
- } else {
- throw new RuntimeException("Unknown target type '" + targetString + "'!");
- }
- }
-
- // TODO: FromString
-
- public String toString() {
- int valuesPerSample = getValuesPerSample();
- String sampleCountString = valuesPerSample == 1 ? "" : String.valueOf(valuesPerSample);
- String targetString = mTarget == TARGET_UNSPECIFIED ? "" : (targetToString(mTarget) + " ");
- String classString = mObjectClass == null
- ? ""
- : (" class(" + mObjectClass.getSimpleName() + ") ");
-
- return targetString
- + baseTypeToString(mBaseType)
- + sampleCountString
- + dimensionsToString(mDimensions)
- + classString
- + metaDataToString(mMetaData);
- }
-
- private void initDefaults() {
- mBytesPerSample = bytesPerSampleOf(mBaseType);
- }
-
- // Core internal methods ///////////////////////////////////////////////////////////////////////
- int calcSize(int[] dimensions) {
- if (dimensions != null && dimensions.length > 0) {
- int size = getBytesPerSample();
- for (int dim : dimensions) {
- size *= dim;
- }
- return size;
- }
- return 0;
- }
-
- boolean isReplaceableBy(FrameFormat format) {
- return mTarget == format.mTarget
- && getSize() == format.getSize()
- && Arrays.equals(format.mDimensions, mDimensions);
- }
-}
+++ /dev/null
-/*
- * 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.core;
-
-import android.filterfw.core.Frame;
-import android.filterfw.core.FrameFormat;
-import android.filterfw.core.MutableFrameFormat;
-
-/**
- * @hide
- */
-public abstract class FrameManager {
-
- private FilterContext mContext;
-
- public abstract Frame newFrame(FrameFormat format);
-
- public abstract Frame newBoundFrame(FrameFormat format, int bindingType, long bindingId);
-
- public Frame duplicateFrame(Frame frame) {
- Frame result = newFrame(frame.getFormat());
- result.setDataFromFrame(frame);
- return result;
- }
-
- public Frame duplicateFrameToTarget(Frame frame, int newTarget) {
- MutableFrameFormat newFormat = frame.getFormat().mutableCopy();
- newFormat.setTarget(newTarget);
- Frame result = newFrame(newFormat);
- result.setDataFromFrame(frame);
- return result;
- }
-
- public abstract Frame retainFrame(Frame frame);
-
- public abstract Frame releaseFrame(Frame frame);
-
- public FilterContext getContext() {
- return mContext;
- }
-
- public GLEnvironment getGLEnvironment() {
- return mContext != null ? mContext.getGLEnvironment() : null;
- }
-
- public void tearDown() {
- }
-
- void setContext(FilterContext context) {
- mContext = context;
- }
-}
+++ /dev/null
-/*
- * 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.core;
-
-import android.filterfw.core.NativeAllocatorTag;
-import android.graphics.SurfaceTexture;
-import android.os.Looper;
-import android.util.Log;
-import android.view.Surface;
-import android.media.MediaRecorder;
-
-/**
- * @hide
- */
-public class GLEnvironment {
-
- private int glEnvId;
-
- public GLEnvironment() {
- nativeAllocate();
- }
-
- private GLEnvironment(NativeAllocatorTag tag) {
- }
-
- public synchronized void tearDown() {
- if (glEnvId != -1) {
- nativeDeallocate();
- glEnvId = -1;
- }
- }
-
- @Override
- protected void finalize() throws Throwable {
- tearDown();
- }
-
- public void initWithNewContext() {
- if (!nativeInitWithNewContext()) {
- throw new RuntimeException("Could not initialize GLEnvironment with new context!");
- }
- }
-
- public void initWithCurrentContext() {
- if (!nativeInitWithCurrentContext()) {
- throw new RuntimeException("Could not initialize GLEnvironment with current context!");
- }
- }
-
- public boolean isActive() {
- return nativeIsActive();
- }
-
- public boolean isContextActive() {
- return nativeIsContextActive();
- }
-
- public static boolean isAnyContextActive() {
- return nativeIsAnyContextActive();
- }
-
- public void activate() {
- if (Looper.myLooper() != null && Looper.myLooper().equals(Looper.getMainLooper())) {
- Log.e("FilterFramework", "Activating GL context in UI thread!");
- }
- if (!nativeActivate()) {
- throw new RuntimeException("Could not activate GLEnvironment!");
- }
- }
-
- public void deactivate() {
- if (!nativeDeactivate()) {
- throw new RuntimeException("Could not deactivate GLEnvironment!");
- }
- }
-
- public void swapBuffers() {
- if (!nativeSwapBuffers()) {
- throw new RuntimeException("Error swapping EGL buffers!");
- }
- }
-
- public int registerSurface(Surface surface) {
- int result = nativeAddSurface(surface);
- if (result < 0) {
- throw new RuntimeException("Error registering surface " + surface + "!");
- }
- return result;
- }
-
- public int registerSurfaceTexture(SurfaceTexture surfaceTexture, int width, int height) {
- Surface surface = new Surface(surfaceTexture);
- int result = nativeAddSurfaceWidthHeight(surface, width, height);
- surface.release();
- if (result < 0) {
- throw new RuntimeException("Error registering surfaceTexture " + surfaceTexture + "!");
- }
- return result;
- }
-
- public int registerSurfaceFromMediaRecorder(MediaRecorder mediaRecorder) {
- int result = nativeAddSurfaceFromMediaRecorder(mediaRecorder);
- if (result < 0) {
- throw new RuntimeException("Error registering surface from "
- + "MediaRecorder" + mediaRecorder + "!");
- }
- return result;
- }
-
- public void activateSurfaceWithId(int surfaceId) {
- if (!nativeActivateSurfaceId(surfaceId)) {
- throw new RuntimeException("Could not activate surface " + surfaceId + "!");
- }
- }
-
- public void unregisterSurfaceId(int surfaceId) {
- if (!nativeRemoveSurfaceId(surfaceId)) {
- throw new RuntimeException("Could not unregister surface " + surfaceId + "!");
- }
- }
-
- public void setSurfaceTimestamp(long timestamp) {
- if (!nativeSetSurfaceTimestamp(timestamp)) {
- throw new RuntimeException("Could not set timestamp for current surface!");
- }
- }
-
- static {
- System.loadLibrary("filterfw");
- }
-
- private native boolean nativeInitWithNewContext();
-
- private native boolean nativeInitWithCurrentContext();
-
- private native boolean nativeIsActive();
-
- private native boolean nativeIsContextActive();
-
- private static native boolean nativeIsAnyContextActive();
-
- private native boolean nativeActivate();
-
- private native boolean nativeDeactivate();
-
- private native boolean nativeSwapBuffers();
-
- private native boolean nativeAllocate();
-
- private native boolean nativeDeallocate();
-
- private native int nativeAddSurface(Surface surface);
-
- private native int nativeAddSurfaceWidthHeight(Surface surface, int width, int height);
-
- private native int nativeAddSurfaceFromMediaRecorder(MediaRecorder mediaRecorder);
-
- private native boolean nativeDisconnectSurfaceMediaSource(MediaRecorder mediaRecorder);
-
- private native boolean nativeActivateSurfaceId(int surfaceId);
-
- private native boolean nativeRemoveSurfaceId(int surfaceId);
-
- private native boolean nativeSetSurfaceTimestamp(long timestamp);
-}
+++ /dev/null
-/*
- * 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.core;
-
-import android.filterfw.core.Frame;
-import android.filterfw.core.FrameFormat;
-import android.filterfw.core.FrameManager;
-import android.filterfw.core.NativeFrame;
-import android.filterfw.core.StopWatchMap;
-import android.graphics.Bitmap;
-import android.opengl.GLES20;
-import android.graphics.Rect;
-
-import java.nio.ByteBuffer;
-
-class GLFrameTimer {
-
- private static StopWatchMap mTimer = null;
-
- public static StopWatchMap get() {
- if (mTimer == null) {
- mTimer = new StopWatchMap();
- }
- return mTimer;
- }
-
-}
-
-/**
- * @hide
- */
-public class GLFrame extends Frame {
-
- // GL-related binding types
- public final static int EXISTING_TEXTURE_BINDING = 100;
- public final static int EXISTING_FBO_BINDING = 101;
- public final static int NEW_TEXTURE_BINDING = 102; // TODO: REMOVE THIS
- public final static int NEW_FBO_BINDING = 103; // TODO: REMOVE THIS
- public final static int EXTERNAL_TEXTURE = 104;
-
- private int glFrameId = -1;
-
- /**
- * Flag whether we own the texture or not. If we do not, we must be careful when caching or
- * storing the frame, as the user may delete, and regenerate it.
- */
- private boolean mOwnsTexture = true;
-
- /**
- * Keep a reference to the GL environment, so that it does not get deallocated while there
- * are still frames living in it.
- */
- private GLEnvironment mGLEnvironment;
-
- GLFrame(FrameFormat format, FrameManager frameManager) {
- super(format, frameManager);
- }
-
- GLFrame(FrameFormat format, FrameManager frameManager, int bindingType, long bindingId) {
- super(format, frameManager, bindingType, bindingId);
- }
-
- void init(GLEnvironment glEnv) {
- FrameFormat format = getFormat();
- mGLEnvironment = glEnv;
-
- // Check that we have a valid format
- if (format.getBytesPerSample() != 4) {
- throw new IllegalArgumentException("GL frames must have 4 bytes per sample!");
- } else if (format.getDimensionCount() != 2) {
- throw new IllegalArgumentException("GL frames must be 2-dimensional!");
- } else if (getFormat().getSize() < 0) {
- throw new IllegalArgumentException("Initializing GL frame with zero size!");
- }
-
- // Create correct frame
- int bindingType = getBindingType();
- boolean reusable = true;
- if (bindingType == Frame.NO_BINDING) {
- initNew(false);
- } else if (bindingType == EXTERNAL_TEXTURE) {
- initNew(true);
- reusable = false;
- } else if (bindingType == EXISTING_TEXTURE_BINDING) {
- initWithTexture((int)getBindingId());
- } else if (bindingType == EXISTING_FBO_BINDING) {
- initWithFbo((int)getBindingId());
- } else if (bindingType == NEW_TEXTURE_BINDING) {
- initWithTexture((int)getBindingId());
- } else if (bindingType == NEW_FBO_BINDING) {
- initWithFbo((int)getBindingId());
- } else {
- throw new RuntimeException("Attempting to create GL frame with unknown binding type "
- + bindingType + "!");
- }
- setReusable(reusable);
- }
-
- private void initNew(boolean isExternal) {
- if (isExternal) {
- if (!nativeAllocateExternal(mGLEnvironment)) {
- throw new RuntimeException("Could not allocate external GL frame!");
- }
- } else {
- if (!nativeAllocate(mGLEnvironment, getFormat().getWidth(), getFormat().getHeight())) {
- throw new RuntimeException("Could not allocate GL frame!");
- }
- }
- }
-
- private void initWithTexture(int texId) {
- int width = getFormat().getWidth();
- int height = getFormat().getHeight();
- if (!nativeAllocateWithTexture(mGLEnvironment, texId, width, height)) {
- throw new RuntimeException("Could not allocate texture backed GL frame!");
- }
- mOwnsTexture = false;
- markReadOnly();
- }
-
- private void initWithFbo(int fboId) {
- int width = getFormat().getWidth();
- int height = getFormat().getHeight();
- if (!nativeAllocateWithFbo(mGLEnvironment, fboId, width, height)) {
- throw new RuntimeException("Could not allocate FBO backed GL frame!");
- }
- }
-
- void flushGPU(String message) {
- StopWatchMap timer = GLFrameTimer.get();
- if (timer.LOG_MFF_RUNNING_TIMES) {
- timer.start("glFinish " + message);
- GLES20.glFinish();
- timer.stop("glFinish " + message);
- }
- }
-
- @Override
- protected synchronized boolean hasNativeAllocation() {
- return glFrameId != -1;
- }
-
- @Override
- protected synchronized void releaseNativeAllocation() {
- nativeDeallocate();
- glFrameId = -1;
- }
-
- public GLEnvironment getGLEnvironment() {
- return mGLEnvironment;
- }
-
- @Override
- public Object getObjectValue() {
- assertGLEnvValid();
- return ByteBuffer.wrap(getNativeData());
- }
-
- @Override
- public void setInts(int[] ints) {
- assertFrameMutable();
- assertGLEnvValid();
- if (!setNativeInts(ints)) {
- throw new RuntimeException("Could not set int values for GL frame!");
- }
- }
-
- @Override
- public int[] getInts() {
- assertGLEnvValid();
- flushGPU("getInts");
- return getNativeInts();
- }
-
- @Override
- public void setFloats(float[] floats) {
- assertFrameMutable();
- assertGLEnvValid();
- if (!setNativeFloats(floats)) {
- throw new RuntimeException("Could not set int values for GL frame!");
- }
- }
-
- @Override
- public float[] getFloats() {
- assertGLEnvValid();
- flushGPU("getFloats");
- return getNativeFloats();
- }
-
- @Override
- public void setData(ByteBuffer buffer, int offset, int length) {
- assertFrameMutable();
- assertGLEnvValid();
- byte[] bytes = buffer.array();
- if (getFormat().getSize() != bytes.length) {
- throw new RuntimeException("Data size in setData does not match GL frame size!");
- } else if (!setNativeData(bytes, offset, length)) {
- throw new RuntimeException("Could not set GL frame data!");
- }
- }
-
- @Override
- public ByteBuffer getData() {
- assertGLEnvValid();
- flushGPU("getData");
- return ByteBuffer.wrap(getNativeData());
- }
-
- @Override
- public void setBitmap(Bitmap bitmap) {
- assertFrameMutable();
- assertGLEnvValid();
- if (getFormat().getWidth() != bitmap.getWidth() ||
- getFormat().getHeight() != bitmap.getHeight()) {
- throw new RuntimeException("Bitmap dimensions do not match GL frame dimensions!");
- } else {
- Bitmap rgbaBitmap = convertBitmapToRGBA(bitmap);
- if (!setNativeBitmap(rgbaBitmap, rgbaBitmap.getByteCount())) {
- throw new RuntimeException("Could not set GL frame bitmap data!");
- }
- }
- }
-
- @Override
- public Bitmap getBitmap() {
- assertGLEnvValid();
- flushGPU("getBitmap");
- Bitmap result = Bitmap.createBitmap(getFormat().getWidth(),
- getFormat().getHeight(),
- Bitmap.Config.ARGB_8888);
- if (!getNativeBitmap(result)) {
- throw new RuntimeException("Could not get bitmap data from GL frame!");
- }
- return result;
- }
-
- @Override
- public void setDataFromFrame(Frame frame) {
- assertGLEnvValid();
-
- // Make sure frame fits
- if (getFormat().getSize() < frame.getFormat().getSize()) {
- throw new RuntimeException(
- "Attempting to assign frame of size " + frame.getFormat().getSize() + " to " +
- "smaller GL frame of size " + getFormat().getSize() + "!");
- }
-
- // Invoke optimized implementations if possible
- if (frame instanceof NativeFrame) {
- nativeCopyFromNative((NativeFrame)frame);
- } else if (frame instanceof GLFrame) {
- nativeCopyFromGL((GLFrame)frame);
- } else if (frame instanceof SimpleFrame) {
- setObjectValue(frame.getObjectValue());
- } else {
- super.setDataFromFrame(frame);
- }
- }
-
- public void setViewport(int x, int y, int width, int height) {
- assertFrameMutable();
- setNativeViewport(x, y, width, height);
- }
-
- public void setViewport(Rect rect) {
- assertFrameMutable();
- setNativeViewport(rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top);
- }
-
- public void generateMipMap() {
- assertFrameMutable();
- assertGLEnvValid();
- if (!generateNativeMipMap()) {
- throw new RuntimeException("Could not generate mip-map for GL frame!");
- }
- }
-
- public void setTextureParameter(int param, int value) {
- assertFrameMutable();
- assertGLEnvValid();
- if (!setNativeTextureParam(param, value)) {
- throw new RuntimeException("Could not set texture value " + param + " = " + value + " " +
- "for GLFrame!");
- }
- }
-
- public int getTextureId() {
- return getNativeTextureId();
- }
-
- public int getFboId() {
- return getNativeFboId();
- }
-
- public void focus() {
- if (!nativeFocus()) {
- throw new RuntimeException("Could not focus on GLFrame for drawing!");
- }
- }
-
- @Override
- public String toString() {
- return "GLFrame id: " + glFrameId + " (" + getFormat() + ") with texture ID "
- + getTextureId() + ", FBO ID " + getFboId();
- }
-
- @Override
- protected void reset(FrameFormat newFormat) {
- if (!nativeResetParams()) {
- throw new RuntimeException("Could not reset GLFrame texture parameters!");
- }
- super.reset(newFormat);
- }
-
- @Override
- protected void onFrameStore() {
- if (!mOwnsTexture) {
- // Detach texture from FBO in case user manipulates it.
- nativeDetachTexFromFbo();
- }
- }
-
- @Override
- protected void onFrameFetch() {
- if (!mOwnsTexture) {
- // Reattach texture to FBO when using frame again. This may reallocate the texture
- // in case it has become invalid.
- nativeReattachTexToFbo();
- }
- }
-
- private void assertGLEnvValid() {
- if (!mGLEnvironment.isContextActive()) {
- if (GLEnvironment.isAnyContextActive()) {
- throw new RuntimeException("Attempting to access " + this + " with foreign GL " +
- "context active!");
- } else {
- throw new RuntimeException("Attempting to access " + this + " with no GL context " +
- " active!");
- }
- }
- }
-
- static {
- System.loadLibrary("filterfw");
- }
-
- private native boolean nativeAllocate(GLEnvironment env, int width, int height);
-
- private native boolean nativeAllocateWithTexture(GLEnvironment env,
- int textureId,
- int width,
- int height);
-
- private native boolean nativeAllocateWithFbo(GLEnvironment env,
- int fboId,
- int width,
- int height);
-
- private native boolean nativeAllocateExternal(GLEnvironment env);
-
- private native boolean nativeDeallocate();
-
- private native boolean setNativeData(byte[] data, int offset, int length);
-
- private native byte[] getNativeData();
-
- private native boolean setNativeInts(int[] ints);
-
- private native boolean setNativeFloats(float[] floats);
-
- private native int[] getNativeInts();
-
- private native float[] getNativeFloats();
-
- private native boolean setNativeBitmap(Bitmap bitmap, int size);
-
- private native boolean getNativeBitmap(Bitmap bitmap);
-
- private native boolean setNativeViewport(int x, int y, int width, int height);
-
- private native int getNativeTextureId();
-
- private native int getNativeFboId();
-
- private native boolean generateNativeMipMap();
-
- private native boolean setNativeTextureParam(int param, int value);
-
- private native boolean nativeResetParams();
-
- private native boolean nativeCopyFromNative(NativeFrame frame);
-
- private native boolean nativeCopyFromGL(GLFrame frame);
-
- private native boolean nativeFocus();
-
- private native boolean nativeReattachTexToFbo();
-
- private native boolean nativeDetachTexFromFbo();
-}
+++ /dev/null
-/*
- * 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.core;
-
-import java.lang.annotation.*;
-
-/**
- * @hide
- */
-@Retention(RetentionPolicy.RUNTIME)
-@Target(ElementType.FIELD)
-public @interface GenerateFieldPort {
- String name() default "";
- boolean hasDefault() default false;
-}
+++ /dev/null
-/*
- * 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.core;
-
-import java.lang.annotation.*;
-
-/**
- * @hide
- */
-@Retention(RetentionPolicy.RUNTIME)
-@Target(ElementType.FIELD)
-public @interface GenerateFinalPort {
- String name() default "";
- boolean hasDefault() default false;
-}
+++ /dev/null
-/*
- * 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.core;
-
-import java.lang.annotation.*;
-
-/**
- * @hide
- */
-@Retention(RetentionPolicy.RUNTIME)
-@Target(ElementType.FIELD)
-public @interface GenerateProgramPort {
- String name();
- Class type();
- String variableName() default "";
- boolean hasDefault() default false;
-}
+++ /dev/null
-/*
- * 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.core;
-
-import java.lang.annotation.*;
-
-/**
- * @hide
- */
-@Retention(RetentionPolicy.RUNTIME)
-@Target(ElementType.FIELD)
-public @interface GenerateProgramPorts {
- GenerateProgramPort[] value();
-}
+++ /dev/null
-/*
- * 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.core;
-
-/**
- * @hide
- */
-public abstract class GraphRunner {
-
- protected FilterContext mFilterContext = null;
-
- /** Interface for listeners waiting for the runner to complete. */
- public interface OnRunnerDoneListener {
- /** Callback method to be called when the runner completes a
- * {@link #run()} call.
- *
- * @param result will be RESULT_FINISHED if the graph finished running
- * on its own, RESULT_STOPPED if the runner was stopped by a call
- * to stop(), RESULT_BLOCKED if no filters could run due to lack
- * of inputs or outputs or due to scheduling policies, and
- * RESULT_SLEEPING if a filter node requested sleep.
- */
- public void onRunnerDone(int result);
- }
-
- public static final int RESULT_UNKNOWN = 0;
- public static final int RESULT_RUNNING = 1;
- public static final int RESULT_FINISHED = 2;
- public static final int RESULT_SLEEPING = 3;
- public static final int RESULT_BLOCKED = 4;
- public static final int RESULT_STOPPED = 5;
- public static final int RESULT_ERROR = 6;
-
- public GraphRunner(FilterContext context) {
- mFilterContext = context;
- }
-
- public abstract FilterGraph getGraph();
-
- public FilterContext getContext() {
- return mFilterContext;
- }
-
- /**
- * Helper function for subclasses to activate the GL environment before running.
- * @return true, if the GL environment was activated. Returns false, if the GL environment
- * was already active.
- */
- protected boolean activateGlContext() {
- GLEnvironment glEnv = mFilterContext.getGLEnvironment();
- if (glEnv != null && !glEnv.isActive()) {
- glEnv.activate();
- return true;
- }
- return false;
- }
-
- /**
- * Helper function for subclasses to deactivate the GL environment after running.
- */
- protected void deactivateGlContext() {
- GLEnvironment glEnv = mFilterContext.getGLEnvironment();
- if (glEnv != null) {
- glEnv.deactivate();
- }
- }
-
- /** Starts running the graph. Will open the filters in the graph if they are not already open. */
- public abstract void run();
-
- public abstract void setDoneCallback(OnRunnerDoneListener listener);
- public abstract boolean isRunning();
-
- /** Stops graph execution. As part of stopping, also closes the graph nodes. */
- public abstract void stop();
-
- /** Closes the filters in a graph. Can only be called if the graph is not running. */
- public abstract void close();
-
- /**
- * Returns the last exception that happened during an asynchronous run. Returns null if
- * there is nothing to report.
- */
- public abstract Exception getError();
-}
+++ /dev/null
-/*
- * 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.core;
-
-/**
- * @hide
- */
-public abstract class InputPort extends FilterPort {
-
- protected OutputPort mSourcePort;
-
- public InputPort(Filter filter, String name) {
- super(filter, name);
- }
-
- public void setSourcePort(OutputPort source) {
- if (mSourcePort != null) {
- throw new RuntimeException(this + " already connected to " + mSourcePort + "!");
- }
- mSourcePort = source;
- }
-
- public boolean isConnected() {
- return mSourcePort != null;
- }
-
- public void open() {
- super.open();
- if (mSourcePort != null && !mSourcePort.isOpen()) {
- mSourcePort.open();
- }
- }
-
- public void close() {
- if (mSourcePort != null && mSourcePort.isOpen()) {
- mSourcePort.close();
- }
- super.close();
- }
-
- public OutputPort getSourcePort() {
- return mSourcePort;
- }
-
- public Filter getSourceFilter() {
- return mSourcePort == null ? null : mSourcePort.getFilter();
- }
-
- public FrameFormat getSourceFormat() {
- return mSourcePort != null ? mSourcePort.getPortFormat() : getPortFormat();
- }
-
- public Object getTarget() {
- return null;
- }
-
- public boolean filterMustClose() {
- return !isOpen() && isBlocking() && !hasFrame();
- }
-
- public boolean isReady() {
- return hasFrame() || !isBlocking();
- }
-
- public boolean acceptsFrame() {
- return !hasFrame();
- }
-
- public abstract void transfer(FilterContext context);
-}
+++ /dev/null
-/*
- * 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.core;
-
-import java.io.StringWriter;
-import java.util.HashMap;
-import java.util.Map;
-
-/**
- * @hide
- */
-public class KeyValueMap extends HashMap<String, Object> {
-
- public void setKeyValues(Object... keyValues) {
- if (keyValues.length % 2 != 0) {
- throw new RuntimeException("Key-Value arguments passed into setKeyValues must be "
- + "an alternating list of keys and values!");
- }
- for (int i = 0; i < keyValues.length; i += 2) {
- if (!(keyValues[i] instanceof String)) {
- throw new RuntimeException("Key-value argument " + i + " must be a key of type "
- + "String, but found an object of type " + keyValues[i].getClass() + "!");
- }
- String key = (String)keyValues[i];
- Object value = keyValues[i+1];
- put(key, value);
- }
- }
-
- public static KeyValueMap fromKeyValues(Object... keyValues) {
- KeyValueMap result = new KeyValueMap();
- result.setKeyValues(keyValues);
- return result;
- }
-
- public String getString(String key) {
- Object result = get(key);
- return result != null ? (String)result : null;
- }
-
- public int getInt(String key) {
- Object result = get(key);
- return result != null ? (Integer)result : null;
- }
-
- public float getFloat(String key) {
- Object result = get(key);
- return result != null ? (Float)result : null;
- }
-
- @Override
- public String toString() {
- StringWriter writer = new StringWriter();
- for (Map.Entry<String, Object> entry : entrySet()) {
- String valueString;
- Object value = entry.getValue();
- if (value instanceof String) {
- valueString = "\"" + value + "\"";
- } else {
- valueString = value.toString();
- }
- writer.write(entry.getKey() + " = " + valueString + ";\n");
- }
- return writer.toString();
- }
-
-}
+++ /dev/null
-/*
- * 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.core;
-
-import android.filterfw.core.FrameFormat;
-import android.filterfw.core.KeyValueMap;
-
-import java.util.Arrays;
-
-/**
- * @hide
- */
-public class MutableFrameFormat extends FrameFormat {
-
- public MutableFrameFormat() {
- super();
- }
-
- public MutableFrameFormat(int baseType, int target) {
- super(baseType, target);
- }
-
- public void setBaseType(int baseType) {
- mBaseType = baseType;
- mBytesPerSample = bytesPerSampleOf(baseType);
- }
-
- public void setTarget(int target) {
- mTarget = target;
- }
-
- public void setBytesPerSample(int bytesPerSample) {
- mBytesPerSample = bytesPerSample;
- mSize = SIZE_UNKNOWN;
- }
-
- public void setDimensions(int[] dimensions) {
- mDimensions = (dimensions == null) ? null : Arrays.copyOf(dimensions, dimensions.length);
- mSize = SIZE_UNKNOWN;
- }
-
- public void setDimensions(int size) {
- int[] dimensions = new int[1];
- dimensions[0] = size;
- mDimensions = dimensions;
- mSize = SIZE_UNKNOWN;
- }
-
- public void setDimensions(int width, int height) {
- int[] dimensions = new int[2];
- dimensions[0] = width;
- dimensions[1] = height;
- mDimensions = dimensions;
- mSize = SIZE_UNKNOWN;
- }
-
- public void setDimensions(int width, int height, int depth) {
- int[] dimensions = new int[3];
- dimensions[0] = width;
- dimensions[1] = height;
- dimensions[2] = depth;
- mDimensions = dimensions;
- mSize = SIZE_UNKNOWN;
- }
-
- public void setDimensionCount(int count) {
- mDimensions = new int[count];
- }
-
- public void setObjectClass(Class objectClass) {
- mObjectClass = objectClass;
- }
-
- public void setMetaValue(String key, Object value) {
- if (mMetaData == null) {
- mMetaData = new KeyValueMap();
- }
- mMetaData.put(key, value);
- }
-
-}
+++ /dev/null
-/*
- * 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.core;
-
-/**
- * This class is simply a place-holder type used to identify calls coming
- * from the native layer. This way method signatures can be selected
- * that are to be accessed from the native layer only.
- *
- * @hide
- **/
-public class NativeAllocatorTag {
-}
+++ /dev/null
-/*
- * 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.core;
-
-import android.filterfw.core.Frame;
-
-/**
- * @hide
- */
-public class NativeBuffer {
-
- // These are set by the native layer
- private long mDataPointer = 0;
- private int mSize = 0;
-
- private Frame mAttachedFrame;
-
- private boolean mOwnsData = false;
- private int mRefCount = 1;
-
- public NativeBuffer() {
- }
-
- public NativeBuffer(int count) {
- allocate(count * getElementSize());
- mOwnsData = true;
- }
-
- public NativeBuffer mutableCopy() {
- NativeBuffer result = null;
- try {
- Class myClass = getClass();
- result = (NativeBuffer)myClass.newInstance();
- } catch (Exception e) {
- throw new RuntimeException("Unable to allocate a copy of " + getClass() + "! Make " +
- "sure the class has a default constructor!");
- }
- if (mSize > 0 && !nativeCopyTo(result)) {
- throw new RuntimeException("Failed to copy NativeBuffer to mutable instance!");
- }
- return result;
- }
-
- public int size() {
- return mSize;
- }
-
- public int count() {
- return (mDataPointer != 0) ? mSize / getElementSize() : 0;
- }
-
- public int getElementSize() {
- return 1;
- }
-
- public NativeBuffer retain() {
- if (mAttachedFrame != null) {
- mAttachedFrame.retain();
- } else if (mOwnsData) {
- ++mRefCount;
- }
- return this;
- }
-
- public NativeBuffer release() {
- // Decrement refcount
- boolean doDealloc = false;
- if (mAttachedFrame != null) {
- doDealloc = (mAttachedFrame.release() == null);
- } else if (mOwnsData) {
- --mRefCount;
- doDealloc = (mRefCount == 0);
- }
-
- // Deallocate if necessary
- if (doDealloc) {
- deallocate(mOwnsData);
- return null;
- } else {
- return this;
- }
- }
-
- public boolean isReadOnly() {
- return (mAttachedFrame != null) ? mAttachedFrame.isReadOnly() : false;
- }
-
- static {
- System.loadLibrary("filterfw");
- }
-
- void attachToFrame(Frame frame) {
- // We do not auto-retain. We expect the user to call retain() if they want to hold on to
- // the frame.
- mAttachedFrame = frame;
- }
-
- protected void assertReadable() {
- if (mDataPointer == 0 || mSize == 0
- || (mAttachedFrame != null && !mAttachedFrame.hasNativeAllocation())) {
- throw new NullPointerException("Attempting to read from null data frame!");
- }
- }
-
- protected void assertWritable() {
- if (isReadOnly()) {
- throw new RuntimeException("Attempting to modify read-only native (structured) data!");
- }
- }
-
- private native boolean allocate(int size);
- private native boolean deallocate(boolean ownsData);
- private native boolean nativeCopyTo(NativeBuffer buffer);
-}
+++ /dev/null
-/*
- * 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.core;
-
-import android.filterfw.core.Frame;
-import android.filterfw.core.FrameFormat;
-import android.filterfw.core.FrameManager;
-import android.filterfw.core.GLFrame;
-import android.filterfw.core.NativeBuffer;
-import android.graphics.Bitmap;
-
-import android.util.Log;
-
-import java.nio.ByteBuffer;
-
-/**
- * @hide
- */
-public class NativeFrame extends Frame {
-
- private int nativeFrameId = -1;
-
- NativeFrame(FrameFormat format, FrameManager frameManager) {
- super(format, frameManager);
- int capacity = format.getSize();
- nativeAllocate(capacity);
- setReusable(capacity != 0);
- }
-
- @Override
- protected synchronized void releaseNativeAllocation() {
- nativeDeallocate();
- nativeFrameId = -1;
- }
-
- @Override
- protected synchronized boolean hasNativeAllocation() {
- return nativeFrameId != -1;
- }
-
- @Override
- public int getCapacity() {
- return getNativeCapacity();
- }
-
- /**
- * Returns the native frame's Object value.
- *
- * If the frame's base-type is not TYPE_OBJECT, this returns a data buffer containing the native
- * data (this is equivalent to calling getData().
- * If the frame is based on an object type, this type is expected to be a subclass of
- * NativeBuffer. The NativeBuffer returned is only valid for as long as the frame is alive. If
- * you need to hold on to the returned value, you must retain it.
- */
- @Override
- public Object getObjectValue() {
- // If this is not a structured frame, return our data
- if (getFormat().getBaseType() != FrameFormat.TYPE_OBJECT) {
- return getData();
- }
-
- // Get the structure class
- Class structClass = getFormat().getObjectClass();
- if (structClass == null) {
- throw new RuntimeException("Attempting to get object data from frame that does " +
- "not specify a structure object class!");
- }
-
- // Make sure it is a NativeBuffer subclass
- if (!NativeBuffer.class.isAssignableFrom(structClass)) {
- throw new RuntimeException("NativeFrame object class must be a subclass of " +
- "NativeBuffer!");
- }
-
- // Instantiate a new empty instance of this class
- NativeBuffer structData = null;
- try {
- structData = (NativeBuffer)structClass.newInstance();
- } catch (Exception e) {
- throw new RuntimeException("Could not instantiate new structure instance of type '" +
- structClass + "'!");
- }
-
- // Wrap it around our data
- if (!getNativeBuffer(structData)) {
- throw new RuntimeException("Could not get the native structured data for frame!");
- }
-
- // Attach this frame to it
- structData.attachToFrame(this);
-
- return structData;
- }
-
- @Override
- public void setInts(int[] ints) {
- assertFrameMutable();
- if (ints.length * nativeIntSize() > getFormat().getSize()) {
- throw new RuntimeException(
- "NativeFrame cannot hold " + ints.length + " integers. (Can only hold " +
- (getFormat().getSize() / nativeIntSize()) + " integers).");
- } else if (!setNativeInts(ints)) {
- throw new RuntimeException("Could not set int values for native frame!");
- }
- }
-
- @Override
- public int[] getInts() {
- return getNativeInts(getFormat().getSize());
- }
-
- @Override
- public void setFloats(float[] floats) {
- assertFrameMutable();
- if (floats.length * nativeFloatSize() > getFormat().getSize()) {
- throw new RuntimeException(
- "NativeFrame cannot hold " + floats.length + " floats. (Can only hold " +
- (getFormat().getSize() / nativeFloatSize()) + " floats).");
- } else if (!setNativeFloats(floats)) {
- throw new RuntimeException("Could not set int values for native frame!");
- }
- }
-
- @Override
- public float[] getFloats() {
- return getNativeFloats(getFormat().getSize());
- }
-
- // TODO: This function may be a bit confusing: Is the offset the target or source offset? Maybe
- // we should allow specifying both? (May be difficult for other frame types).
- @Override
- public void setData(ByteBuffer buffer, int offset, int length) {
- assertFrameMutable();
- byte[] bytes = buffer.array();
- if ((length + offset) > buffer.limit()) {
- throw new RuntimeException("Offset and length exceed buffer size in native setData: " +
- (length + offset) + " bytes given, but only " + buffer.limit() +
- " bytes available!");
- } else if (getFormat().getSize() != length) {
- throw new RuntimeException("Data size in setData does not match native frame size: " +
- "Frame size is " + getFormat().getSize() + " bytes, but " +
- length + " bytes given!");
- } else if (!setNativeData(bytes, offset, length)) {
- throw new RuntimeException("Could not set native frame data!");
- }
- }
-
- @Override
- public ByteBuffer getData() {
- byte[] data = getNativeData(getFormat().getSize());
- return data == null ? null : ByteBuffer.wrap(data);
- }
-
- @Override
- public void setBitmap(Bitmap bitmap) {
- assertFrameMutable();
- if (getFormat().getNumberOfDimensions() != 2) {
- throw new RuntimeException("Attempting to set Bitmap for non 2-dimensional native frame!");
- } else if (getFormat().getWidth() != bitmap.getWidth() ||
- getFormat().getHeight() != bitmap.getHeight()) {
- throw new RuntimeException("Bitmap dimensions do not match native frame dimensions!");
- } else {
- Bitmap rgbaBitmap = convertBitmapToRGBA(bitmap);
- int byteCount = rgbaBitmap.getByteCount();
- int bps = getFormat().getBytesPerSample();
- if (!setNativeBitmap(rgbaBitmap, byteCount, bps)) {
- throw new RuntimeException("Could not set native frame bitmap data!");
- }
- }
- }
-
- @Override
- public Bitmap getBitmap() {
- if (getFormat().getNumberOfDimensions() != 2) {
- throw new RuntimeException("Attempting to get Bitmap for non 2-dimensional native frame!");
- }
- Bitmap result = Bitmap.createBitmap(getFormat().getWidth(),
- getFormat().getHeight(),
- Bitmap.Config.ARGB_8888);
- int byteCount = result.getByteCount();
- int bps = getFormat().getBytesPerSample();
- if (!getNativeBitmap(result, byteCount, bps)) {
- throw new RuntimeException("Could not get bitmap data from native frame!");
- }
- return result;
- }
-
- @Override
- public void setDataFromFrame(Frame frame) {
- // Make sure frame fits
- if (getFormat().getSize() < frame.getFormat().getSize()) {
- throw new RuntimeException(
- "Attempting to assign frame of size " + frame.getFormat().getSize() + " to " +
- "smaller native frame of size " + getFormat().getSize() + "!");
- }
-
- // Invoke optimized implementations if possible
- if (frame instanceof NativeFrame) {
- nativeCopyFromNative((NativeFrame)frame);
- } else if (frame instanceof GLFrame) {
- nativeCopyFromGL((GLFrame)frame);
- } else if (frame instanceof SimpleFrame) {
- setObjectValue(frame.getObjectValue());
- } else {
- super.setDataFromFrame(frame);
- }
- }
-
- @Override
- public String toString() {
- return "NativeFrame id: " + nativeFrameId + " (" + getFormat() + ") of size "
- + getCapacity();
- }
-
- static {
- System.loadLibrary("filterfw");
- }
-
- private native boolean nativeAllocate(int capacity);
-
- private native boolean nativeDeallocate();
-
- private native int getNativeCapacity();
-
- private static native int nativeIntSize();
-
- private static native int nativeFloatSize();
-
- private native boolean setNativeData(byte[] data, int offset, int length);
-
- private native byte[] getNativeData(int byteCount);
-
- private native boolean getNativeBuffer(NativeBuffer buffer);
-
- private native boolean setNativeInts(int[] ints);
-
- private native boolean setNativeFloats(float[] floats);
-
- private native int[] getNativeInts(int byteCount);
-
- private native float[] getNativeFloats(int byteCount);
-
- private native boolean setNativeBitmap(Bitmap bitmap, int size, int bytesPerSample);
-
- private native boolean getNativeBitmap(Bitmap bitmap, int size, int bytesPerSample);
-
- private native boolean nativeCopyFromNative(NativeFrame frame);
-
- private native boolean nativeCopyFromGL(GLFrame frame);
-}
+++ /dev/null
-/*
- * 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.core;
-
-import android.filterfw.core.Frame;
-import android.filterfw.core.Program;
-
-/**
- * @hide
- */
-public class NativeProgram extends Program {
-
- private int nativeProgramId;
- private boolean mHasInitFunction = false;
- private boolean mHasTeardownFunction = false;
- private boolean mHasSetValueFunction = false;
- private boolean mHasGetValueFunction = false;
- private boolean mHasResetFunction = false;
- private boolean mTornDown = false;
-
- public NativeProgram(String nativeLibName, String nativeFunctionPrefix) {
- // Allocate the native instance
- allocate();
-
- // Open the native library
- String fullLibName = "lib" + nativeLibName + ".so";
- if (!openNativeLibrary(fullLibName)) {
- throw new RuntimeException("Could not find native library named '" + fullLibName + "' " +
- "required for native program!");
- }
-
- // Bind the native functions
- String processFuncName = nativeFunctionPrefix + "_process";
- if (!bindProcessFunction(processFuncName)) {
- throw new RuntimeException("Could not find native program function name " +
- processFuncName + " in library " + fullLibName + "! " +
- "This function is required!");
- }
-
- String initFuncName = nativeFunctionPrefix + "_init";
- mHasInitFunction = bindInitFunction(initFuncName);
-
- String teardownFuncName = nativeFunctionPrefix + "_teardown";
- mHasTeardownFunction = bindTeardownFunction(teardownFuncName);
-
- String setValueFuncName = nativeFunctionPrefix + "_setvalue";
- mHasSetValueFunction = bindSetValueFunction(setValueFuncName);
-
- String getValueFuncName = nativeFunctionPrefix + "_getvalue";
- mHasGetValueFunction = bindGetValueFunction(getValueFuncName);
-
- String resetFuncName = nativeFunctionPrefix + "_reset";
- mHasResetFunction = bindResetFunction(resetFuncName);
-
- // Initialize the native code
- if (mHasInitFunction && !callNativeInit()) {
- throw new RuntimeException("Could not initialize NativeProgram!");
- }
- }
-
- public void tearDown() {
- if (mTornDown) return;
- if (mHasTeardownFunction && !callNativeTeardown()) {
- throw new RuntimeException("Could not tear down NativeProgram!");
- }
- deallocate();
- mTornDown = true;
- }
-
- @Override
- public void reset() {
- if (mHasResetFunction && !callNativeReset()) {
- throw new RuntimeException("Could not reset NativeProgram!");
- }
- }
-
- @Override
- protected void finalize() throws Throwable {
- tearDown();
- }
-
- @Override
- public void process(Frame[] inputs, Frame output) {
- if (mTornDown) {
- throw new RuntimeException("NativeProgram already torn down!");
- }
- NativeFrame[] nativeInputs = new NativeFrame[inputs.length];
- for (int i = 0; i < inputs.length; ++i) {
- if (inputs[i] == null || inputs[i] instanceof NativeFrame) {
- nativeInputs[i] = (NativeFrame)inputs[i];
- } else {
- throw new RuntimeException("NativeProgram got non-native frame as input "+ i +"!");
- }
- }
-
- // Get the native output frame
- NativeFrame nativeOutput = null;
- if (output == null || output instanceof NativeFrame) {
- nativeOutput = (NativeFrame)output;
- } else {
- throw new RuntimeException("NativeProgram got non-native output frame!");
- }
-
- // Process!
- if (!callNativeProcess(nativeInputs, nativeOutput)) {
- throw new RuntimeException("Calling native process() caused error!");
- }
- }
-
- @Override
- public void setHostValue(String variableName, Object value) {
- if (mTornDown) {
- throw new RuntimeException("NativeProgram already torn down!");
- }
- if (!mHasSetValueFunction) {
- throw new RuntimeException("Attempting to set native variable, but native code does not " +
- "define native setvalue function!");
- }
- if (!callNativeSetValue(variableName, value.toString())) {
- throw new RuntimeException("Error setting native value for variable '" + variableName + "'!");
- }
- }
-
- @Override
- public Object getHostValue(String variableName) {
- if (mTornDown) {
- throw new RuntimeException("NativeProgram already torn down!");
- }
- if (!mHasGetValueFunction) {
- throw new RuntimeException("Attempting to get native variable, but native code does not " +
- "define native getvalue function!");
- }
- return callNativeGetValue(variableName);
- }
-
- static {
- System.loadLibrary("filterfw");
- }
-
- private native boolean allocate();
-
- private native boolean deallocate();
-
- private native boolean nativeInit();
-
- private native boolean openNativeLibrary(String libName);
-
- private native boolean bindInitFunction(String funcName);
- private native boolean bindSetValueFunction(String funcName);
- private native boolean bindGetValueFunction(String funcName);
- private native boolean bindProcessFunction(String funcName);
- private native boolean bindResetFunction(String funcName);
- private native boolean bindTeardownFunction(String funcName);
-
- private native boolean callNativeInit();
- private native boolean callNativeSetValue(String key, String value);
- private native String callNativeGetValue(String key);
- private native boolean callNativeProcess(NativeFrame[] inputs, NativeFrame output);
- private native boolean callNativeReset();
- private native boolean callNativeTeardown();
-}
+++ /dev/null
-/*
- * 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.core;
-
-import android.filterfw.core.Filter;
-import android.filterfw.core.Scheduler;
-import android.filterfw.core.RoundRobinScheduler;
-import android.util.Log;
-
-import java.util.HashMap;
-
-/**
- * This OneShotScheduler only schedules source filters at most once. All other
- * filters will be scheduled, and possibly repeatedly, until there is no filter
- * that can be scheduled.
- *
- * @hide
- */
-public class OneShotScheduler extends RoundRobinScheduler {
- private HashMap <String, Integer> scheduled;
-
- private final boolean mLogVerbose;
- private static final String TAG = "OneShotScheduler";
-
- public OneShotScheduler(FilterGraph graph) {
- super(graph);
- scheduled = new HashMap<String, Integer>();
- mLogVerbose = Log.isLoggable(TAG, Log.VERBOSE);
- }
-
- @Override
- public void reset() {
- super.reset();
- scheduled.clear();
- }
-
- @Override
- public Filter scheduleNextNode() {
- Filter first = null;
- // return the first filter that is not scheduled before.
- while (true) {
- Filter filter = super.scheduleNextNode();
- if (filter == null) {
- if (mLogVerbose) Log.v(TAG, "No filters available to run.");
- return null;
- }
- if (!scheduled.containsKey(filter.getName())) {
- if (filter.getNumberOfConnectedInputs() == 0)
- scheduled.put(filter.getName(),1);
- if (mLogVerbose) Log.v(TAG, "Scheduling filter \"" + filter.getName() + "\" of type " + filter.getFilterClassName());
- return filter;
- }
- // if loop back, nothing available
- if (first == filter) {
- break;
- }
- // save the first scheduled one
- if (first == null) first = filter;
- }
- if (mLogVerbose) Log.v(TAG, "One pass through graph completed.");
- return null;
- }
-}
+++ /dev/null
-/*
- * 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.core;
-
-/**
- * @hide
- */
-public class OutputPort extends FilterPort {
-
- protected InputPort mTargetPort;
- protected InputPort mBasePort;
-
- public OutputPort(Filter filter, String name) {
- super(filter, name);
- }
-
- public void connectTo(InputPort target) {
- if (mTargetPort != null) {
- throw new RuntimeException(this + " already connected to " + mTargetPort + "!");
- }
- mTargetPort = target;
- mTargetPort.setSourcePort(this);
- }
-
- public boolean isConnected() {
- return mTargetPort != null;
- }
-
- public void open() {
- super.open();
- if (mTargetPort != null && !mTargetPort.isOpen()) {
- mTargetPort.open();
- }
- }
-
- public void close() {
- super.close();
- if (mTargetPort != null && mTargetPort.isOpen()) {
- mTargetPort.close();
- }
- }
-
- public InputPort getTargetPort() {
- return mTargetPort;
- }
-
- public Filter getTargetFilter() {
- return mTargetPort == null ? null : mTargetPort.getFilter();
- }
-
- public void setBasePort(InputPort basePort) {
- mBasePort = basePort;
- }
-
- public InputPort getBasePort() {
- return mBasePort;
- }
-
- public boolean filterMustClose() {
- return !isOpen() && isBlocking();
- }
-
- public boolean isReady() {
- return (isOpen() && mTargetPort.acceptsFrame()) || !isBlocking();
- }
-
- @Override
- public void clear() {
- if (mTargetPort != null) {
- mTargetPort.clear();
- }
- }
-
- @Override
- public void pushFrame(Frame frame) {
- if (mTargetPort == null) {
- throw new RuntimeException(
- "Attempting to push frame on unconnected port: " + this + "!");
- }
- mTargetPort.pushFrame(frame);
- }
-
- @Override
- public void setFrame(Frame frame) {
- assertPortIsOpen();
- if (mTargetPort == null) {
- throw new RuntimeException(
- "Attempting to set frame on unconnected port: " + this + "!");
- }
- mTargetPort.setFrame(frame);
- }
-
- @Override
- public Frame pullFrame() {
- throw new RuntimeException("Cannot pull frame on " + this + "!");
- }
-
- @Override
- public boolean hasFrame() {
- return mTargetPort == null ? false : mTargetPort.hasFrame();
- }
-
- @Override
- public String toString() {
- return "output " + super.toString();
- }
-}
+++ /dev/null
-/*
- * 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.core;
-
-import android.filterfw.core.Frame;
-
-/**
- * @hide
- */
-public abstract class Program {
-
- public abstract void process(Frame[] inputs, Frame output);
-
- public void process(Frame input, Frame output) {
- Frame[] inputs = new Frame[1];
- inputs[0] = input;
- process(inputs, output);
- }
-
- public abstract void setHostValue(String variableName, Object value);
-
- public abstract Object getHostValue(String variableName);
-
- public void reset() {
- }
-}
+++ /dev/null
-/*
- * 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.core;
-
-import java.lang.reflect.Field;
-
-/**
- * @hide
- */
-public class ProgramPort extends FieldPort {
-
- protected String mVarName;
-
- public ProgramPort(Filter filter,
- String name,
- String varName,
- Field field,
- boolean hasDefault) {
- super(filter, name, field, hasDefault);
- mVarName = varName;
- }
-
- @Override
- public String toString() {
- return "Program " + super.toString();
- }
-
- @Override
- public synchronized void transfer(FilterContext context) {
- if (mValueWaiting) {
- try {
- Object fieldValue = mField.get(mFilter);
- if (fieldValue != null) {
- Program program = (Program)fieldValue;
- program.setHostValue(mVarName, mValue);
- mValueWaiting = false;
- }
- } catch (IllegalAccessException e) {
- throw new RuntimeException(
- "Access to program field '" + mField.getName() + "' was denied!");
- } catch (ClassCastException e) {
- throw new RuntimeException("Non Program field '" + mField.getName()
- + "' annotated with ProgramParameter!");
- }
- }
- }
-}
+++ /dev/null
-/*
- * 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.core;
-
-/**
- * @hide
- */
-public class ProgramVariable {
-
- private Program mProgram;
- private String mVarName;
-
- public ProgramVariable(Program program, String varName) {
- mProgram = program;
- mVarName = varName;
- }
-
- public Program getProgram() {
- return mProgram;
- }
-
- public String getVariableName() {
- return mVarName;
- }
-
- public void setValue(Object value) {
- if (mProgram == null) {
- throw new RuntimeException("Attempting to set program variable '" + mVarName
- + "' but the program is null!");
- }
- mProgram.setHostValue(mVarName, value);
- }
-
- public Object getValue() {
- if (mProgram == null) {
- throw new RuntimeException("Attempting to get program variable '" + mVarName
- + "' but the program is null!");
- }
- return mProgram.getHostValue(mVarName);
- }
-
-}
+++ /dev/null
-/*
- * 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.core;
-
-/**
- * @hide
- */
-public class ProtocolException extends RuntimeException {
-
- public ProtocolException() {
- super();
- }
-
- public ProtocolException(String message) {
- super(message);
- }
-
-}
+++ /dev/null
-/*
- * 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.core;
-
-import java.util.Random;
-import java.util.Vector;
-
-import android.filterfw.core.Filter;
-import android.filterfw.core.Scheduler;
-
-/**
- * @hide
- */
-public class RandomScheduler extends Scheduler {
-
- private Random mRand = new Random();
-
- public RandomScheduler(FilterGraph graph) {
- super(graph);
- }
-
- @Override
- public void reset() {
- }
-
- @Override
- public Filter scheduleNextNode() {
- Vector<Filter> candidates = new Vector<Filter>();
- for (Filter filter : getGraph().getFilters()) {
- if (filter.canProcess())
- candidates.add(filter);
- }
- if (candidates.size() > 0) {
- int r = mRand.nextInt(candidates.size());
- return candidates.elementAt(r);
- }
- return null;
- }
-}
+++ /dev/null
-/*
- * 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.core;
-
-import java.util.Set;
-
-import android.filterfw.core.Filter;
-import android.filterfw.core.Scheduler;
-
-/**
- * @hide
- */
-public class RoundRobinScheduler extends Scheduler {
-
- private int mLastPos = -1;
-
- public RoundRobinScheduler(FilterGraph graph) {
- super(graph);
- }
-
- @Override
- public void reset() {
- mLastPos = -1;
- }
-
- @Override
- public Filter scheduleNextNode() {
- Set<Filter> all_filters = getGraph().getFilters();
- if (mLastPos >= all_filters.size()) mLastPos = -1;
- int pos = 0;
- Filter first = null;
- int firstNdx = -1;
- for (Filter filter : all_filters) {
- if (filter.canProcess()) {
- if (pos <= mLastPos) {
- if (first == null) {
- // store the first available filter
- first = filter;
- firstNdx = pos;
- }
- } else {
- // return the next available filter since last
- mLastPos = pos;
- return filter;
- }
- }
- pos ++;
- }
- // going around from the beginning
- if (first != null ) {
- mLastPos = firstNdx;
- return first;
- }
- // if there is nothing to be scheduled, still keep the previous
- // position.
- return null;
- }
-}
+++ /dev/null
-/*
- * 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.core;
-
-import android.filterfw.core.Filter;
-import android.filterfw.core.FilterGraph;
-
-/**
- * @hide
- */
-public abstract class Scheduler {
- // All methods are core internal methods as Scheduler internals are only used by the GraphRunner.
-
- private FilterGraph mGraph;
-
- Scheduler(FilterGraph graph) {
- mGraph = graph;
- }
-
- FilterGraph getGraph() {
- return mGraph;
- }
-
- abstract void reset();
-
- abstract Filter scheduleNextNode();
-
- boolean finished() {
- // TODO: Check that the state of all nodes is FINISHED.
- return true;
- }
-}
+++ /dev/null
-/*
- * 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.core;
-
-import android.filterfw.core.Frame;
-import android.filterfw.core.FrameFormat;
-import android.filterfw.core.FrameManager;
-import android.filterfw.core.NativeBuffer;
-import android.filterfw.format.ObjectFormat;
-import android.graphics.Bitmap;
-
-import java.io.InputStream;
-import java.io.IOException;
-import java.io.ObjectInputStream;
-import java.io.ObjectOutputStream;
-import java.io.OptionalDataException;
-import java.io.OutputStream;
-import java.io.StreamCorruptedException;
-import java.lang.reflect.Constructor;
-import java.nio.ByteBuffer;
-
-/**
- * A frame that serializes any assigned values. Such a frame is used when passing data objects
- * between threads.
- *
- * @hide
- */
-public class SerializedFrame extends Frame {
-
- /**
- * The initial capacity of the serialized data stream.
- */
- private final static int INITIAL_CAPACITY = 64;
-
- /**
- * The internal data streams.
- */
- private DirectByteOutputStream mByteOutputStream;
- private ObjectOutputStream mObjectOut;
-
- /**
- * An unsynchronized output stream that writes data to an accessible byte array. Callers are
- * responsible for synchronization. This is more efficient than a ByteArrayOutputStream, as
- * there are no array copies or synchronization involved to read back written data.
- */
- private class DirectByteOutputStream extends OutputStream {
- private byte[] mBuffer = null;
- private int mOffset = 0;
- private int mDataOffset = 0;
-
- public DirectByteOutputStream(int size) {
- mBuffer = new byte[size];
- }
-
- private final void ensureFit(int bytesToWrite) {
- if (mOffset + bytesToWrite > mBuffer.length) {
- byte[] oldBuffer = mBuffer;
- mBuffer = new byte[Math.max(mOffset + bytesToWrite, mBuffer.length * 2)];
- System.arraycopy(oldBuffer, 0, mBuffer, 0, mOffset);
- oldBuffer = null;
- }
- }
-
- public final void markHeaderEnd() {
- mDataOffset = mOffset;
- }
-
- public final int getSize() {
- return mOffset;
- }
-
- public byte[] getByteArray() {
- return mBuffer;
- }
-
- @Override
- public final void write(byte b[]) {
- write(b, 0, b.length);
- }
-
- @Override
- public final void write(byte b[], int off, int len) {
- ensureFit(len);
- System.arraycopy(b, off, mBuffer, mOffset, len);
- mOffset += len;
- }
-
- @Override
- public final void write(int b) {
- ensureFit(1);
- mBuffer[mOffset++] = (byte)b;
- }
-
- public final void reset() {
- mOffset = mDataOffset;
- }
-
- public final DirectByteInputStream getInputStream() {
- return new DirectByteInputStream(mBuffer, mOffset);
- }
- }
-
- /**
- * An unsynchronized input stream that reads data directly from a provided byte array. Callers
- * are responsible for synchronization and ensuring that the byte buffer is valid.
- */
- private class DirectByteInputStream extends InputStream {
-
- private byte[] mBuffer;
- private int mPos = 0;
- private int mSize;
-
- public DirectByteInputStream(byte[] buffer, int size) {
- mBuffer = buffer;
- mSize = size;
- }
-
- @Override
- public final int available() {
- return mSize - mPos;
- }
-
- @Override
- public final int read() {
- return (mPos < mSize) ? (mBuffer[mPos++] & 0xFF) : -1;
- }
-
- @Override
- public final int read(byte[] b, int off, int len) {
- if (mPos >= mSize) {
- return -1;
- }
- if ((mPos + len) > mSize) {
- len = mSize - mPos;
- }
- System.arraycopy(mBuffer, mPos, b, off, len);
- mPos += len;
- return len;
- }
-
- @Override
- public final long skip(long n) {
- if ((mPos + n) > mSize) {
- n = mSize - mPos;
- }
- if (n < 0) {
- return 0;
- }
- mPos += n;
- return n;
- }
- }
-
- SerializedFrame(FrameFormat format, FrameManager frameManager) {
- super(format, frameManager);
- setReusable(false);
-
- // Setup streams
- try {
- mByteOutputStream = new DirectByteOutputStream(INITIAL_CAPACITY);
- mObjectOut = new ObjectOutputStream(mByteOutputStream);
- mByteOutputStream.markHeaderEnd();
- } catch (IOException e) {
- throw new RuntimeException("Could not create serialization streams for "
- + "SerializedFrame!", e);
- }
- }
-
- static SerializedFrame wrapObject(Object object, FrameManager frameManager) {
- FrameFormat format = ObjectFormat.fromObject(object, FrameFormat.TARGET_SIMPLE);
- SerializedFrame result = new SerializedFrame(format, frameManager);
- result.setObjectValue(object);
- return result;
- }
-
- @Override
- protected boolean hasNativeAllocation() {
- return false;
- }
-
- @Override
- protected void releaseNativeAllocation() {
- }
-
- @Override
- public Object getObjectValue() {
- return deserializeObjectValue();
- }
-
- @Override
- public void setInts(int[] ints) {
- assertFrameMutable();
- setGenericObjectValue(ints);
- }
-
- @Override
- public int[] getInts() {
- Object result = deserializeObjectValue();
- return (result instanceof int[]) ? (int[])result : null;
- }
-
- @Override
- public void setFloats(float[] floats) {
- assertFrameMutable();
- setGenericObjectValue(floats);
- }
-
- @Override
- public float[] getFloats() {
- Object result = deserializeObjectValue();
- return (result instanceof float[]) ? (float[])result : null;
- }
-
- @Override
- public void setData(ByteBuffer buffer, int offset, int length) {
- assertFrameMutable();
- setGenericObjectValue(ByteBuffer.wrap(buffer.array(), offset, length));
- }
-
- @Override
- public ByteBuffer getData() {
- Object result = deserializeObjectValue();
- return (result instanceof ByteBuffer) ? (ByteBuffer)result : null;
- }
-
- @Override
- public void setBitmap(Bitmap bitmap) {
- assertFrameMutable();
- setGenericObjectValue(bitmap);
- }
-
- @Override
- public Bitmap getBitmap() {
- Object result = deserializeObjectValue();
- return (result instanceof Bitmap) ? (Bitmap)result : null;
- }
-
- @Override
- protected void setGenericObjectValue(Object object) {
- serializeObjectValue(object);
- }
-
- private final void serializeObjectValue(Object object) {
- try {
- mByteOutputStream.reset();
- mObjectOut.writeObject(object);
- mObjectOut.flush();
- mObjectOut.close();
- } catch (IOException e) {
- throw new RuntimeException("Could not serialize object " + object + " in "
- + this + "!", e);
- }
- }
-
- private final Object deserializeObjectValue() {
- try {
- InputStream inputStream = mByteOutputStream.getInputStream();
- ObjectInputStream objectStream = new ObjectInputStream(inputStream);
- return objectStream.readObject();
- } catch (IOException e) {
- throw new RuntimeException("Could not deserialize object in " + this + "!", e);
- } catch (ClassNotFoundException e) {
- throw new RuntimeException("Unable to deserialize object of unknown class in "
- + this + "!", e);
- }
- }
-
- @Override
- public String toString() {
- return "SerializedFrame (" + getFormat() + ")";
- }
-}
+++ /dev/null
-/*
- * 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.core;
-
-import android.filterfw.core.Frame;
-import android.filterfw.core.NativeAllocatorTag;
-import android.filterfw.core.Program;
-import android.filterfw.core.StopWatchMap;
-import android.filterfw.core.VertexFrame;
-import android.filterfw.geometry.Quad;
-import android.opengl.GLES20;
-
-/**
- * @hide
- */
-public class ShaderProgram extends Program {
-
- private int shaderProgramId;
-
- private int mMaxTileSize = 0;
-
- // Keep a reference to the GL environment, so that it does not get deallocated while there
- // are still programs living in it.
- private GLEnvironment mGLEnvironment;
-
- private StopWatchMap mTimer = null;
-
- private void setTimer() {
- mTimer = new StopWatchMap();
- }
-
- // Used from native layer for creating empty wrapper only!
- private ShaderProgram() {
- }
-
- private ShaderProgram(NativeAllocatorTag tag) {
- }
-
- public ShaderProgram(FilterContext context, String fragmentShader) {
- mGLEnvironment = getGLEnvironment(context);
- allocate(mGLEnvironment, null, fragmentShader);
- if (!compileAndLink()) {
- throw new RuntimeException("Could not compile and link shader!");
- }
- this.setTimer();
- }
-
- public ShaderProgram(FilterContext context, String vertexShader, String fragmentShader) {
- mGLEnvironment = getGLEnvironment(context);
- allocate(mGLEnvironment, vertexShader, fragmentShader);
- if (!compileAndLink()) {
- throw new RuntimeException("Could not compile and link shader!");
- }
- this.setTimer();
- }
-
- public static ShaderProgram createIdentity(FilterContext context) {
- ShaderProgram program = nativeCreateIdentity(getGLEnvironment(context));
- program.setTimer();
- return program;
- }
-
- @Override
- protected void finalize() throws Throwable {
- deallocate();
- }
-
- public GLEnvironment getGLEnvironment() {
- return mGLEnvironment;
- }
-
- @Override
- public void process(Frame[] inputs, Frame output) {
- if (mTimer.LOG_MFF_RUNNING_TIMES) {
- mTimer.start("glFinish");
- GLES20.glFinish();
- mTimer.stop("glFinish");
- }
-
- // Get the GL input frames
- // TODO: We do the same in the NativeProgram... can we find a better way?!
- GLFrame[] glInputs = new GLFrame[inputs.length];
- for (int i = 0; i < inputs.length; ++i) {
- if (inputs[i] instanceof GLFrame) {
- glInputs[i] = (GLFrame)inputs[i];
- } else {
- throw new RuntimeException("ShaderProgram got non-GL frame as input " + i + "!");
- }
- }
-
- // Get the GL output frame
- GLFrame glOutput = null;
- if (output instanceof GLFrame) {
- glOutput = (GLFrame)output;
- } else {
- throw new RuntimeException("ShaderProgram got non-GL output frame!");
- }
-
- // Adjust tiles to meet maximum tile size requirement
- if (mMaxTileSize > 0) {
- int xTiles = (output.getFormat().getWidth() + mMaxTileSize - 1) / mMaxTileSize;
- int yTiles = (output.getFormat().getHeight() + mMaxTileSize - 1) / mMaxTileSize;
- setShaderTileCounts(xTiles, yTiles);
- }
-
- // Process!
- if (!shaderProcess(glInputs, glOutput)) {
- throw new RuntimeException("Error executing ShaderProgram!");
- }
-
- if (mTimer.LOG_MFF_RUNNING_TIMES) {
- GLES20.glFinish();
- }
- }
-
- @Override
- public void setHostValue(String variableName, Object value) {
- if (!setUniformValue(variableName, value)) {
- throw new RuntimeException("Error setting uniform value for variable '" +
- variableName + "'!");
- }
- }
-
- @Override
- public Object getHostValue(String variableName) {
- return getUniformValue(variableName);
- }
-
- public void setAttributeValues(String attributeName, float[] data, int componentCount) {
- if (!setShaderAttributeValues(attributeName, data, componentCount)) {
- throw new RuntimeException("Error setting attribute value for attribute '" +
- attributeName + "'!");
- }
- }
-
- public void setAttributeValues(String attributeName,
- VertexFrame vertexData,
- int type,
- int componentCount,
- int strideInBytes,
- int offsetInBytes,
- boolean normalize) {
- if (!setShaderAttributeVertexFrame(attributeName,
- vertexData,
- type,
- componentCount,
- strideInBytes,
- offsetInBytes,
- normalize)) {
- throw new RuntimeException("Error setting attribute value for attribute '" +
- attributeName + "'!");
- }
- }
-
- public void setSourceRegion(Quad region) {
- setSourceRegion(region.p0.x, region.p0.y,
- region.p1.x, region.p1.y,
- region.p2.x, region.p2.y,
- region.p3.x, region.p3.y);
- }
-
- public void setTargetRegion(Quad region) {
- setTargetRegion(region.p0.x, region.p0.y,
- region.p1.x, region.p1.y,
- region.p2.x, region.p2.y,
- region.p3.x, region.p3.y);
- }
-
- public void setSourceRect(float x, float y, float width, float height) {
- setSourceRegion(x, y, x + width, y, x, y + height, x + width, y + height);
- }
-
- public void setTargetRect(float x, float y, float width, float height) {
- setTargetRegion(x, y, x + width, y, x, y + height, x + width, y + height);
- }
-
- public void setClearsOutput(boolean clears) {
- if (!setShaderClearsOutput(clears)) {
- throw new RuntimeException("Could not set clears-output flag to " + clears + "!");
- }
- }
-
- public void setClearColor(float r, float g, float b) {
- if (!setShaderClearColor(r, g, b)) {
- throw new RuntimeException("Could not set clear color to " + r + "," + g + "," + b + "!");
- }
- }
-
- public void setBlendEnabled(boolean enable) {
- if (!setShaderBlendEnabled(enable)) {
- throw new RuntimeException("Could not set Blending " + enable + "!");
- }
- }
-
- public void setBlendFunc(int sfactor, int dfactor) {
- if (!setShaderBlendFunc(sfactor, dfactor)) {
- throw new RuntimeException("Could not set BlendFunc " + sfactor +","+ dfactor + "!");
- }
- }
-
- public void setDrawMode(int drawMode) {
- if (!setShaderDrawMode(drawMode)) {
- throw new RuntimeException("Could not set GL draw-mode to " + drawMode + "!");
- }
- }
-
- public void setVertexCount(int count) {
- if (!setShaderVertexCount(count)) {
- throw new RuntimeException("Could not set GL vertex count to " + count + "!");
- }
- }
-
- public void setMaximumTileSize(int size) {
- mMaxTileSize = size;
- }
-
- public void beginDrawing() {
- if (!beginShaderDrawing()) {
- throw new RuntimeException("Could not prepare shader-program for drawing!");
- }
- }
-
- private static GLEnvironment getGLEnvironment(FilterContext context) {
- GLEnvironment result = context != null ? context.getGLEnvironment() : null;
- if (result == null) {
- throw new NullPointerException("Attempting to create ShaderProgram with no GL "
- + "environment in place!");
- }
- return result;
- }
-
- static {
- System.loadLibrary("filterfw");
- }
-
- private native boolean allocate(GLEnvironment glEnv,
- String vertexShader,
- String fragmentShader);
-
- private native boolean deallocate();
-
- private native boolean compileAndLink();
-
- private native boolean shaderProcess(GLFrame[] inputs, GLFrame output);
-
- private native boolean setUniformValue(String name, Object value);
-
- private native Object getUniformValue(String name);
-
- public native boolean setSourceRegion(float x0, float y0, float x1, float y1,
- float x2, float y2, float x3, float y3);
-
- private native boolean setTargetRegion(float x0, float y0, float x1, float y1,
- float x2, float y2, float x3, float y3);
-
- private static native ShaderProgram nativeCreateIdentity(GLEnvironment glEnv);
-
- private native boolean setShaderClearsOutput(boolean clears);
-
- private native boolean setShaderBlendEnabled(boolean enable);
-
- private native boolean setShaderBlendFunc(int sfactor, int dfactor);
-
- private native boolean setShaderClearColor(float r, float g, float b);
-
- private native boolean setShaderDrawMode(int drawMode);
-
- private native boolean setShaderTileCounts(int xCount, int yCount);
-
- private native boolean setShaderVertexCount(int vertexCount);
-
- private native boolean beginShaderDrawing();
-
- private native boolean setShaderAttributeValues(String attributeName,
- float[] data,
- int componentCount);
-
- private native boolean setShaderAttributeVertexFrame(String attributeName,
- VertexFrame vertexData,
- int type,
- int componentCount,
- int strideInBytes,
- int offsetInBytes,
- boolean normalize);
-
-}
+++ /dev/null
-/*
- * 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.core;
-
-import android.filterfw.core.Frame;
-import android.filterfw.core.FrameFormat;
-import android.filterfw.core.FrameManager;
-import android.filterfw.core.NativeBuffer;
-import android.filterfw.format.ObjectFormat;
-import android.graphics.Bitmap;
-
-import java.lang.reflect.Constructor;
-import java.nio.ByteBuffer;
-
-/**
- * @hide
- */
-public class SimpleFrame extends Frame {
-
- private Object mObject;
-
- SimpleFrame(FrameFormat format, FrameManager frameManager) {
- super(format, frameManager);
- initWithFormat(format);
- setReusable(false);
- }
-
- static SimpleFrame wrapObject(Object object, FrameManager frameManager) {
- FrameFormat format = ObjectFormat.fromObject(object, FrameFormat.TARGET_SIMPLE);
- SimpleFrame result = new SimpleFrame(format, frameManager);
- result.setObjectValue(object);
- return result;
- }
-
- private void initWithFormat(FrameFormat format) {
- final int count = format.getLength();
- final int baseType = format.getBaseType();
- switch (baseType) {
- case FrameFormat.TYPE_BYTE:
- mObject = new byte[count];
- break;
- case FrameFormat.TYPE_INT16:
- mObject = new short[count];
- break;
- case FrameFormat.TYPE_INT32:
- mObject = new int[count];
- break;
- case FrameFormat.TYPE_FLOAT:
- mObject = new float[count];
- break;
- case FrameFormat.TYPE_DOUBLE:
- mObject = new double[count];
- break;
- default:
- mObject = null;
- break;
- }
- }
-
- @Override
- protected boolean hasNativeAllocation() {
- return false;
- }
-
- @Override
- protected void releaseNativeAllocation() {
- }
-
- @Override
- public Object getObjectValue() {
- return mObject;
- }
-
- @Override
- public void setInts(int[] ints) {
- assertFrameMutable();
- setGenericObjectValue(ints);
- }
-
- @Override
- public int[] getInts() {
- return (mObject instanceof int[]) ? (int[])mObject : null;
- }
-
- @Override
- public void setFloats(float[] floats) {
- assertFrameMutable();
- setGenericObjectValue(floats);
- }
-
- @Override
- public float[] getFloats() {
- return (mObject instanceof float[]) ? (float[])mObject : null;
- }
-
- @Override
- public void setData(ByteBuffer buffer, int offset, int length) {
- assertFrameMutable();
- setGenericObjectValue(ByteBuffer.wrap(buffer.array(), offset, length));
- }
-
- @Override
- public ByteBuffer getData() {
- return (mObject instanceof ByteBuffer) ? (ByteBuffer)mObject : null;
- }
-
- @Override
- public void setBitmap(Bitmap bitmap) {
- assertFrameMutable();
- setGenericObjectValue(bitmap);
- }
-
- @Override
- public Bitmap getBitmap() {
- return (mObject instanceof Bitmap) ? (Bitmap)mObject : null;
- }
-
- private void setFormatObjectClass(Class objectClass) {
- MutableFrameFormat format = getFormat().mutableCopy();
- format.setObjectClass(objectClass);
- setFormat(format);
- }
-
- @Override
- protected void setGenericObjectValue(Object object) {
- // Update the FrameFormat class
- // TODO: Take this out! FrameFormats should not be modified and convenience formats used
- // instead!
- FrameFormat format = getFormat();
- if (format.getObjectClass() == null) {
- setFormatObjectClass(object.getClass());
- } else if (!format.getObjectClass().isAssignableFrom(object.getClass())) {
- throw new RuntimeException(
- "Attempting to set object value of type '" + object.getClass() + "' on " +
- "SimpleFrame of type '" + format.getObjectClass() + "'!");
- }
-
- // Set the object value
- mObject = object;
- }
-
- @Override
- public String toString() {
- return "SimpleFrame (" + getFormat() + ")";
- }
-}
+++ /dev/null
-/*
- * 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.core;
-
-import android.filterfw.core.Frame;
-import android.filterfw.core.FrameFormat;
-import android.filterfw.core.FrameManager;
-import android.filterfw.core.GLFrame;
-import android.filterfw.core.NativeFrame;
-import android.filterfw.core.SimpleFrame;
-import android.filterfw.core.VertexFrame;
-
-/**
- * @hide
- */
-public class SimpleFrameManager extends FrameManager {
-
- public SimpleFrameManager() {
- }
-
- @Override
- public Frame newFrame(FrameFormat format) {
- return createNewFrame(format);
- }
-
- @Override
- public Frame newBoundFrame(FrameFormat format, int bindingType, long bindingId) {
- Frame result = null;
- switch(format.getTarget()) {
- case FrameFormat.TARGET_GPU: {
- GLFrame glFrame = new GLFrame(format, this, bindingType, bindingId);
- glFrame.init(getGLEnvironment());
- result = glFrame;
- break;
- }
-
- default:
- throw new RuntimeException("Attached frames are not supported for target type: "
- + FrameFormat.targetToString(format.getTarget()) + "!");
- }
- return result;
- }
-
- private Frame createNewFrame(FrameFormat format) {
- Frame result = null;
- switch(format.getTarget()) {
- case FrameFormat.TARGET_SIMPLE:
- result = new SimpleFrame(format, this);
- break;
-
- case FrameFormat.TARGET_NATIVE:
- result = new NativeFrame(format, this);
- break;
-
- case FrameFormat.TARGET_GPU: {
- GLFrame glFrame = new GLFrame(format, this);
- glFrame.init(getGLEnvironment());
- result = glFrame;
- break;
- }
-
- case FrameFormat.TARGET_VERTEXBUFFER: {
- result = new VertexFrame(format, this);
- break;
- }
-
- default:
- throw new RuntimeException("Unsupported frame target type: " +
- FrameFormat.targetToString(format.getTarget()) + "!");
- }
- return result;
- }
-
- @Override
- public Frame retainFrame(Frame frame) {
- frame.incRefCount();
- return frame;
- }
-
- @Override
- public Frame releaseFrame(Frame frame) {
- int refCount = frame.decRefCount();
- if (refCount == 0 && frame.hasNativeAllocation()) {
- frame.releaseNativeAllocation();
- return null;
- } else if (refCount < 0) {
- throw new RuntimeException("Frame reference count dropped below 0!");
- }
- return frame;
- }
-
-}
+++ /dev/null
-/*
- * 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.core;
-
-import android.filterfw.core.Filter;
-import android.filterfw.core.Scheduler;
-
-/**
- * @hide
- */
-public class SimpleScheduler extends Scheduler {
-
- public SimpleScheduler(FilterGraph graph) {
- super(graph);
- }
-
- @Override
- public void reset() {
- }
-
- @Override
- public Filter scheduleNextNode() {
- for (Filter filter : getGraph().getFilters()) {
- if (filter.canProcess())
- return filter;
- }
- return null;
- }
-
-}
+++ /dev/null
-/*
- * 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.core;
-
-import android.os.SystemClock;
-import android.util.Log;
-import java.util.HashMap;
-
-/**
- * @hide
- */
-class StopWatch {
-
- private int STOP_WATCH_LOGGING_PERIOD = 200;
- private String TAG = "MFF";
-
- private String mName;
- private long mStartTime;
- private long mTotalTime;
- private int mNumCalls;
-
- public StopWatch(String name) {
- mName = name;
- mStartTime = -1;
- mTotalTime = 0;
- mNumCalls = 0;
- }
-
- public void start() {
- if (mStartTime != -1) {
- throw new RuntimeException(
- "Calling start with StopWatch already running");
- }
- mStartTime = SystemClock.elapsedRealtime();
- }
-
- public void stop() {
- if (mStartTime == -1) {
- throw new RuntimeException(
- "Calling stop with StopWatch already stopped");
- }
- long stopTime = SystemClock.elapsedRealtime();
- mTotalTime += stopTime - mStartTime;
- ++mNumCalls;
- mStartTime = -1;
- if (mNumCalls % STOP_WATCH_LOGGING_PERIOD == 0) {
- Log.i(TAG, "AVG ms/call " + mName + ": " +
- String.format("%.1f", mTotalTime * 1.0f / mNumCalls));
- mTotalTime = 0;
- mNumCalls = 0;
- }
- }
-
-}
-
-public class StopWatchMap {
-
- public boolean LOG_MFF_RUNNING_TIMES = false;
-
- private HashMap<String, StopWatch> mStopWatches = null;
-
- public StopWatchMap() {
- mStopWatches = new HashMap<String, StopWatch>();
- }
-
- public void start(String stopWatchName) {
- if (!LOG_MFF_RUNNING_TIMES) {
- return;
- }
- if (!mStopWatches.containsKey(stopWatchName)) {
- mStopWatches.put(stopWatchName, new StopWatch(stopWatchName));
- }
- mStopWatches.get(stopWatchName).start();
- }
-
- public void stop(String stopWatchName) {
- if (!LOG_MFF_RUNNING_TIMES) {
- return;
- }
- if (!mStopWatches.containsKey(stopWatchName)) {
- throw new RuntimeException(
- "Calling stop with unknown stopWatchName: " + stopWatchName);
- }
- mStopWatches.get(stopWatchName).stop();
- }
-
-}
+++ /dev/null
-/*
- * 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.core;
-
-/**
- * @hide
- */
-public class StreamPort extends InputPort {
-
- private Frame mFrame;
- private boolean mPersistent;
-
- public StreamPort(Filter filter, String name) {
- super(filter, name);
- }
-
- @Override
- public void clear() {
- if (mFrame != null) {
- mFrame.release();
- mFrame = null;
- }
- }
-
- @Override
- public void setFrame(Frame frame) {
- assignFrame(frame, true);
- }
-
- @Override
- public void pushFrame(Frame frame) {
- assignFrame(frame, false);
- }
-
- protected synchronized void assignFrame(Frame frame, boolean persistent) {
- assertPortIsOpen();
- checkFrameType(frame, persistent);
-
- if (persistent) {
- if (mFrame != null) {
- mFrame.release();
- }
- } else if (mFrame != null) {
- throw new RuntimeException(
- "Attempting to push more than one frame on port: " + this + "!");
- }
- mFrame = frame.retain();
- mFrame.markReadOnly();
- mPersistent = persistent;
- }
-
- @Override
- public synchronized Frame pullFrame() {
- // Make sure we have a frame
- if (mFrame == null) {
- throw new RuntimeException("No frame available to pull on port: " + this + "!");
- }
-
- // Return a retained result
- Frame result = mFrame;
- if (mPersistent) {
- mFrame.retain();
- } else {
- mFrame = null;
- }
- return result;
- }
-
- @Override
- public synchronized boolean hasFrame() {
- return mFrame != null;
- }
-
- @Override
- public String toString() {
- return "input " + super.toString();
- }
-
- @Override
- public synchronized void transfer(FilterContext context) {
- if (mFrame != null) {
- checkFrameManager(mFrame, context);
- }
- }
-}
+++ /dev/null
-/*
- * 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.core;
-
-import android.os.ConditionVariable;
-import android.util.Log;
-
-import java.lang.reflect.Constructor;
-import java.lang.reflect.InvocationTargetException;
-import java.util.concurrent.ScheduledThreadPoolExecutor;
-import java.util.concurrent.TimeUnit;
-
-/**
- * @hide
- */
-public class SyncRunner extends GraphRunner {
-
- private Scheduler mScheduler = null;
-
- private OnRunnerDoneListener mDoneListener = null;
- private ScheduledThreadPoolExecutor mWakeExecutor = new ScheduledThreadPoolExecutor(1);
- private ConditionVariable mWakeCondition = new ConditionVariable();
-
- private StopWatchMap mTimer = null;
-
- private final boolean mLogVerbose;
- private final static String TAG = "SyncRunner";
-
- // TODO: Provide factory based constructor?
- public SyncRunner(FilterContext context, FilterGraph graph, Class schedulerClass) {
- super(context);
-
- mLogVerbose = Log.isLoggable(TAG, Log.VERBOSE);
-
- if (mLogVerbose) Log.v(TAG, "Initializing SyncRunner");
-
- // Create the scheduler
- if (Scheduler.class.isAssignableFrom(schedulerClass)) {
- try {
- Constructor schedulerConstructor = schedulerClass.getConstructor(FilterGraph.class);
- mScheduler = (Scheduler)schedulerConstructor.newInstance(graph);
- } catch (NoSuchMethodException e) {
- throw new RuntimeException("Scheduler does not have constructor <init>(FilterGraph)!", e);
- } catch (InstantiationException e) {
- throw new RuntimeException("Could not instantiate the Scheduler instance!", e);
- } catch (IllegalAccessException e) {
- throw new RuntimeException("Cannot access Scheduler constructor!", e);
- } catch (InvocationTargetException e) {
- throw new RuntimeException("Scheduler constructor threw an exception", e);
- } catch (Exception e) {
- throw new RuntimeException("Could not instantiate Scheduler", e);
- }
- } else {
- throw new IllegalArgumentException("Class provided is not a Scheduler subclass!");
- }
-
- // Associate this runner and the graph with the context
- mFilterContext = context;
- mFilterContext.addGraph(graph);
-
- mTimer = new StopWatchMap();
-
- if (mLogVerbose) Log.v(TAG, "Setting up filters");
-
- // Setup graph filters
- graph.setupFilters();
- }
-
- @Override
- public FilterGraph getGraph() {
- return mScheduler != null ? mScheduler.getGraph() : null;
- }
-
- public int step() {
- assertReadyToStep();
- if (!getGraph().isReady() ) {
- throw new RuntimeException("Trying to process graph that is not open!");
- }
- return performStep() ? RESULT_RUNNING : determinePostRunState();
- }
-
- public void beginProcessing() {
- mScheduler.reset();
- getGraph().beginProcessing();
- }
-
- public void close() {
- // Close filters
- if (mLogVerbose) Log.v(TAG, "Closing graph.");
- getGraph().closeFilters(mFilterContext);
- mScheduler.reset();
- }
-
- @Override
- public void run() {
- if (mLogVerbose) Log.v(TAG, "Beginning run.");
-
- assertReadyToStep();
-
- // Preparation
- beginProcessing();
- boolean glActivated = activateGlContext();
-
- // Run
- boolean keepRunning = true;
- while (keepRunning) {
- keepRunning = performStep();
- }
-
- // Cleanup
- if (glActivated) {
- deactivateGlContext();
- }
-
- // Call completion callback if set
- if (mDoneListener != null) {
- if (mLogVerbose) Log.v(TAG, "Calling completion listener.");
- mDoneListener.onRunnerDone(determinePostRunState());
- }
- if (mLogVerbose) Log.v(TAG, "Run complete");
- }
-
- @Override
- public boolean isRunning() {
- return false;
- }
-
- @Override
- public void setDoneCallback(OnRunnerDoneListener listener) {
- mDoneListener = listener;
- }
-
- @Override
- public void stop() {
- throw new RuntimeException("SyncRunner does not support stopping a graph!");
- }
-
- @Override
- synchronized public Exception getError() {
- return null;
- }
-
- protected void waitUntilWake() {
- mWakeCondition.block();
- }
-
- protected void processFilterNode(Filter filter) {
- if (mLogVerbose) Log.v(TAG, "Processing filter node");
- filter.performProcess(mFilterContext);
- if (filter.getStatus() == Filter.STATUS_ERROR) {
- throw new RuntimeException("There was an error executing " + filter + "!");
- } else if (filter.getStatus() == Filter.STATUS_SLEEPING) {
- if (mLogVerbose) Log.v(TAG, "Scheduling filter wakeup");
- scheduleFilterWake(filter, filter.getSleepDelay());
- }
- }
-
- protected void scheduleFilterWake(Filter filter, int delay) {
- // Close the wake condition
- mWakeCondition.close();
-
- // Schedule the wake-up
- final Filter filterToSchedule = filter;
- final ConditionVariable conditionToWake = mWakeCondition;
-
- mWakeExecutor.schedule(new Runnable() {
- @Override
- public void run() {
- filterToSchedule.unsetStatus(Filter.STATUS_SLEEPING);
- conditionToWake.open();
- }
- }, delay, TimeUnit.MILLISECONDS);
- }
-
- protected int determinePostRunState() {
- boolean isBlocked = false;
- for (Filter filter : mScheduler.getGraph().getFilters()) {
- if (filter.isOpen()) {
- if (filter.getStatus() == Filter.STATUS_SLEEPING) {
- // If ANY node is sleeping, we return our state as sleeping
- return RESULT_SLEEPING;
- } else {
- // If a node is still open, it is blocked (by input or output)
- return RESULT_BLOCKED;
- }
- }
- }
- return RESULT_FINISHED;
- }
-
- // Core internal methods ///////////////////////////////////////////////////////////////////////
- boolean performStep() {
- if (mLogVerbose) Log.v(TAG, "Performing one step.");
- Filter filter = mScheduler.scheduleNextNode();
- if (filter != null) {
- mTimer.start(filter.getName());
- processFilterNode(filter);
- mTimer.stop(filter.getName());
- return true;
- } else {
- return false;
- }
- }
-
- void assertReadyToStep() {
- if (mScheduler == null) {
- throw new RuntimeException("Attempting to run schedule with no scheduler in place!");
- } else if (getGraph() == null) {
- throw new RuntimeException("Calling step on scheduler with no graph in place!");
- }
- }
-}
+++ /dev/null
-/*
- * 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.core;
-
-import android.filterfw.core.Frame;
-import android.filterfw.core.FrameFormat;
-import android.filterfw.core.FrameManager;
-import android.graphics.Bitmap;
-
-import java.nio.ByteBuffer;
-
-/**
- * @hide
- */
-public class VertexFrame extends Frame {
-
- private int vertexFrameId = -1;
-
- VertexFrame(FrameFormat format, FrameManager frameManager) {
- super(format, frameManager);
- if (getFormat().getSize() <= 0) {
- throw new IllegalArgumentException("Initializing vertex frame with zero size!");
- } else {
- if (!nativeAllocate(getFormat().getSize())) {
- throw new RuntimeException("Could not allocate vertex frame!");
- }
- }
- }
-
- @Override
- protected synchronized boolean hasNativeAllocation() {
- return vertexFrameId != -1;
- }
-
- @Override
- protected synchronized void releaseNativeAllocation() {
- nativeDeallocate();
- vertexFrameId = -1;
- }
-
- @Override
- public Object getObjectValue() {
- throw new RuntimeException("Vertex frames do not support reading data!");
- }
-
- @Override
- public void setInts(int[] ints) {
- assertFrameMutable();
- if (!setNativeInts(ints)) {
- throw new RuntimeException("Could not set int values for vertex frame!");
- }
- }
-
- @Override
- public int[] getInts() {
- throw new RuntimeException("Vertex frames do not support reading data!");
- }
-
- @Override
- public void setFloats(float[] floats) {
- assertFrameMutable();
- if (!setNativeFloats(floats)) {
- throw new RuntimeException("Could not set int values for vertex frame!");
- }
- }
-
- @Override
- public float[] getFloats() {
- throw new RuntimeException("Vertex frames do not support reading data!");
- }
-
- @Override
- public void setData(ByteBuffer buffer, int offset, int length) {
- assertFrameMutable();
- byte[] bytes = buffer.array();
- if (getFormat().getSize() != bytes.length) {
- throw new RuntimeException("Data size in setData does not match vertex frame size!");
- } else if (!setNativeData(bytes, offset, length)) {
- throw new RuntimeException("Could not set vertex frame data!");
- }
- }
-
- @Override
- public ByteBuffer getData() {
- throw new RuntimeException("Vertex frames do not support reading data!");
- }
-
- @Override
- public void setBitmap(Bitmap bitmap) {
- throw new RuntimeException("Unsupported: Cannot set vertex frame bitmap value!");
- }
-
- @Override
- public Bitmap getBitmap() {
- throw new RuntimeException("Vertex frames do not support reading data!");
- }
-
- @Override
- public void setDataFromFrame(Frame frame) {
- // TODO: Optimize
- super.setDataFromFrame(frame);
- }
-
- public int getVboId() {
- return getNativeVboId();
- }
-
- @Override
- public String toString() {
- return "VertexFrame (" + getFormat() + ") with VBO ID " + getVboId();
- }
-
- static {
- System.loadLibrary("filterfw");
- }
-
- private native boolean nativeAllocate(int size);
-
- private native boolean nativeDeallocate();
-
- private native boolean setNativeData(byte[] data, int offset, int length);
-
- private native boolean setNativeInts(int[] ints);
-
- private native boolean setNativeFloats(float[] floats);
-
- private native int getNativeVboId();
-}
+++ /dev/null
-/**
- * @hide
- */
-package android.filterfw.core;
+++ /dev/null
-/*
- * 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.format;
-
-import android.filterfw.core.FrameFormat;
-import android.filterfw.core.MutableFrameFormat;
-import android.graphics.Bitmap;
-
-/**
- * @hide
- */
-public class ImageFormat {
-
- public static final String COLORSPACE_KEY = "colorspace";
-
- public static final int COLORSPACE_GRAY = 1;
- public static final int COLORSPACE_RGB = 2;
- public static final int COLORSPACE_RGBA = 3;
- public static final int COLORSPACE_YUV = 4;
-
- public static MutableFrameFormat create(int width,
- int height,
- int colorspace,
- int bytesPerSample,
- int target) {
- MutableFrameFormat result = new MutableFrameFormat(FrameFormat.TYPE_BYTE, target);
- result.setDimensions(width, height);
- result.setBytesPerSample(bytesPerSample);
- result.setMetaValue(COLORSPACE_KEY, colorspace);
- if (target == FrameFormat.TARGET_SIMPLE) {
- result.setObjectClass(Bitmap.class);
- }
- return result;
- }
-
- public static MutableFrameFormat create(int width,
- int height,
- int colorspace,
- int target) {
- return create(width,
- height,
- colorspace,
- bytesPerSampleForColorspace(colorspace),
- target);
- }
-
- public static MutableFrameFormat create(int colorspace, int target) {
- return create(FrameFormat.SIZE_UNSPECIFIED,
- FrameFormat.SIZE_UNSPECIFIED,
- colorspace,
- bytesPerSampleForColorspace(colorspace),
- target);
- }
-
- public static MutableFrameFormat create(int colorspace) {
- return create(FrameFormat.SIZE_UNSPECIFIED,
- FrameFormat.SIZE_UNSPECIFIED,
- colorspace,
- bytesPerSampleForColorspace(colorspace),
- FrameFormat.TARGET_UNSPECIFIED);
- }
-
- public static int bytesPerSampleForColorspace(int colorspace) {
- switch (colorspace) {
- case COLORSPACE_GRAY:
- return 1;
- case COLORSPACE_RGB:
- return 3;
- case COLORSPACE_RGBA:
- return 4;
- case COLORSPACE_YUV:
- return 3;
- default:
- throw new RuntimeException("Unknown colorspace id " + colorspace + "!");
- }
- }
-}
+++ /dev/null
-/*
- * 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.format;
-
-import android.filterfw.core.FrameFormat;
-import android.filterfw.core.MutableFrameFormat;
-import android.filterfw.core.NativeBuffer;
-
-/**
- * @hide
- */
-public class ObjectFormat {
-
- public static MutableFrameFormat fromClass(Class clazz, int count, int target) {
- // Create frame format
- MutableFrameFormat result = new MutableFrameFormat(FrameFormat.TYPE_OBJECT, target);
- result.setObjectClass(getBoxedClass(clazz));
- if (count != FrameFormat.SIZE_UNSPECIFIED) {
- result.setDimensions(count);
- }
- result.setBytesPerSample(bytesPerSampleForClass(clazz, target));
- return result;
- }
-
- public static MutableFrameFormat fromClass(Class clazz, int target) {
- return fromClass(clazz, FrameFormat.SIZE_UNSPECIFIED, target);
- }
-
- public static MutableFrameFormat fromObject(Object object, int target) {
- return object == null
- ? new MutableFrameFormat(FrameFormat.TYPE_OBJECT, target)
- : fromClass(object.getClass(), FrameFormat.SIZE_UNSPECIFIED, target);
- }
-
- public static MutableFrameFormat fromObject(Object object, int count, int target) {
- return object == null
- ? new MutableFrameFormat(FrameFormat.TYPE_OBJECT, target)
- : fromClass(object.getClass(), count, target);
- }
-
- private static int bytesPerSampleForClass(Class clazz, int target) {
- // Native targets have objects manifested in a byte buffer. Thus it is important to
- // correctly determine the size of single element here.
- if (target == FrameFormat.TARGET_NATIVE) {
- if (!NativeBuffer.class.isAssignableFrom(clazz)) {
- throw new IllegalArgumentException("Native object-based formats must be of a " +
- "NativeBuffer subclass! (Received class: " + clazz + ").");
- }
- try {
- return ((NativeBuffer)clazz.newInstance()).getElementSize();
- } catch (Exception e) {
- throw new RuntimeException("Could not determine the size of an element in a "
- + "native object-based frame of type " + clazz + "! Perhaps it is missing a "
- + "default constructor?");
- }
- } else {
- return FrameFormat.BYTES_PER_SAMPLE_UNSPECIFIED;
- }
- }
-
- private static Class getBoxedClass(Class type) {
- // Check if type is primitive
- if (type.isPrimitive()) {
- // Yes -> box it
- if (type == boolean.class) {
- return java.lang.Boolean.class;
- } else if (type == byte.class) {
- return java.lang.Byte.class;
- } else if (type == char.class) {
- return java.lang.Character.class;
- } else if (type == short.class) {
- return java.lang.Short.class;
- } else if (type == int.class) {
- return java.lang.Integer.class;
- } else if (type == long.class) {
- return java.lang.Long.class;
- } else if (type == float.class) {
- return java.lang.Float.class;
- } else if (type == double.class) {
- return java.lang.Double.class;
- } else {
- throw new IllegalArgumentException(
- "Unknown primitive type: " + type.getSimpleName() + "!");
- }
- } else {
- // No -> return it
- return type;
- }
- }
-}
+++ /dev/null
-/*
- * 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.format;
-
-import android.filterfw.core.FrameFormat;
-import android.filterfw.core.MutableFrameFormat;
-
-/**
- * @hide
- */
-public class PrimitiveFormat {
-
- public static MutableFrameFormat createByteFormat(int count, int target) {
- return createFormat(FrameFormat.TYPE_BYTE, count, target);
- }
-
- public static MutableFrameFormat createInt16Format(int count, int target) {
- return createFormat(FrameFormat.TYPE_INT16, count, target);
- }
-
- public static MutableFrameFormat createInt32Format(int count, int target) {
- return createFormat(FrameFormat.TYPE_INT32, count, target);
- }
-
- public static MutableFrameFormat createFloatFormat(int count, int target) {
- return createFormat(FrameFormat.TYPE_FLOAT, count, target);
- }
-
- public static MutableFrameFormat createDoubleFormat(int count, int target) {
- return createFormat(FrameFormat.TYPE_DOUBLE, count, target);
- }
-
- public static MutableFrameFormat createByteFormat(int target) {
- return createFormat(FrameFormat.TYPE_BYTE, target);
- }
-
- public static MutableFrameFormat createInt16Format(int target) {
- return createFormat(FrameFormat.TYPE_INT16, target);
- }
-
- public static MutableFrameFormat createInt32Format(int target) {
- return createFormat(FrameFormat.TYPE_INT32, target);
- }
-
- public static MutableFrameFormat createFloatFormat(int target) {
- return createFormat(FrameFormat.TYPE_FLOAT, target);
- }
-
- public static MutableFrameFormat createDoubleFormat(int target) {
- return createFormat(FrameFormat.TYPE_DOUBLE, target);
- }
-
- private static MutableFrameFormat createFormat(int baseType, int count, int target) {
- MutableFrameFormat result = new MutableFrameFormat(baseType, target);
- result.setDimensions(count);
- return result;
- }
-
- private static MutableFrameFormat createFormat(int baseType, int target) {
- MutableFrameFormat result = new MutableFrameFormat(baseType, target);
- result.setDimensionCount(1);
- return result;
- }
-}
+++ /dev/null
-/**
- * @hide
- */
-package android.filterfw.format;
+++ /dev/null
-/*
- * 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.geometry;
-
-import java.lang.Math;
-
-/**
- * @hide
- */
-public class Point {
-
- public float x;
- public float y;
-
- public Point() {
- }
-
- public Point(float x, float y) {
- this.x = x;
- this.y = y;
- }
-
- public void set(float x, float y) {
- this.x = x;
- this.y = y;
- }
-
- public boolean IsInUnitRange() {
- return x >= 0.0f && x <= 1.0f &&
- y >= 0.0f && y <= 1.0f;
- }
-
- public Point plus(float x, float y) {
- return new Point(this.x + x, this.y + y);
- }
-
- public Point plus(Point point) {
- return this.plus(point.x, point.y);
- }
-
- public Point minus(float x, float y) {
- return new Point(this.x - x, this.y - y);
- }
-
- public Point minus(Point point) {
- return this.minus(point.x, point.y);
- }
-
- public Point times(float s) {
- return new Point(this.x * s, this.y * s);
- }
-
- public Point mult(float x, float y) {
- return new Point(this.x * x, this.y * y);
- }
-
- public float length() {
- return (float)Math.sqrt(x*x + y*y);
- }
-
- public float distanceTo(Point p) {
- return p.minus(this).length();
- }
-
- public Point scaledTo(float length) {
- return this.times(length / this.length());
- }
-
- public Point normalize() {
- return this.scaledTo(1.0f);
- }
-
- public Point rotated90(int count) {
- float nx = this.x;
- float ny = this.y;
- for (int i = 0; i < count; ++i) {
- float ox = nx;
- nx = ny;
- ny = -ox;
- }
- return new Point(nx, ny);
- }
-
- public Point rotated(float radians) {
- // TODO(renn): Optimize: Keep cache of cos/sin values
- return new Point((float)(Math.cos(radians) * x - Math.sin(radians) * y),
- (float)(Math.sin(radians) * x + Math.cos(radians) * y));
- }
-
- public Point rotatedAround(Point center, float radians) {
- return this.minus(center).rotated(radians).plus(center);
- }
-
- @Override
- public String toString() {
- return "(" + x + ", " + y + ")";
- }
-}
+++ /dev/null
-/*
- * 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.geometry;
-
-import android.filterfw.geometry.Point;
-
-import java.lang.Float;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.List;
-
-/**
- * @hide
- */
-public class Quad {
-
- public Point p0;
- public Point p1;
- public Point p2;
- public Point p3;
-
- public Quad() {
- }
-
- public Quad(Point p0, Point p1, Point p2, Point p3) {
- this.p0 = p0;
- this.p1 = p1;
- this.p2 = p2;
- this.p3 = p3;
- }
-
- public boolean IsInUnitRange() {
- return p0.IsInUnitRange() &&
- p1.IsInUnitRange() &&
- p2.IsInUnitRange() &&
- p3.IsInUnitRange();
- }
-
- public Quad translated(Point t) {
- return new Quad(p0.plus(t), p1.plus(t), p2.plus(t), p3.plus(t));
- }
-
- public Quad translated(float x, float y) {
- return new Quad(p0.plus(x, y), p1.plus(x, y), p2.plus(x, y), p3.plus(x, y));
- }
-
- public Quad scaled(float s) {
- return new Quad(p0.times(s), p1.times(s), p2.times(s), p3.times(s));
- }
-
- public Quad scaled(float x, float y) {
- return new Quad(p0.mult(x, y), p1.mult(x, y), p2.mult(x, y), p3.mult(x, y));
- }
-
- public Rectangle boundingBox() {
- List<Float> xs = Arrays.asList(p0.x, p1.x, p2.x, p3.x);
- List<Float> ys = Arrays.asList(p0.y, p1.y, p2.y, p3.y);
- float x0 = Collections.min(xs);
- float y0 = Collections.min(ys);
- float x1 = Collections.max(xs);
- float y1 = Collections.max(ys);
- return new Rectangle(x0, y0, x1 - x0, y1 - y0);
- }
-
- public float getBoundingWidth() {
- List<Float> xs = Arrays.asList(p0.x, p1.x, p2.x, p3.x);
- return Collections.max(xs) - Collections.min(xs);
- }
-
- public float getBoundingHeight() {
- List<Float> ys = Arrays.asList(p0.y, p1.y, p2.y, p3.y);
- return Collections.max(ys) - Collections.min(ys);
- }
-
- @Override
- public String toString() {
- return "{" + p0 + ", " + p1 + ", " + p2 + ", " + p3 + "}";
- }
-}
+++ /dev/null
-/*
- * 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.geometry;
-
-import android.filterfw.geometry.Point;
-import android.filterfw.geometry.Quad;
-
-/**
- * @hide
- */
-public class Rectangle extends Quad {
-
- public Rectangle() {
- }
-
- public Rectangle(float x, float y, float width, float height) {
- super(new Point(x, y),
- new Point(x + width, y),
- new Point(x, y + height),
- new Point(x + width, y + height));
- }
-
- public Rectangle(Point origin, Point size) {
- super(origin,
- origin.plus(size.x, 0.0f),
- origin.plus(0.0f, size.y),
- origin.plus(size.x, size.y));
- }
-
- public static Rectangle fromRotatedRect(Point center, Point size, float rotation) {
- Point p0 = new Point(center.x - size.x/2f, center.y - size.y/2f);
- Point p1 = new Point(center.x + size.x/2f, center.y - size.y/2f);
- Point p2 = new Point(center.x - size.x/2f, center.y + size.y/2f);
- Point p3 = new Point(center.x + size.x/2f, center.y + size.y/2f);
- return new Rectangle(p0.rotatedAround(center, rotation),
- p1.rotatedAround(center, rotation),
- p2.rotatedAround(center, rotation),
- p3.rotatedAround(center, rotation));
- }
-
- private Rectangle(Point p0, Point p1, Point p2, Point p3) {
- super(p0, p1, p2, p3);
- }
-
- public static Rectangle fromCenterVerticalAxis(Point center, Point vAxis, Point size) {
- Point dy = vAxis.scaledTo(size.y / 2.0f);
- Point dx = vAxis.rotated90(1).scaledTo(size.x / 2.0f);
- return new Rectangle(center.minus(dx).minus(dy),
- center.plus(dx).minus(dy),
- center.minus(dx).plus(dy),
- center.plus(dx).plus(dy));
- }
-
- public float getWidth() {
- return p1.minus(p0).length();
- }
-
- public float getHeight() {
- return p2.minus(p0).length();
- }
-
- public Point center() {
- return p0.plus(p1).plus(p2).plus(p3).times(0.25f);
- }
-
- @Override
- public Rectangle scaled(float s) {
- return new Rectangle(p0.times(s), p1.times(s), p2.times(s), p3.times(s));
- }
-
- @Override
- public Rectangle scaled(float x, float y) {
- return new Rectangle(p0.mult(x, y), p1.mult(x, y), p2.mult(x, y), p3.mult(x, y));
- }
-
- //public Rectangle rotated(float radians) {
- // TODO: Implement this.
- //}
-
-}
+++ /dev/null
-/**
- * @hide
- */
-package android.filterfw.geometry;
+++ /dev/null
-/*
- * 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.io;
-
-/**
- * @hide
- */
-public class GraphIOException extends Exception {
-
- public GraphIOException() {
- super();
- }
-
- public GraphIOException(String message) {
- super(message);
- }
-
-}
+++ /dev/null
-/*
- * 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.io;
-
-import android.content.Context;
-import android.filterfw.core.FilterGraph;
-import android.filterfw.core.KeyValueMap;
-import android.filterfw.io.GraphIOException;
-
-import java.io.InputStream;
-import java.io.InputStreamReader;
-import java.io.IOException;
-import java.io.StringWriter;
-
-/**
- * @hide
- */
-public abstract class GraphReader {
-
- protected KeyValueMap mReferences = new KeyValueMap();
-
- public abstract FilterGraph readGraphString(String graphString) throws GraphIOException;
-
- public abstract KeyValueMap readKeyValueAssignments(String assignments) throws GraphIOException;
-
- public FilterGraph readGraphResource(Context context, int resourceId) throws GraphIOException {
- InputStream inputStream = context.getResources().openRawResource(resourceId);
- InputStreamReader reader = new InputStreamReader(inputStream);
- StringWriter writer = new StringWriter();
- char[] buffer = new char[1024];
- try {
- int bytesRead;
- while ((bytesRead = reader.read(buffer, 0, 1024)) > 0) {
- writer.write(buffer, 0, bytesRead);
- }
- } catch (IOException e) {
- throw new RuntimeException("Could not read specified resource file!");
- }
- return readGraphString(writer.toString());
- }
-
- public void addReference(String name, Object object) {
- mReferences.put(name, object);
- }
-
- public void addReferencesByMap(KeyValueMap refs) {
- mReferences.putAll(refs);
- }
-
- public void addReferencesByKeysAndValues(Object... references) {
- mReferences.setKeyValues(references);
- }
-
-}
+++ /dev/null
-/*
- * 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.io;
-
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
-
-/**
- * @hide
- */
-public class PatternScanner {
-
- private String mInput;
- private Pattern mIgnorePattern;
- private int mOffset = 0;
- private int mLineNo = 0;
- private int mStartOfLine = 0;
-
- public PatternScanner(String input) {
- mInput = input;
- }
-
- public PatternScanner(String input, Pattern ignorePattern) {
- mInput = input;
- mIgnorePattern = ignorePattern;
- skip(mIgnorePattern);
- }
-
- public String tryEat(Pattern pattern) {
- // Skip ignore pattern
- if (mIgnorePattern != null) {
- skip(mIgnorePattern);
- }
-
- // Create the matcher
- Matcher matcher = pattern.matcher(mInput);
- matcher.region(mOffset, mInput.length());
-
- // Attempt to match
- String result = null;
- if (matcher.lookingAt()) {
- updateLineCount(mOffset, matcher.end());
- mOffset = matcher.end();
- result = mInput.substring(matcher.start(), matcher.end());
- }
-
- // Skip ignore pattern
- if (result != null && mIgnorePattern != null) {
- skip(mIgnorePattern);
- }
-
- return result;
- }
-
- public String eat(Pattern pattern, String tokenName) {
- String result = tryEat(pattern);
- if (result == null) {
- throw new RuntimeException(unexpectedTokenMessage(tokenName));
- }
- return result;
- }
-
- public boolean peek(Pattern pattern) {
- // Skip ignore pattern
- if (mIgnorePattern != null) {
- skip(mIgnorePattern);
- }
-
- // Create the matcher
- Matcher matcher = pattern.matcher(mInput);
- matcher.region(mOffset, mInput.length());
-
- // Attempt to match
- return matcher.lookingAt();
- }
-
- public void skip(Pattern pattern) {
- Matcher matcher = pattern.matcher(mInput);
- matcher.region(mOffset, mInput.length());
- if (matcher.lookingAt()) {
- updateLineCount(mOffset, matcher.end());
- mOffset = matcher.end();
- }
- }
-
- public boolean atEnd() {
- return mOffset >= mInput.length();
- }
-
- public int lineNo() {
- return mLineNo;
- }
-
- public String unexpectedTokenMessage(String tokenName) {
- String line = mInput.substring(mStartOfLine, mOffset);
- return "Unexpected token on line " + (mLineNo + 1) + " after '" + line + "' <- Expected " +
- tokenName + "!";
- }
-
- public void updateLineCount(int start, int end) {
- for (int i = start; i < end; ++i) {
- if (mInput.charAt(i) == '\n') {
- ++mLineNo;
- mStartOfLine = i + 1;
- }
- }
- }
-}
+++ /dev/null
-/*
- * 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.io;
-
-import java.lang.Float;
-import java.lang.Integer;
-import java.lang.String;
-
-import java.util.ArrayList;
-import java.util.regex.Pattern;
-
-import android.filterfw.core.Filter;
-import android.filterfw.core.FilterFactory;
-import android.filterfw.core.FilterGraph;
-import android.filterfw.core.KeyValueMap;
-import android.filterfw.core.ProtocolException;
-import android.filterfw.io.GraphReader;
-import android.filterfw.io.GraphIOException;
-import android.filterfw.io.PatternScanner;
-
-/**
- * @hide
- */
-public class TextGraphReader extends GraphReader {
-
- private ArrayList<Command> mCommands = new ArrayList<Command>();
- private Filter mCurrentFilter;
- private FilterGraph mCurrentGraph;
- private KeyValueMap mBoundReferences;
- private KeyValueMap mSettings;
- private FilterFactory mFactory;
-
- private interface Command {
- public void execute(TextGraphReader reader) throws GraphIOException;
- }
-
- private class ImportPackageCommand implements Command {
- private String mPackageName;
-
- public ImportPackageCommand(String packageName) {
- mPackageName = packageName;
- }
-
- @Override
- public void execute(TextGraphReader reader) throws GraphIOException {
- try {
- reader.mFactory.addPackage(mPackageName);
- } catch (IllegalArgumentException e) {
- throw new GraphIOException(e.getMessage());
- }
- }
- }
-
- private class AddLibraryCommand implements Command {
- private String mLibraryName;
-
- public AddLibraryCommand(String libraryName) {
- mLibraryName = libraryName;
- }
-
- @Override
- public void execute(TextGraphReader reader) {
- reader.mFactory.addFilterLibrary(mLibraryName);
- }
- }
-
- private class AllocateFilterCommand implements Command {
- private String mClassName;
- private String mFilterName;
-
- public AllocateFilterCommand(String className, String filterName) {
- mClassName = className;
- mFilterName = filterName;
- }
-
- public void execute(TextGraphReader reader) throws GraphIOException {
- // Create the filter
- Filter filter = null;
- try {
- filter = reader.mFactory.createFilterByClassName(mClassName, mFilterName);
- } catch (IllegalArgumentException e) {
- throw new GraphIOException(e.getMessage());
- }
-
- // Set it as the current filter
- reader.mCurrentFilter = filter;
- }
- }
-
- private class InitFilterCommand implements Command {
- private KeyValueMap mParams;
-
- public InitFilterCommand(KeyValueMap params) {
- mParams = params;
- }
-
- @Override
- public void execute(TextGraphReader reader) throws GraphIOException {
- Filter filter = reader.mCurrentFilter;
- try {
- filter.initWithValueMap(mParams);
- } catch (ProtocolException e) {
- throw new GraphIOException(e.getMessage());
- }
- reader.mCurrentGraph.addFilter(mCurrentFilter);
- }
- }
-
- private class ConnectCommand implements Command {
- private String mSourceFilter;
- private String mSourcePort;
- private String mTargetFilter;
- private String mTargetName;
-
- public ConnectCommand(String sourceFilter,
- String sourcePort,
- String targetFilter,
- String targetName) {
- mSourceFilter = sourceFilter;
- mSourcePort = sourcePort;
- mTargetFilter = targetFilter;
- mTargetName = targetName;
- }
-
- @Override
- public void execute(TextGraphReader reader) {
- reader.mCurrentGraph.connect(mSourceFilter, mSourcePort, mTargetFilter, mTargetName);
- }
- }
-
- @Override
- public FilterGraph readGraphString(String graphString) throws GraphIOException {
- FilterGraph result = new FilterGraph();
-
- reset();
- mCurrentGraph = result;
- parseString(graphString);
- applySettings();
- executeCommands();
- reset();
-
- return result;
- }
-
- private void reset() {
- mCurrentGraph = null;
- mCurrentFilter = null;
- mCommands.clear();
- mBoundReferences = new KeyValueMap();
- mSettings = new KeyValueMap();
- mFactory = new FilterFactory();
- }
-
- private void parseString(String graphString) throws GraphIOException {
- final Pattern commandPattern = Pattern.compile("@[a-zA-Z]+");
- final Pattern curlyClosePattern = Pattern.compile("\\}");
- final Pattern curlyOpenPattern = Pattern.compile("\\{");
- final Pattern ignorePattern = Pattern.compile("(\\s+|//[^\\n]*\\n)+");
- final Pattern packageNamePattern = Pattern.compile("[a-zA-Z\\.]+");
- final Pattern libraryNamePattern = Pattern.compile("[a-zA-Z\\./:]+");
- final Pattern portPattern = Pattern.compile("\\[[a-zA-Z0-9\\-_]+\\]");
- final Pattern rightArrowPattern = Pattern.compile("=>");
- final Pattern semicolonPattern = Pattern.compile(";");
- final Pattern wordPattern = Pattern.compile("[a-zA-Z0-9\\-_]+");
-
- final int STATE_COMMAND = 0;
- final int STATE_IMPORT_PKG = 1;
- final int STATE_ADD_LIBRARY = 2;
- final int STATE_FILTER_CLASS = 3;
- final int STATE_FILTER_NAME = 4;
- final int STATE_CURLY_OPEN = 5;
- final int STATE_PARAMETERS = 6;
- final int STATE_CURLY_CLOSE = 7;
- final int STATE_SOURCE_FILTERNAME = 8;
- final int STATE_SOURCE_PORT = 9;
- final int STATE_RIGHT_ARROW = 10;
- final int STATE_TARGET_FILTERNAME = 11;
- final int STATE_TARGET_PORT = 12;
- final int STATE_ASSIGNMENT = 13;
- final int STATE_EXTERNAL = 14;
- final int STATE_SETTING = 15;
- final int STATE_SEMICOLON = 16;
-
- int state = STATE_COMMAND;
- PatternScanner scanner = new PatternScanner(graphString, ignorePattern);
-
- String curClassName = null;
- String curSourceFilterName = null;
- String curSourcePortName = null;
- String curTargetFilterName = null;
- String curTargetPortName = null;
-
- // State machine main loop
- while (!scanner.atEnd()) {
- switch (state) {
- case STATE_COMMAND: {
- String curCommand = scanner.eat(commandPattern, "<command>");
- if (curCommand.equals("@import")) {
- state = STATE_IMPORT_PKG;
- } else if (curCommand.equals("@library")) {
- state = STATE_ADD_LIBRARY;
- } else if (curCommand.equals("@filter")) {
- state = STATE_FILTER_CLASS;
- } else if (curCommand.equals("@connect")) {
- state = STATE_SOURCE_FILTERNAME;
- } else if (curCommand.equals("@set")) {
- state = STATE_ASSIGNMENT;
- } else if (curCommand.equals("@external")) {
- state = STATE_EXTERNAL;
- } else if (curCommand.equals("@setting")) {
- state = STATE_SETTING;
- } else {
- throw new GraphIOException("Unknown command '" + curCommand + "'!");
- }
- break;
- }
-
- case STATE_IMPORT_PKG: {
- String packageName = scanner.eat(packageNamePattern, "<package-name>");
- mCommands.add(new ImportPackageCommand(packageName));
- state = STATE_SEMICOLON;
- break;
- }
-
- case STATE_ADD_LIBRARY: {
- String libraryName = scanner.eat(libraryNamePattern, "<library-name>");
- mCommands.add(new AddLibraryCommand(libraryName));
- state = STATE_SEMICOLON;
- break;
- }
-
- case STATE_FILTER_CLASS:
- curClassName = scanner.eat(wordPattern, "<class-name>");
- state = STATE_FILTER_NAME;
- break;
-
- case STATE_FILTER_NAME: {
- String curFilterName = scanner.eat(wordPattern, "<filter-name>");
- mCommands.add(new AllocateFilterCommand(curClassName, curFilterName));
- state = STATE_CURLY_OPEN;
- break;
- }
-
- case STATE_CURLY_OPEN:
- scanner.eat(curlyOpenPattern, "{");
- state = STATE_PARAMETERS;
- break;
-
- case STATE_PARAMETERS: {
- KeyValueMap params = readKeyValueAssignments(scanner, curlyClosePattern);
- mCommands.add(new InitFilterCommand(params));
- state = STATE_CURLY_CLOSE;
- break;
- }
-
- case STATE_CURLY_CLOSE:
- scanner.eat(curlyClosePattern, "}");
- state = STATE_COMMAND;
- break;
-
- case STATE_SOURCE_FILTERNAME:
- curSourceFilterName = scanner.eat(wordPattern, "<source-filter-name>");
- state = STATE_SOURCE_PORT;
- break;
-
- case STATE_SOURCE_PORT: {
- String portString = scanner.eat(portPattern, "[<source-port-name>]");
- curSourcePortName = portString.substring(1, portString.length() - 1);
- state = STATE_RIGHT_ARROW;
- break;
- }
-
- case STATE_RIGHT_ARROW:
- scanner.eat(rightArrowPattern, "=>");
- state = STATE_TARGET_FILTERNAME;
- break;
-
- case STATE_TARGET_FILTERNAME:
- curTargetFilterName = scanner.eat(wordPattern, "<target-filter-name>");
- state = STATE_TARGET_PORT;
- break;
-
- case STATE_TARGET_PORT: {
- String portString = scanner.eat(portPattern, "[<target-port-name>]");
- curTargetPortName = portString.substring(1, portString.length() - 1);
- mCommands.add(new ConnectCommand(curSourceFilterName,
- curSourcePortName,
- curTargetFilterName,
- curTargetPortName));
- state = STATE_SEMICOLON;
- break;
- }
-
- case STATE_ASSIGNMENT: {
- KeyValueMap assignment = readKeyValueAssignments(scanner, semicolonPattern);
- mBoundReferences.putAll(assignment);
- state = STATE_SEMICOLON;
- break;
- }
-
- case STATE_EXTERNAL: {
- String externalName = scanner.eat(wordPattern, "<external-identifier>");
- bindExternal(externalName);
- state = STATE_SEMICOLON;
- break;
- }
-
- case STATE_SETTING: {
- KeyValueMap setting = readKeyValueAssignments(scanner, semicolonPattern);
- mSettings.putAll(setting);
- state = STATE_SEMICOLON;
- break;
- }
-
- case STATE_SEMICOLON:
- scanner.eat(semicolonPattern, ";");
- state = STATE_COMMAND;
- break;
- }
- }
-
- // Make sure end of input was expected
- if (state != STATE_SEMICOLON && state != STATE_COMMAND) {
- throw new GraphIOException("Unexpected end of input!");
- }
- }
-
- @Override
- public KeyValueMap readKeyValueAssignments(String assignments) throws GraphIOException {
- final Pattern ignorePattern = Pattern.compile("\\s+");
- PatternScanner scanner = new PatternScanner(assignments, ignorePattern);
- return readKeyValueAssignments(scanner, null);
- }
-
- private KeyValueMap readKeyValueAssignments(PatternScanner scanner,
- Pattern endPattern) throws GraphIOException {
- // Our parser is a state-machine, and these are our states
- final int STATE_IDENTIFIER = 0;
- final int STATE_EQUALS = 1;
- final int STATE_VALUE = 2;
- final int STATE_POST_VALUE = 3;
-
- final Pattern equalsPattern = Pattern.compile("=");
- final Pattern semicolonPattern = Pattern.compile(";");
- final Pattern wordPattern = Pattern.compile("[a-zA-Z]+[a-zA-Z0-9]*");
- final Pattern stringPattern = Pattern.compile("'[^']*'|\\\"[^\\\"]*\\\"");
- final Pattern intPattern = Pattern.compile("[0-9]+");
- final Pattern floatPattern = Pattern.compile("[0-9]*\\.[0-9]+f?");
- final Pattern referencePattern = Pattern.compile("\\$[a-zA-Z]+[a-zA-Z0-9]");
- final Pattern booleanPattern = Pattern.compile("true|false");
-
- int state = STATE_IDENTIFIER;
- KeyValueMap newVals = new KeyValueMap();
- String curKey = null;
- String curValue = null;
-
- while (!scanner.atEnd() && !(endPattern != null && scanner.peek(endPattern))) {
- switch (state) {
- case STATE_IDENTIFIER:
- curKey = scanner.eat(wordPattern, "<identifier>");
- state = STATE_EQUALS;
- break;
-
- case STATE_EQUALS:
- scanner.eat(equalsPattern, "=");
- state = STATE_VALUE;
- break;
-
- case STATE_VALUE:
- if ((curValue = scanner.tryEat(stringPattern)) != null) {
- newVals.put(curKey, curValue.substring(1, curValue.length() - 1));
- } else if ((curValue = scanner.tryEat(referencePattern)) != null) {
- String refName = curValue.substring(1, curValue.length());
- Object referencedObject = mBoundReferences != null
- ? mBoundReferences.get(refName)
- : null;
- if (referencedObject == null) {
- throw new GraphIOException(
- "Unknown object reference to '" + refName + "'!");
- }
- newVals.put(curKey, referencedObject);
- } else if ((curValue = scanner.tryEat(booleanPattern)) != null) {
- newVals.put(curKey, Boolean.parseBoolean(curValue));
- } else if ((curValue = scanner.tryEat(floatPattern)) != null) {
- newVals.put(curKey, Float.parseFloat(curValue));
- } else if ((curValue = scanner.tryEat(intPattern)) != null) {
- newVals.put(curKey, Integer.parseInt(curValue));
- } else {
- throw new GraphIOException(scanner.unexpectedTokenMessage("<value>"));
- }
- state = STATE_POST_VALUE;
- break;
-
- case STATE_POST_VALUE:
- scanner.eat(semicolonPattern, ";");
- state = STATE_IDENTIFIER;
- break;
- }
- }
-
- // Make sure end is expected
- if (state != STATE_IDENTIFIER && state != STATE_POST_VALUE) {
- throw new GraphIOException(
- "Unexpected end of assignments on line " + scanner.lineNo() + "!");
- }
-
- return newVals;
- }
-
- private void bindExternal(String name) throws GraphIOException {
- if (mReferences.containsKey(name)) {
- Object value = mReferences.get(name);
- mBoundReferences.put(name, value);
- } else {
- throw new GraphIOException("Unknown external variable '" + name + "'! "
- + "You must add a reference to this external in the host program using "
- + "addReference(...)!");
- }
- }
-
- /**
- * Unused for now: Often you may want to declare references that are NOT in a certain graph,
- * e.g. when reading multiple graphs with the same reader. We could print a warning, but even
- * that may be too much.
- **/
- private void checkReferences() throws GraphIOException {
- for (String reference : mReferences.keySet()) {
- if (!mBoundReferences.containsKey(reference)) {
- throw new GraphIOException(
- "Host program specifies reference to '" + reference + "', which is not "
- + "declared @external in graph file!");
- }
- }
- }
-
- private void applySettings() throws GraphIOException {
- for (String setting : mSettings.keySet()) {
- Object value = mSettings.get(setting);
- if (setting.equals("autoBranch")) {
- expectSettingClass(setting, value, String.class);
- if (value.equals("synced")) {
- mCurrentGraph.setAutoBranchMode(FilterGraph.AUTOBRANCH_SYNCED);
- } else if (value.equals("unsynced")) {
- mCurrentGraph.setAutoBranchMode(FilterGraph.AUTOBRANCH_UNSYNCED);
- } else if (value.equals("off")) {
- mCurrentGraph.setAutoBranchMode(FilterGraph.AUTOBRANCH_OFF);
- } else {
- throw new GraphIOException("Unknown autobranch setting: " + value + "!");
- }
- } else if (setting.equals("discardUnconnectedOutputs")) {
- expectSettingClass(setting, value, Boolean.class);
- mCurrentGraph.setDiscardUnconnectedOutputs((Boolean)value);
- } else {
- throw new GraphIOException("Unknown @setting '" + setting + "'!");
- }
- }
- }
-
- private void expectSettingClass(String setting,
- Object value,
- Class expectedClass) throws GraphIOException {
- if (value.getClass() != expectedClass) {
- throw new GraphIOException("Setting '" + setting + "' must have a value of type "
- + expectedClass.getSimpleName() + ", but found a value of type "
- + value.getClass().getSimpleName() + "!");
- }
- }
-
- private void executeCommands() throws GraphIOException {
- for (Command command : mCommands) {
- command.execute(this);
- }
- }
-}
+++ /dev/null
-/**
- * @hide
- */
-package android.filterfw.io;
+++ /dev/null
-# 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.
-#
-
-LOCAL_PATH := $(call my-dir)
-
-#####################
-# Build module libfilterfw_jni
-include $(CLEAR_VARS)
-
-LOCAL_MODULE_TAGS := optional
-
-LOCAL_MODULE = libfilterfw_jni
-
-LOCAL_SRC_FILES = jni_init.cpp \
- jni_gl_environment.cpp \
- jni_gl_frame.cpp \
- jni_native_buffer.cpp \
- jni_native_frame.cpp \
- jni_native_program.cpp \
- jni_shader_program.cpp \
- jni_util.cpp \
- jni_vertex_frame.cpp
-
-# Need FilterFW lib
-include $(LOCAL_PATH)/../native/libfilterfw.mk
-
-# Also need the JNI headers.
-LOCAL_C_INCLUDES += \
- $(JNI_H_INCLUDE) \
- $(LOCAL_PATH)/..
-
-# Don't prelink this library. For more efficient code, you may want
-# to add this library to the prelink map and set this to true. However,
-# it's difficult to do this for applications that are not supplied as
-# part of a system image.
-LOCAL_PRELINK_MODULE := false
-
-include $(BUILD_STATIC_LIBRARY)
-
+++ /dev/null
-/*
- * 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.
- */
-// #define LOG_NDEBUG 0
-
-#include <stdint.h>
-#include <android/native_window_jni.h>
-
-#include "jni/jni_gl_environment.h"
-#include "jni/jni_util.h"
-#include <media/mediarecorder.h>
-#include "native/core/gl_env.h"
-
-#include <gui/ISurfaceTexture.h>
-#include <gui/SurfaceTextureClient.h>
-#include <utils/Errors.h>
-#include <system/window.h>
-
-
-using android::filterfw::GLEnv;
-using android::filterfw::WindowHandle;
-using android::MediaRecorder;
-using android::sp;
-using android::ISurfaceTexture;
-using android::SurfaceTextureClient;
-
-
-class NativeWindowHandle : public WindowHandle {
- public:
- NativeWindowHandle(ANativeWindow* window) : window_(window) {
- }
-
- virtual ~NativeWindowHandle() {
- }
-
- virtual void Destroy() {
- ALOGI("Releasing ANativeWindow!");
- ANativeWindow_release(window_);
- }
-
- virtual const void* InternalHandle() const {
- return window_;
- }
-
- virtual void* InternalHandle() {
- return window_;
- }
-
- private:
- ANativeWindow* window_;
-};
-
-jboolean Java_android_filterfw_core_GLEnvironment_nativeAllocate(JNIEnv* env, jobject thiz) {
- return ToJBool(WrapObjectInJava(new GLEnv(), env, thiz, true));
-}
-
-jboolean Java_android_filterfw_core_GLEnvironment_nativeDeallocate(JNIEnv* env, jobject thiz) {
- return ToJBool(DeleteNativeObject<GLEnv>(env, thiz));
-}
-
-jboolean Java_android_filterfw_core_GLEnvironment_nativeInitWithNewContext(JNIEnv* env,
- jobject thiz) {
- GLEnv* gl_env = ConvertFromJava<GLEnv>(env, thiz);
- return gl_env ? ToJBool(gl_env->InitWithNewContext()) : JNI_FALSE;
-}
-
-jboolean Java_android_filterfw_core_GLEnvironment_nativeInitWithCurrentContext(JNIEnv* env,
- jobject thiz) {
- GLEnv* gl_env = ConvertFromJava<GLEnv>(env, thiz);
- return gl_env ? ToJBool(gl_env->InitWithCurrentContext()) : JNI_FALSE;
-}
-
-jboolean Java_android_filterfw_core_GLEnvironment_nativeIsActive(JNIEnv* env, jobject thiz) {
- GLEnv* gl_env = ConvertFromJava<GLEnv>(env, thiz);
- return gl_env ? ToJBool(gl_env->IsActive()) : JNI_FALSE;
-}
-
-jboolean Java_android_filterfw_core_GLEnvironment_nativeIsContextActive(JNIEnv* env, jobject thiz) {
- GLEnv* gl_env = ConvertFromJava<GLEnv>(env, thiz);
- return gl_env ? ToJBool(gl_env->IsContextActive()) : JNI_FALSE;
-}
-
-jboolean Java_android_filterfw_core_GLEnvironment_nativeIsAnyContextActive(JNIEnv* env,
- jclass clazz) {
- return ToJBool(GLEnv::IsAnyContextActive());
-}
-
-jboolean Java_android_filterfw_core_GLEnvironment_nativeActivate(JNIEnv* env, jobject thiz) {
- GLEnv* gl_env = ConvertFromJava<GLEnv>(env, thiz);
- return gl_env ? ToJBool(gl_env->Activate()) : JNI_FALSE;
-}
-
-jboolean Java_android_filterfw_core_GLEnvironment_nativeDeactivate(JNIEnv* env, jobject thiz) {
- GLEnv* gl_env = ConvertFromJava<GLEnv>(env, thiz);
- return gl_env ? ToJBool(gl_env->Deactivate()) : JNI_FALSE;
-}
-
-jboolean Java_android_filterfw_core_GLEnvironment_nativeSwapBuffers(JNIEnv* env, jobject thiz) {
- GLEnv* gl_env = ConvertFromJava<GLEnv>(env, thiz);
- return gl_env ? ToJBool(gl_env->SwapBuffers()) : JNI_FALSE;
-}
-
-// Get the native mediarecorder object corresponding to the java object
-static sp<MediaRecorder> getMediaRecorder(JNIEnv* env, jobject jmediarecorder) {
- jclass clazz = env->FindClass("android/media/MediaRecorder");
- if (clazz == NULL) {
- return NULL;
- }
-
- jfieldID context = env->GetFieldID(clazz, "mNativeContext", "I");
- if (context == NULL) {
- return NULL;
- }
-
- MediaRecorder* const p = (MediaRecorder*)env->GetIntField(jmediarecorder, context);
- env->DeleteLocalRef(clazz);
- return sp<MediaRecorder>(p);
-}
-
-
-jint Java_android_filterfw_core_GLEnvironment_nativeAddSurface(JNIEnv* env,
- jobject thiz,
- jobject surface) {
- GLEnv* gl_env = ConvertFromJava<GLEnv>(env, thiz);
- if (!surface) {
- ALOGE("GLEnvironment: Null Surface passed!");
- return -1;
- } else if (gl_env) {
- // Get the ANativeWindow
- ANativeWindow* window = ANativeWindow_fromSurface(env, surface);
- if (!window) {
- ALOGE("GLEnvironment: Error creating window!");
- return -1;
- }
-
- NativeWindowHandle* winHandle = new NativeWindowHandle(window);
- int result = gl_env->FindSurfaceIdForWindow(winHandle);
- if (result == -1) {
- // Configure surface
- EGLConfig config;
- EGLint numConfigs = -1;
- EGLint configAttribs[] = {
- EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
- EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
- EGL_RED_SIZE, 8,
- EGL_GREEN_SIZE, 8,
- EGL_BLUE_SIZE, 8,
- EGL_RECORDABLE_ANDROID, EGL_TRUE,
- EGL_NONE
- };
-
-
-
- eglChooseConfig(gl_env->display(), configAttribs, &config, 1, &numConfigs);
- if (numConfigs < 1) {
- ALOGE("GLEnvironment: No suitable EGL configuration found for surface!");
- return -1;
- }
-
- // Create the EGL surface
- EGLSurface egl_surface = eglCreateWindowSurface(gl_env->display(),
- config,
- window,
- NULL);
-
- if (GLEnv::CheckEGLError("eglCreateWindowSurface")) {
- ALOGE("GLEnvironment: Error creating window surface!");
- return -1;
- }
-
- // Add it to GL Env and assign ID
- result = gl_env->AddWindowSurface(egl_surface, winHandle);
- } else {
- delete winHandle;
- }
- return result;
- }
- return -1;
-}
-
-jint Java_android_filterfw_core_GLEnvironment_nativeAddSurfaceWidthHeight(JNIEnv* env,
- jobject thiz,
- jobject surface,
- jint width,
- jint height) {
- GLEnv* gl_env = ConvertFromJava<GLEnv>(env, thiz);
- if (!surface) {
- ALOGE("GLEnvironment: Null SurfaceTexture passed!");
- return -1;
- } else if (gl_env) {
- // Get the ANativeWindow
- ANativeWindow* window = ANativeWindow_fromSurface(env, surface);
- if (!window) {
- ALOGE("GLEnvironment: Error creating window!");
- return -1;
- }
-
- // Don't care about format (will get overridden by SurfaceTexture
- // anyway), but do care about width and height
- // TODO: Probably, this should be just be
- // ANativeWindow_setBuffersDimensions. The pixel format is
- // set during the eglCreateWindowSurface
- ANativeWindow_setBuffersGeometry(window, width, height, 0);
-
- NativeWindowHandle* winHandle = new NativeWindowHandle(window);
- int result = gl_env->FindSurfaceIdForWindow(winHandle);
- if (result == -1) {
- // Configure surface
- EGLConfig config;
- EGLint numConfigs = -1;
- EGLint configAttribs[] = {
- EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
- EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
- EGL_RED_SIZE, 8,
- EGL_GREEN_SIZE, 8,
- EGL_BLUE_SIZE, 8,
- EGL_RECORDABLE_ANDROID, EGL_TRUE,
- EGL_NONE
- };
-
-
-
- eglChooseConfig(gl_env->display(), configAttribs, &config, 1, &numConfigs);
- if (numConfigs < 1) {
- ALOGE("GLEnvironment: No suitable EGL configuration found for surface texture!");
- return -1;
- }
-
- // Create the EGL surface
- EGLSurface egl_surface = eglCreateWindowSurface(gl_env->display(),
- config,
- window,
- NULL);
-
- if (GLEnv::CheckEGLError("eglCreateWindowSurface")) {
- ALOGE("GLEnvironment: Error creating window surface!");
- return -1;
- }
-
- // Add it to GL Env and assign ID
- result = gl_env->AddWindowSurface(egl_surface, winHandle);
- } else {
- delete winHandle;
- }
- return result;
- }
- return -1;
-}
-
-// nativeAddSurfaceFromMediaRecorder gets an EGLSurface
-// using a MediaRecorder object.
-// When Mediarecorder is used for recording GL Frames, it
-// will have a reference to a Native Handle (a SurfaceTexureClient)
-// which talks to the StageFrightRecorder in mediaserver via
-// a binder interface.
-jint Java_android_filterfw_core_GLEnvironment_nativeAddSurfaceFromMediaRecorder(
- JNIEnv* env,
- jobject thiz,
- jobject jmediarecorder) {
- ALOGV("GLEnv Jni: nativeAddSurfaceFromMediaRecorder");
- GLEnv* gl_env = ConvertFromJava<GLEnv>(env, thiz);
- if (!gl_env) {
- return -1;
- }
- // get a native mediarecorder object from the java object
- sp<MediaRecorder> mr = getMediaRecorder(env, jmediarecorder);
- if (mr == NULL) {
- ALOGE("GLEnvironment: Error- MediaRecorder could not be initialized!");
- return -1;
- }
-
- // Ask the mediarecorder to return a handle to a surfacemediasource
- // This will talk to the StageFrightRecorder via MediaRecorderClient
- // over binder calls
- sp<ISurfaceTexture> surfaceMS = mr->querySurfaceMediaSourceFromMediaServer();
- if (surfaceMS == NULL) {
- ALOGE("GLEnvironment: Error- MediaRecorder returned a null \
- <ISurfaceTexture> handle.");
- return -1;
- }
- sp<SurfaceTextureClient> surfaceTC = new SurfaceTextureClient(surfaceMS);
- // Get the ANativeWindow
- sp<ANativeWindow> window = surfaceTC;
-
-
- if (window == NULL) {
- ALOGE("GLEnvironment: Error creating window!");
- return -1;
- }
- window->incStrong((void*)ANativeWindow_acquire);
-
- // In case of encoding, no need to set the dimensions
- // on the buffers. The dimensions for the final encoding are set by
- // the consumer side.
- // The pixel format is dictated by the GL, and set during the
- // eglCreateWindowSurface
-
- NativeWindowHandle* winHandle = new NativeWindowHandle(window.get());
- int result = gl_env->FindSurfaceIdForWindow(winHandle);
- // If we find a surface with that window handle, just return that id
- if (result != -1) {
- delete winHandle;
- return result;
- }
- // If we do not find a surface with that window handle, create
- // one and assign to it the handle
- // Configure surface
- EGLConfig config;
- EGLint numConfigs = -1;
- EGLint configAttribs[] = {
- EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
- EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
- EGL_RED_SIZE, 8,
- EGL_GREEN_SIZE, 8,
- EGL_BLUE_SIZE, 8,
- EGL_RECORDABLE_ANDROID, EGL_TRUE,
- EGL_NONE
- };
-
-
- eglChooseConfig(gl_env->display(), configAttribs, &config, 1, &numConfigs);
- if (numConfigs < 1) {
- ALOGE("GLEnvironment: No suitable EGL configuration found for surface texture!");
- delete winHandle;
- return -1;
- }
-
- // Create the EGL surface
- EGLSurface egl_surface = eglCreateWindowSurface(gl_env->display(),
- config,
- window.get(),
- NULL);
-
- if (GLEnv::CheckEGLError("eglCreateWindowSurface")) {
- ALOGE("GLEnvironment: Error creating window surface!");
- delete winHandle;
- return -1;
- }
-
- // Add it to GL Env and assign ID
- result = gl_env->AddWindowSurface(egl_surface, winHandle);
- return result;
-}
-
-jboolean Java_android_filterfw_core_GLEnvironment_nativeActivateSurfaceId(JNIEnv* env,
- jobject thiz,
- jint surfaceId) {
- GLEnv* gl_env = ConvertFromJava<GLEnv>(env, thiz);
- return gl_env ? ToJBool(gl_env->SwitchToSurfaceId(surfaceId) && gl_env->Activate()) : JNI_FALSE;
-}
-
-jboolean Java_android_filterfw_core_GLEnvironment_nativeRemoveSurfaceId(JNIEnv* env,
- jobject thiz,
- jint surfaceId) {
- GLEnv* gl_env = ConvertFromJava<GLEnv>(env, thiz);
- return gl_env ? ToJBool(gl_env->ReleaseSurfaceId(surfaceId)) : JNI_FALSE;
-}
-
-jboolean Java_android_filterfw_core_GLEnvironment_nativeSetSurfaceTimestamp(JNIEnv* env,
- jobject thiz,
- jlong timestamp) {
- GLEnv* gl_env = ConvertFromJava<GLEnv>(env, thiz);
- int64_t timestamp_native = timestamp;
- return gl_env ? ToJBool(gl_env->SetSurfaceTimestamp(timestamp_native)) : JNI_FALSE;
-}
+++ /dev/null
-/*
- * 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.
- */
-
-#ifndef ANDROID_FILTERFW_JNI_GL_ENVIRONMENT_H
-#define ANDROID_FILTERFW_JNI_GL_ENVIRONMENT_H
-
-#include <jni.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-JNIEXPORT jboolean JNICALL
-Java_android_filterfw_core_GLEnvironment_nativeAllocate(JNIEnv* env, jobject thiz);
-
-JNIEXPORT jboolean JNICALL
-Java_android_filterfw_core_GLEnvironment_nativeDeallocate(JNIEnv* env, jobject thiz);
-
-JNIEXPORT jboolean JNICALL
-Java_android_filterfw_core_GLEnvironment_nativeInitWithNewContext(JNIEnv* env, jobject thiz);
-
-JNIEXPORT jboolean JNICALL
-Java_android_filterfw_core_GLEnvironment_nativeInitWithCurrentContext(JNIEnv* env, jobject thiz);
-
-JNIEXPORT jboolean JNICALL
-Java_android_filterfw_core_GLEnvironment_nativeIsActive(JNIEnv* env, jobject thiz);
-
-JNIEXPORT jboolean JNICALL
-Java_android_filterfw_core_GLEnvironment_nativeIsContextActive(JNIEnv* env, jobject thiz);
-
-JNIEXPORT jboolean JNICALL
-Java_android_filterfw_core_GLEnvironment_nativeIsAnyContextActive(JNIEnv* env, jclass clazz);
-
-JNIEXPORT jboolean JNICALL
-Java_android_filterfw_core_GLEnvironment_nativeActivate(JNIEnv* env, jobject thiz);
-
-JNIEXPORT jboolean JNICALL
-Java_android_filterfw_core_GLEnvironment_nativeDeactivate(JNIEnv* env, jobject thiz);
-
-JNIEXPORT jboolean JNICALL
-Java_android_filterfw_core_GLEnvironment_nativeSwapBuffers(JNIEnv* env, jobject thiz);
-
-JNIEXPORT jint JNICALL
-Java_android_filterfw_core_GLEnvironment_nativeAddSurface(JNIEnv* env,
- jobject thiz,
- jobject surface);
-
-JNIEXPORT jint JNICALL
-Java_android_filterfw_core_GLEnvironment_nativeAddSurfaceWidthHeight(JNIEnv* env,
- jobject thiz,
- jobject surface,
- jint width,
- jint height);
-
-// The call to hook up the SurfaceMediaSource (in MediaServer) to the GL.
-// We get a sp<ISurfaceTexure> from the MediaServer and talks to MediaServer
-// over a binder interface. GL hooked up to the MediaServer by using the native
-// window created using the <ISurfaceTexture> handle
-JNIEXPORT jint JNICALL
-Java_android_filterfw_core_GLEnvironment_nativeAddSurfaceFromMediaRecorder(
- JNIEnv* env,
- jobject thiz,
- jobject mediarecorder);
-
-JNIEXPORT jboolean JNICALL
-Java_android_filterfw_core_GLEnvironment_nativeActivateSurfaceId(JNIEnv* env,
- jobject thiz,
- jint surfaceId);
-
-JNIEXPORT jboolean JNICALL
-Java_android_filterfw_core_GLEnvironment_nativeRemoveSurfaceId(JNIEnv* env,
- jobject thiz,
- jint surfaceId);
-
-JNIEXPORT jboolean JNICALL
-Java_android_filterfw_core_GLEnvironment_nativeSetSurfaceTimestamp(JNIEnv* env,
- jobject thiz,
- jlong timestamp);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif // ANDROID_FILTERFW_JNI_GL_ENVIRONMENT_H
+++ /dev/null
-/*
- * 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.
- */
-
-#include "android/bitmap.h"
-
-#include "jni/jni_gl_frame.h"
-#include "jni/jni_util.h"
-
-#include "native/core/gl_env.h"
-#include "native/core/gl_frame.h"
-#include "native/core/native_frame.h"
-
-using android::filterfw::GLEnv;
-using android::filterfw::GLFrame;
-using android::filterfw::NativeFrame;
-
-// Helper functions ////////////////////////////////////////////////////////////////////////////////
-void ConvertFloatsToRGBA(const float* floats, int length, uint8_t* result) {
- for (int i = 0; i < length; ++i) {
- result[i] = static_cast<uint8_t>(floats[i] * 255.0);
- }
-}
-
-void ConvertRGBAToFloats(const uint8_t* rgba, int length, float* result) {
- for (int i = 0; i < length; ++i) {
- result[i] = rgba[i] / 255.0;
- }
-}
-
-// GLFrame JNI implementation //////////////////////////////////////////////////////////////////////
-jboolean Java_android_filterfw_core_GLFrame_nativeAllocate(JNIEnv* env,
- jobject thiz,
- jobject gl_env,
- jint width,
- jint height) {
- GLEnv* gl_env_ptr = ConvertFromJava<GLEnv>(env, gl_env);
- if (!gl_env_ptr) return JNI_FALSE;
- GLFrame* frame = new GLFrame(gl_env_ptr);
- if (frame->Init(width, height)) {
- return ToJBool(WrapObjectInJava(frame, env, thiz, true));
- } else {
- delete frame;
- return JNI_FALSE;
- }
-}
-
-jboolean Java_android_filterfw_core_GLFrame_nativeAllocateWithTexture(JNIEnv* env,
- jobject thiz,
- jobject gl_env,
- jint tex_id,
- jint width,
- jint height) {
- GLEnv* gl_env_ptr = ConvertFromJava<GLEnv>(env, gl_env);
- if (!gl_env_ptr) return JNI_FALSE;
- GLFrame* frame = new GLFrame(gl_env_ptr);
- if (frame->InitWithTexture(tex_id, width, height)) {
- return ToJBool(WrapObjectInJava(frame, env, thiz, true));
- } else {
- delete frame;
- return JNI_FALSE;
- }
-}
-
-jboolean Java_android_filterfw_core_GLFrame_nativeAllocateWithFbo(JNIEnv* env,
- jobject thiz,
- jobject gl_env,
- jint fbo_id,
- jint width,
- jint height) {
- GLEnv* gl_env_ptr = ConvertFromJava<GLEnv>(env, gl_env);
- if (!gl_env_ptr) return JNI_FALSE;
- GLFrame* frame = new GLFrame(gl_env_ptr);
- if (frame->InitWithFbo(fbo_id, width, height)) {
- return ToJBool(WrapObjectInJava(frame, env, thiz, true));
- } else {
- delete frame;
- return JNI_FALSE;
- }
-}
-
-jboolean Java_android_filterfw_core_GLFrame_nativeAllocateExternal(JNIEnv* env,
- jobject thiz,
- jobject gl_env) {
- GLEnv* gl_env_ptr = ConvertFromJava<GLEnv>(env, gl_env);
- if (!gl_env_ptr) return JNI_FALSE;
- GLFrame* frame = new GLFrame(gl_env_ptr);
- if (frame->InitWithExternalTexture()) {
- return ToJBool(WrapObjectInJava(frame, env, thiz, true));
- } else {
- delete frame;
- return JNI_FALSE;
- }
-}
-
-jboolean Java_android_filterfw_core_GLFrame_nativeDeallocate(JNIEnv* env, jobject thiz) {
- return ToJBool(DeleteNativeObject<GLFrame>(env, thiz));
-}
-
-jboolean Java_android_filterfw_core_GLFrame_setNativeData(JNIEnv* env,
- jobject thiz,
- jbyteArray data,
- jint offset,
- jint length) {
- GLFrame* frame = ConvertFromJava<GLFrame>(env, thiz);
- if (frame && data) {
- jbyte* bytes = env->GetByteArrayElements(data, NULL);
- if (bytes) {
- const bool success = frame->WriteData(reinterpret_cast<const uint8_t*>(bytes + offset), length);
- env->ReleaseByteArrayElements(data, bytes, JNI_ABORT);
- return ToJBool(success);
- }
- }
- return JNI_FALSE;
-}
-
-jbyteArray Java_android_filterfw_core_GLFrame_getNativeData(JNIEnv* env, jobject thiz) {
- GLFrame* frame = ConvertFromJava<GLFrame>(env, thiz);
- if (frame && frame->Size() > 0) {
- jbyteArray result = env->NewByteArray(frame->Size());
- jbyte* data = env->GetByteArrayElements(result, NULL);
- frame->CopyDataTo(reinterpret_cast<uint8_t*>(data), frame->Size());
- env->ReleaseByteArrayElements(result, data, 0);
- return result;
- }
- return NULL;
-}
-
-jboolean Java_android_filterfw_core_GLFrame_setNativeInts(JNIEnv* env,
- jobject thiz,
- jintArray ints) {
- GLFrame* frame = ConvertFromJava<GLFrame>(env, thiz);
- if (frame && ints) {
- jint* int_ptr = env->GetIntArrayElements(ints, NULL);
- const int length = env->GetArrayLength(ints);
- if (int_ptr) {
- const bool success = frame->WriteData(reinterpret_cast<const uint8_t*>(int_ptr),
- length * sizeof(jint));
- env->ReleaseIntArrayElements(ints, int_ptr, JNI_ABORT);
- return ToJBool(success);
- }
- }
- return JNI_FALSE;
-}
-
-jintArray Java_android_filterfw_core_GLFrame_getNativeInts(JNIEnv* env, jobject thiz) {
- GLFrame* frame = ConvertFromJava<GLFrame>(env, thiz);
- if (frame && frame->Size() > 0 && (frame->Size() % sizeof(jint) == 0)) {
- jintArray result = env->NewIntArray(frame->Size() / sizeof(jint));
- jint* data = env->GetIntArrayElements(result, NULL);
- frame->CopyDataTo(reinterpret_cast<uint8_t*>(data), frame->Size());
- env->ReleaseIntArrayElements(result, data, 0);
- return result;
- }
- return NULL;
-}
-
-jboolean Java_android_filterfw_core_GLFrame_setNativeFloats(JNIEnv* env,
- jobject thiz,
- jfloatArray floats) {
- GLFrame* frame = ConvertFromJava<GLFrame>(env, thiz);
- if (frame && floats) {
- jfloat* float_ptr = env->GetFloatArrayElements(floats, NULL);
- const int length = env->GetArrayLength(floats);
- if (float_ptr) {
- // Convert floats to RGBA buffer
- uint8_t* rgba_buffer = new uint8_t[length];
- ConvertFloatsToRGBA(float_ptr, length, rgba_buffer);
- env->ReleaseFloatArrayElements(floats, float_ptr, JNI_ABORT);
-
- // Write RGBA buffer to frame
- const bool success = frame->WriteData(rgba_buffer, length);
-
- // Clean-up
- delete[] rgba_buffer;
- return ToJBool(success);
- }
- }
- return JNI_FALSE;
-}
-
-jfloatArray Java_android_filterfw_core_GLFrame_getNativeFloats(JNIEnv* env, jobject thiz) {
- GLFrame* frame = ConvertFromJava<GLFrame>(env, thiz);
- if (frame && frame->Size() > 0) {
- // Create the result array
- jfloatArray result = env->NewFloatArray(frame->Size());
- jfloat* float_array = env->GetFloatArrayElements(result, NULL);
-
- // Read the frame pixels
- uint8_t* pixels = new uint8_t[frame->Size()];
- frame->CopyDataTo(pixels, frame->Size());
-
- // Convert them to floats
- ConvertRGBAToFloats(pixels, frame->Size(), float_array);
-
- // Clean-up
- delete[] pixels;
- env->ReleaseFloatArrayElements(result, float_array, 0);
- return result;
- }
- return NULL;
-}
-
-jboolean Java_android_filterfw_core_GLFrame_setNativeBitmap(JNIEnv* env,
- jobject thiz,
- jobject bitmap,
- jint size) {
- GLFrame* frame = ConvertFromJava<GLFrame>(env, thiz);
- if (frame && bitmap) {
- uint8_t* pixels;
- const int result = AndroidBitmap_lockPixels(env, bitmap, reinterpret_cast<void**>(&pixels));
- if (result == ANDROID_BITMAP_RESUT_SUCCESS) {
- const bool success = frame->WriteData(pixels, size);
- return ToJBool(success &&
- AndroidBitmap_unlockPixels(env, bitmap) == ANDROID_BITMAP_RESUT_SUCCESS);
- }
- }
- return JNI_FALSE;
-}
-
-jboolean Java_android_filterfw_core_GLFrame_getNativeBitmap(JNIEnv* env,
- jobject thiz,
- jobject bitmap) {
- GLFrame* frame = ConvertFromJava<GLFrame>(env, thiz);
- if (frame && bitmap) {
- uint8_t* pixels;
- const int result = AndroidBitmap_lockPixels(env, bitmap, reinterpret_cast<void**>(&pixels));
- if (result == ANDROID_BITMAP_RESUT_SUCCESS) {
- frame->CopyDataTo(pixels, frame->Size());
- return (AndroidBitmap_unlockPixels(env, bitmap) == ANDROID_BITMAP_RESUT_SUCCESS);
- }
- }
- return JNI_FALSE;
-}
-
-jboolean Java_android_filterfw_core_GLFrame_setNativeViewport(JNIEnv* env,
- jobject thiz,
- jint x,
- jint y,
- jint width,
- jint height) {
- GLFrame* frame = ConvertFromJava<GLFrame>(env, thiz);
- return frame ? ToJBool(frame->SetViewport(x, y, width, height)) : JNI_FALSE;
-}
-
-jint Java_android_filterfw_core_GLFrame_getNativeTextureId(JNIEnv* env, jobject thiz) {
- GLFrame* frame = ConvertFromJava<GLFrame>(env, thiz);
- return frame ? frame->GetTextureId() : -1;
-}
-
-jint Java_android_filterfw_core_GLFrame_getNativeFboId(JNIEnv* env, jobject thiz) {
- GLFrame* frame = ConvertFromJava<GLFrame>(env, thiz);
- return frame ? frame->GetFboId() : -1;
-}
-
-jboolean Java_android_filterfw_core_GLFrame_generateNativeMipMap(JNIEnv* env, jobject thiz) {
- GLFrame* frame = ConvertFromJava<GLFrame>(env, thiz);
- return frame ? ToJBool(frame->GenerateMipMap()) : JNI_FALSE;
-}
-
-jboolean Java_android_filterfw_core_GLFrame_setNativeTextureParam(JNIEnv* env,
- jobject thiz,
- jint param,
- jint value) {
- GLFrame* frame = ConvertFromJava<GLFrame>(env, thiz);
- return frame ? ToJBool(frame->SetTextureParameter(param, value)) : JNI_FALSE;
-}
-
-jboolean Java_android_filterfw_core_GLFrame_nativeResetParams(JNIEnv* env, jobject thiz) {
- GLFrame* frame = ConvertFromJava<GLFrame>(env, thiz);
- return frame ? ToJBool(frame->ResetTexParameters()) : JNI_FALSE;
-}
-
-jboolean Java_android_filterfw_core_GLFrame_nativeCopyFromNative(JNIEnv* env,
- jobject thiz,
- jobject frame) {
- GLFrame* this_frame = ConvertFromJava<GLFrame>(env, thiz);
- NativeFrame* other_frame = ConvertFromJava<NativeFrame>(env, frame);
- if (this_frame && other_frame) {
- return ToJBool(this_frame->WriteData(other_frame->Data(), other_frame->Size()));
- }
- return JNI_FALSE;
-}
-
-jboolean Java_android_filterfw_core_GLFrame_nativeCopyFromGL(JNIEnv* env,
- jobject thiz,
- jobject frame) {
- GLFrame* this_frame = ConvertFromJava<GLFrame>(env, thiz);
- GLFrame* other_frame = ConvertFromJava<GLFrame>(env, frame);
- if (this_frame && other_frame) {
- return ToJBool(this_frame->CopyPixelsFrom(other_frame));
- }
- return JNI_FALSE;
-}
-
-jboolean Java_android_filterfw_core_GLFrame_nativeFocus(JNIEnv* env, jobject thiz) {
- GLFrame* frame = ConvertFromJava<GLFrame>(env, thiz);
- return ToJBool(frame && frame->FocusFrameBuffer());
-}
-
-jboolean Java_android_filterfw_core_GLFrame_nativeReattachTexToFbo(JNIEnv* env, jobject thiz) {
- GLFrame* frame = ConvertFromJava<GLFrame>(env, thiz);
- return ToJBool(frame && frame->ReattachTextureToFbo());
-}
-
-jboolean Java_android_filterfw_core_GLFrame_nativeDetachTexFromFbo(JNIEnv* env, jobject thiz) {
- GLFrame* frame = ConvertFromJava<GLFrame>(env, thiz);
- return ToJBool(frame && frame->DetachTextureFromFbo());
-}
-
+++ /dev/null
-/*
- * 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.
- */
-
-#ifndef ANDROID_FILTERFW_JNI_GL_FRAME_H
-#define ANDROID_FILTERFW_JNI_GL_FRAME_H
-
-#include <jni.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-JNIEXPORT jboolean JNICALL
-Java_android_filterfw_core_GLFrame_nativeAllocate(JNIEnv* env,
- jobject thiz,
- jobject gl_env,
- jint width,
- jint height);
-
-JNIEXPORT jboolean JNICALL
-Java_android_filterfw_core_GLFrame_nativeAllocateWithTexture(JNIEnv* env,
- jobject thiz,
- jobject gl_env,
- jint tex_id,
- jint width,
- jint height);
-
-JNIEXPORT jboolean JNICALL
-Java_android_filterfw_core_GLFrame_nativeAllocateWithFbo(JNIEnv* env,
- jobject thiz,
- jobject gl_env,
- jint fbo_id,
- jint width,
- jint height);
-
-JNIEXPORT jboolean JNICALL
-Java_android_filterfw_core_GLFrame_nativeAllocateExternal(JNIEnv* env,
- jobject thiz,
- jobject gl_env);
-
-JNIEXPORT jboolean JNICALL
-Java_android_filterfw_core_GLFrame_nativeDeallocate(JNIEnv* env, jobject thiz);
-
-JNIEXPORT jboolean JNICALL
-Java_android_filterfw_core_GLFrame_setNativeInts(JNIEnv* env, jobject thiz, jintArray ints);
-
-JNIEXPORT jintArray JNICALL
-Java_android_filterfw_core_GLFrame_getNativeInts(JNIEnv* env, jobject thiz);
-
-JNIEXPORT jboolean JNICALL
-Java_android_filterfw_core_GLFrame_setNativeFloats(JNIEnv* env, jobject thiz, jfloatArray ints);
-
-JNIEXPORT jfloatArray JNICALL
-Java_android_filterfw_core_GLFrame_getNativeFloats(JNIEnv* env, jobject thiz);
-
-JNIEXPORT jboolean JNICALL
-Java_android_filterfw_core_GLFrame_setNativeData(JNIEnv* env,
- jobject thiz,
- jbyteArray data,
- jint offset,
- jint length);
-
-JNIEXPORT jbyteArray JNICALL
-Java_android_filterfw_core_GLFrame_getNativeData(JNIEnv* env, jobject thiz);
-
-JNIEXPORT jboolean JNICALL
-Java_android_filterfw_core_GLFrame_setNativeBitmap(JNIEnv* env,
- jobject thiz,
- jobject bitmap,
- jint size);
-
-JNIEXPORT jboolean JNICALL
-Java_android_filterfw_core_GLFrame_getNativeBitmap(JNIEnv* env, jobject thiz, jobject bitmap);
-
-JNIEXPORT jboolean JNICALL
-Java_android_filterfw_core_GLFrame_setNativeViewport(JNIEnv* env,
- jobject thiz,
- jint x,
- jint y,
- jint width,
- jint height);
-
-JNIEXPORT jint JNICALL
-Java_android_filterfw_core_GLFrame_getNativeTextureId(JNIEnv* env, jobject thiz);
-
-JNIEXPORT jint JNICALL
-Java_android_filterfw_core_GLFrame_getNativeFboId(JNIEnv* env, jobject thiz);
-
-JNIEXPORT jboolean JNICALL
-Java_android_filterfw_core_GLFrame_generateNativeMipMap(JNIEnv* env, jobject thiz);
-
-JNIEXPORT jboolean JNICALL
-Java_android_filterfw_core_GLFrame_setNativeTextureParam(JNIEnv* env,
- jobject thiz,
- jint param,
- jint value);
-
-JNIEXPORT jboolean JNICALL
-Java_android_filterfw_core_GLFrame_nativeResetParams(JNIEnv* env, jobject thiz);
-
-JNIEXPORT jboolean JNICALL
-Java_android_filterfw_core_GLFrame_nativeCopyFromNative(JNIEnv* env,
- jobject thiz,
- jobject frame);
-
-JNIEXPORT jboolean JNICALL
-Java_android_filterfw_core_GLFrame_nativeCopyFromGL(JNIEnv* env,
- jobject thiz,
- jobject frame);
-
-JNIEXPORT jboolean JNICALL
-Java_android_filterfw_core_GLFrame_nativeFocus(JNIEnv* env, jobject thiz);
-
-JNIEXPORT jboolean JNICALL
-Java_android_filterfw_core_GLFrame_nativeReattachTexToFbo(JNIEnv* env, jobject thiz);
-
-JNIEXPORT jboolean JNICALL
-Java_android_filterfw_core_GLFrame_nativeDetachTexFromFbo(JNIEnv* env, jobject thiz);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* ANDROID_FILTERFW_JNI_GL_FRAME_H */
+++ /dev/null
-/*
- * 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.
- */
-
-#include "jni/jni_util.h"
-
-#include "native/core/native_frame.h"
-#include "native/core/native_program.h"
-#include "native/core/gl_env.h"
-#include "native/core/gl_frame.h"
-#include "native/core/shader_program.h"
-#include "native/core/vertex_frame.h"
-
-using namespace android::filterfw;
-
-JavaVM* g_current_java_vm_ = NULL;
-
-jint JNI_OnLoad(JavaVM* vm, void* reserved) {
- // Set the current vm pointer
- g_current_java_vm_ = vm;
-
- // Initialize object pools
- ObjectPool<NativeFrame>::Setup("android/filterfw/core/NativeFrame", "nativeFrameId");
- ObjectPool<NativeProgram>::Setup("android/filterfw/core/NativeProgram", "nativeProgramId");
- ObjectPool<GLFrame>::Setup("android/filterfw/core/GLFrame", "glFrameId");
- ObjectPool<ShaderProgram>::Setup("android/filterfw/core/ShaderProgram", "shaderProgramId");
- ObjectPool<GLEnv>::Setup("android/filterfw/core/GLEnvironment", "glEnvId");
- ObjectPool<VertexFrame>::Setup("android/filterfw/core/VertexFrame", "vertexFrameId");
-
- return JNI_VERSION_1_4;
-}
+++ /dev/null
-/*
- * 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.
- */
-
-#include "jni/jni_native_buffer.h"
-#include "jni/jni_util.h"
-
-char* GetJBufferData(JNIEnv* env, jobject buffer, int* size) {
- jclass base_class = env->FindClass("android/filterfw/core/NativeBuffer");
-
- // Get fields
- jfieldID ptr_field = env->GetFieldID(base_class, "mDataPointer", "J");
- jfieldID size_field = env->GetFieldID(base_class, "mSize", "I");
-
- // Get their values
- char* data = reinterpret_cast<char*>(env->GetLongField(buffer, ptr_field));
- if (size) {
- *size = env->GetIntField(buffer, size_field);
- }
-
- // Clean-up
- env->DeleteLocalRef(base_class);
-
- return data;
-}
-
-bool AttachDataToJBuffer(JNIEnv* env, jobject buffer, char* data, int size) {
- jclass base_class = env->FindClass("android/filterfw/core/NativeBuffer");
-
- // Get fields
- jfieldID ptr_field = env->GetFieldID(base_class, "mDataPointer", "J");
- jfieldID size_field = env->GetFieldID(base_class, "mSize", "I");
-
- // Set their values
- env->SetLongField(buffer, ptr_field, reinterpret_cast<jlong>(data));
- env->SetIntField(buffer, size_field, size);
-
- return true;
-}
-
-jboolean Java_android_filterfw_core_NativeBuffer_allocate(JNIEnv* env, jobject thiz, jint size) {
- char* data = new char[size];
- return ToJBool(AttachDataToJBuffer(env, thiz, data, size));
-}
-
-jboolean Java_android_filterfw_core_NativeBuffer_deallocate(JNIEnv* env,
- jobject thiz,
- jboolean owns_data) {
- if (ToCppBool(owns_data)) {
- char* data = GetJBufferData(env, thiz, NULL);
- delete[] data;
- }
- return JNI_TRUE;
-}
-
-jboolean Java_android_filterfw_core_NativeBuffer_nativeCopyTo(JNIEnv* env,
- jobject thiz,
- jobject new_buffer) {
- // Get source buffer
- int size;
- char* source_data = GetJBufferData(env, thiz, &size);
-
- // Make copy
- char* target_data = new char[size];
- memcpy(target_data, source_data, size);
-
- // Attach it to new buffer
- AttachDataToJBuffer(env, new_buffer, target_data, size);
-
- return JNI_TRUE;
-}
-
+++ /dev/null
-/*
- * 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.
- */
-
-#ifndef ANDROID_FILTEFW_JNI_NATIVE_BUFFER_H
-#define ANDROID_FILTEFW_JNI_NATIVE_BUFFER_H
-
-#include <jni.h>
-
-// Internal Buffer Unwrapping functions ////////////////////////////////////////////////////////////
-/**
- * Given a Java NativeBuffer instance, get access to the underlying C pointer and its size. The
- * size argument may be NULL, in which case the object is not queried for its size.
- **/
-char* GetJBufferData(JNIEnv* env, jobject buffer, int* size);
-
-/**
- * Attach a given C data buffer and its size to a given allocated Java NativeBuffer instance. After
- * this call, the java instance will have the given C buffer as its backing. Note, that the Java
- * instance contains the flag on whether or not it owns the buffer or not, so make sure it is what
- * you expect.
- **/
-bool AttachDataToJBuffer(JNIEnv* env, jobject buffer, char* data, int size);
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-// JNI Wrappers ////////////////////////////////////////////////////////////////////////////////////
-JNIEXPORT jboolean JNICALL
-Java_android_filterfw_core_NativeBuffer_allocate(JNIEnv* env, jobject thiz, jint size);
-
-JNIEXPORT jboolean JNICALL
-Java_android_filterfw_core_NativeBuffer_deallocate(JNIEnv* env, jobject thiz, jboolean owns_data);
-
-JNIEXPORT jboolean JNICALL
-Java_android_filterfw_core_NativeBuffer_nativeCopyTo(JNIEnv* env, jobject thiz, jobject new_buffer);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif // ANDROID_FILTEFW_JNI_NATIVE_BUFFER_H
+++ /dev/null
-/*
- * 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.
- */
-
-#include "android/bitmap.h"
-
-#include "jni/jni_native_frame.h"
-#include "jni/jni_native_buffer.h"
-#include "jni/jni_util.h"
-
-#include "native/base/logging.h"
-#include "native/core/gl_frame.h"
-#include "native/core/native_frame.h"
-
-using android::filterfw::NativeFrame;
-using android::filterfw::GLFrame;
-
-typedef union {
- uint32_t value;
- uint8_t rgba[4];
-} Pixel;
-
-jboolean Java_android_filterfw_core_NativeFrame_nativeAllocate(JNIEnv* env,
- jobject thiz,
- jint size) {
- return ToJBool(WrapObjectInJava(new NativeFrame(size), env, thiz, true));
-}
-
-jboolean Java_android_filterfw_core_NativeFrame_nativeDeallocate(JNIEnv* env, jobject thiz) {
- return ToJBool(DeleteNativeObject<NativeFrame>(env, thiz));
-}
-
-jint Java_android_filterfw_core_NativeFrame_nativeIntSize(JNIEnv*, jclass) {
- return sizeof(jint);
-}
-
-jint Java_android_filterfw_core_NativeFrame_nativeFloatSize(JNIEnv*, jclass) {
- return sizeof(jfloat);
-}
-
-jboolean Java_android_filterfw_core_NativeFrame_setNativeData(JNIEnv* env,
- jobject thiz,
- jbyteArray data,
- jint offset,
- jint length) {
- NativeFrame* frame = ConvertFromJava<NativeFrame>(env, thiz);
- if (frame && data) {
- jbyte* bytes = env->GetByteArrayElements(data, NULL);
- if (bytes) {
- const bool success = frame->WriteData(reinterpret_cast<const uint8_t*>(bytes + offset),
- 0,
- length);
- env->ReleaseByteArrayElements(data, bytes, JNI_ABORT);
- return ToJBool(success);
- }
- }
- return JNI_FALSE;
-}
-
-jbyteArray Java_android_filterfw_core_NativeFrame_getNativeData(JNIEnv* env,
- jobject thiz,
- jint size) {
- NativeFrame* frame = ConvertFromJava<NativeFrame>(env, thiz);
- if (frame) {
- const uint8_t* data = frame->Data();
- if (!data || size > frame->Size())
- return NULL;
- jbyteArray result = env->NewByteArray(size);
- env->SetByteArrayRegion(result, 0, size, reinterpret_cast<const jbyte*>(data));
- return result;
- }
- return NULL;
-}
-
-jboolean Java_android_filterfw_core_NativeFrame_getNativeBuffer(JNIEnv* env,
- jobject thiz,
- jobject buffer) {
- NativeFrame* frame = ConvertFromJava<NativeFrame>(env, thiz);
- if (frame) {
- char* data = reinterpret_cast<char*>(frame->MutableData());
- return ToJBool(AttachDataToJBuffer(env, buffer, data, frame->Size()));
- }
- return JNI_FALSE;
-}
-
-jboolean Java_android_filterfw_core_NativeFrame_setNativeInts(JNIEnv* env,
- jobject thiz,
- jintArray ints) {
- NativeFrame* frame = ConvertFromJava<NativeFrame>(env, thiz);
- if (frame && ints) {
- jint* int_ptr = env->GetIntArrayElements(ints, NULL);
- const int length = env->GetArrayLength(ints);
- if (int_ptr) {
- const bool success = frame->WriteData(reinterpret_cast<const uint8_t*>(int_ptr),
- 0,
- length * sizeof(jint));
- env->ReleaseIntArrayElements(ints, int_ptr, JNI_ABORT);
- return ToJBool(success);
- }
- }
- return JNI_FALSE;
-}
-
-jintArray Java_android_filterfw_core_NativeFrame_getNativeInts(JNIEnv* env,
- jobject thiz,
- jint size) {
- NativeFrame* frame = ConvertFromJava<NativeFrame>(env, thiz);
- if (frame) {
- const uint8_t* data = frame->Data();
- if (!data || size > frame->Size() || (size % sizeof(jint)) != 0)
- return NULL;
- const int count = size / sizeof(jint);
- jintArray result = env->NewIntArray(count);
- env->SetIntArrayRegion(result, 0, count, reinterpret_cast<const jint*>(data));
- return result;
- }
- return NULL;
-}
-
-jboolean Java_android_filterfw_core_NativeFrame_setNativeFloats(JNIEnv* env,
- jobject thiz,
- jfloatArray floats) {
- NativeFrame* frame = ConvertFromJava<NativeFrame>(env, thiz);
- if (frame && floats) {
- jfloat* float_ptr = env->GetFloatArrayElements(floats, NULL);
- const int length = env->GetArrayLength(floats);
- if (float_ptr) {
- const bool success = frame->WriteData(reinterpret_cast<const uint8_t*>(float_ptr),
- 0,
- length * sizeof(jfloat));
- env->ReleaseFloatArrayElements(floats, float_ptr, JNI_ABORT);
- return ToJBool(success);
- }
- }
- return JNI_FALSE;
-}
-
-jfloatArray Java_android_filterfw_core_NativeFrame_getNativeFloats(JNIEnv* env,
- jobject thiz,
- jint size) {
- NativeFrame* frame = ConvertFromJava<NativeFrame>(env, thiz);
- if (frame) {
- const uint8_t* data = frame->Data();
- if (!data || size > frame->Size() || (size % sizeof(jfloat)) != 0)
- return NULL;
- const int count = size / sizeof(jfloat);
- jfloatArray result = env->NewFloatArray(count);
- env->SetFloatArrayRegion(result, 0, count, reinterpret_cast<const jfloat*>(data));
- return result;
- }
- return NULL;
-}
-
-jboolean Java_android_filterfw_core_NativeFrame_setNativeBitmap(JNIEnv* env,
- jobject thiz,
- jobject bitmap,
- jint size,
- jint bytes_per_sample) {
- NativeFrame* frame = ConvertFromJava<NativeFrame>(env, thiz);
- if (frame && bitmap) {
- // Make sure frame size matches bitmap size
- if ((size / 4) != (frame->Size() / bytes_per_sample)) {
- ALOGE("Size mismatch in native setBitmap()!");
- return JNI_FALSE;
- }
-
- Pixel* src_ptr;
- const int result = AndroidBitmap_lockPixels(env, bitmap, reinterpret_cast<void**>(&src_ptr));
- if (result == ANDROID_BITMAP_RESUT_SUCCESS) {
- // Create destination pointers
- uint8_t* dst_ptr = reinterpret_cast<uint8_t*>(frame->MutableData());
- const uint8_t* end_ptr = dst_ptr + frame->Size();
- switch (bytes_per_sample) {
- case 1: { // RGBA -> GRAY
- while (dst_ptr < end_ptr) {
- const Pixel pixel = *(src_ptr++);
- *(dst_ptr++) = (pixel.rgba[0] + pixel.rgba[1] + pixel.rgba[2]) / 3;
- }
- break;
- }
- case 3: { // RGBA -> RGB
- while (dst_ptr < end_ptr) {
- const Pixel pixel = *(src_ptr++);
- *(dst_ptr++) = pixel.rgba[0];
- *(dst_ptr++) = pixel.rgba[1];
- *(dst_ptr++) = pixel.rgba[2];
- }
- break;
- }
- case 4: { // RGBA -> RGBA
- memcpy(dst_ptr, src_ptr, frame->Size());
- break;
- }
- default:
- ALOGE("Unsupported bytes-per-pixel %d in setBitmap!", bytes_per_sample);
- break;
- }
- return (AndroidBitmap_unlockPixels(env, bitmap) == ANDROID_BITMAP_RESUT_SUCCESS);
- }
- }
- return JNI_FALSE;
-}
-
-jboolean Java_android_filterfw_core_NativeFrame_getNativeBitmap(JNIEnv* env,
- jobject thiz,
- jobject bitmap,
- jint size,
- jint bytes_per_sample) {
- NativeFrame* frame = ConvertFromJava<NativeFrame>(env, thiz);
- if (frame && bitmap) {
- Pixel* dst_ptr;
- const int result = AndroidBitmap_lockPixels(env, bitmap, reinterpret_cast<void**>(&dst_ptr));
- if (result == ANDROID_BITMAP_RESUT_SUCCESS) {
- // Make sure frame size matches bitmap size
- if ((size / 4) != (frame->Size() / bytes_per_sample)) {
- ALOGE("Size mismatch in native getBitmap()!");
- return JNI_FALSE;
- }
-
- const uint8_t* src_ptr = frame->Data();
- const uint8_t* end_ptr = src_ptr + frame->Size();
- switch (bytes_per_sample) {
- case 1: { // GRAY -> RGBA
- while (src_ptr < end_ptr) {
- const uint8_t value = *(src_ptr++);
- dst_ptr->rgba[0] = dst_ptr->rgba[1] = dst_ptr->rgba[2] = value;
- dst_ptr->rgba[3] = 255;
- ++dst_ptr;
- }
- break;
- }
- case 3: { // RGB -> RGBA
- while (src_ptr < end_ptr) {
- dst_ptr->rgba[0] = *(src_ptr++);
- dst_ptr->rgba[1] = *(src_ptr++);
- dst_ptr->rgba[2] = *(src_ptr++);
- dst_ptr->rgba[3] = 255;
- ++dst_ptr;
- }
- break;
- }
- case 4: { // RGBA -> RGBA
- memcpy(dst_ptr, src_ptr, frame->Size());
- break;
- }
- default:
- ALOGE("Unsupported bytes-per-pixel %d in getBitmap!", bytes_per_sample);
- break;
- }
- return (AndroidBitmap_unlockPixels(env, bitmap) == ANDROID_BITMAP_RESUT_SUCCESS);
- }
- }
- return JNI_FALSE;
-}
-
-jint Java_android_filterfw_core_NativeFrame_getNativeCapacity(JNIEnv* env, jobject thiz) {
- NativeFrame* frame = ConvertFromJava<NativeFrame>(env, thiz);
- return frame ? frame->Capacity() : -1;
-}
-
-jboolean Java_android_filterfw_core_NativeFrame_nativeCopyFromNative(JNIEnv* env,
- jobject thiz,
- jobject frame) {
- NativeFrame* this_frame = ConvertFromJava<NativeFrame>(env, thiz);
- NativeFrame* other_frame = ConvertFromJava<NativeFrame>(env, frame);
- if (this_frame && other_frame) {
- return ToJBool(this_frame->WriteData(other_frame->Data(), 0, other_frame->Size()));
- }
- return JNI_FALSE;
-}
-
-jboolean Java_android_filterfw_core_NativeFrame_nativeCopyFromGL(JNIEnv* env,
- jobject thiz,
- jobject frame) {
- NativeFrame* this_frame = ConvertFromJava<NativeFrame>(env, thiz);
- GLFrame* other_frame = ConvertFromJava<GLFrame>(env, frame);
- if (this_frame && other_frame) {
- return ToJBool(other_frame->CopyDataTo(this_frame->MutableData(), this_frame->Size()));
- }
- return JNI_FALSE;
-}
+++ /dev/null
-/*
- * 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.
- */
-
-#ifndef ANDROID_FILTERFW_JNI_NATIVE_FRAME_H
-#define ANDROID_FILTERFW_JNI_NATIVE_FRAME_H
-
-#include <jni.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-JNIEXPORT jboolean JNICALL
-Java_android_filterfw_core_NativeFrame_nativeAllocate(JNIEnv* env, jobject thiz, jint size);
-
-JNIEXPORT jboolean JNICALL
-Java_android_filterfw_core_NativeFrame_nativeDeallocate(JNIEnv* env, jobject thiz);
-
-JNIEXPORT jint JNICALL
-Java_android_filterfw_core_NativeFrame_nativeIntSize(JNIEnv* env, jclass clazz);
-
-JNIEXPORT jint JNICALL
-Java_android_filterfw_core_NativeFrame_nativeFloatSize(JNIEnv* env, jclass clazz);
-
-JNIEXPORT jboolean JNICALL
-Java_android_filterfw_core_NativeFrame_setNativeInts(JNIEnv* env, jobject thiz, jintArray ints);
-
-JNIEXPORT jintArray JNICALL
-Java_android_filterfw_core_NativeFrame_getNativeInts(JNIEnv* env, jobject thiz, jint size);
-
-JNIEXPORT jboolean JNICALL
-Java_android_filterfw_core_NativeFrame_setNativeFloats(JNIEnv* env, jobject thiz, jfloatArray ints);
-
-JNIEXPORT jfloatArray JNICALL
-Java_android_filterfw_core_NativeFrame_getNativeFloats(JNIEnv* env, jobject thiz, jint size);
-
-JNIEXPORT jboolean JNICALL
-Java_android_filterfw_core_NativeFrame_setNativeData(JNIEnv* env,
- jobject thiz,
- jbyteArray data,
- jint offset,
- jint length);
-
-JNIEXPORT jbyteArray JNICALL
-Java_android_filterfw_core_NativeFrame_getNativeData(JNIEnv* env, jobject thiz, jint size);
-
-JNIEXPORT jboolean JNICALL
-Java_android_filterfw_core_NativeFrame_getNativeBuffer(JNIEnv* env, jobject thiz, jobject buffer);
-
-JNIEXPORT jboolean JNICALL
-Java_android_filterfw_core_NativeFrame_setNativeBitmap(JNIEnv* env,
- jobject thiz,
- jobject bitmap,
- jint size,
- jint bytes_per_sample);
-
-JNIEXPORT jboolean JNICALL
-Java_android_filterfw_core_NativeFrame_getNativeBitmap(JNIEnv* env,
- jobject thiz,
- jobject bitmap,
- jint size,
- jint bytes_per_sample);
-
-JNIEXPORT jint JNICALL
-Java_android_filterfw_core_NativeFrame_getNativeCapacity(JNIEnv* env, jobject thiz);
-
-JNIEXPORT jboolean JNICALL
-Java_android_filterfw_core_NativeFrame_nativeCopyFromNative(JNIEnv* env,
- jobject thiz,
- jobject frame);
-
-JNIEXPORT jboolean JNICALL
-Java_android_filterfw_core_NativeFrame_nativeCopyFromGL(JNIEnv* env,
- jobject thiz,
- jobject frame);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif // ANDROID_FILTERFW_JNI_NATIVE_FRAME_H
+++ /dev/null
-/*
- * 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.
- */
-
-#include <string>
-#include <vector>
-
-#include "jni/jni_native_program.h"
-#include "jni/jni_util.h"
-
-#include "native/base/logging.h"
-#include "native/core/native_frame.h"
-#include "native/core/native_program.h"
-
-using android::filterfw::NativeFrame;
-using android::filterfw::NativeProgram;
-
-jboolean Java_android_filterfw_core_NativeProgram_allocate(JNIEnv* env, jobject thiz) {
- return ToJBool(WrapObjectInJava(new NativeProgram(), env, thiz, true));
-}
-
-jboolean Java_android_filterfw_core_NativeProgram_deallocate(JNIEnv* env, jobject thiz) {
- return ToJBool(DeleteNativeObject<NativeProgram>(env, thiz));
-}
-
-jboolean Java_android_filterfw_core_NativeProgram_nativeInit(JNIEnv* env, jobject thiz) {
- NativeProgram* program = ConvertFromJava<NativeProgram>(env, thiz);
- return ToJBool(program && program->CallInit());
-}
-
-jboolean Java_android_filterfw_core_NativeProgram_openNativeLibrary(JNIEnv* env,
- jobject thiz,
- jstring lib_name) {
- NativeProgram* program = ConvertFromJava<NativeProgram>(env, thiz);
- return ToJBool(program && lib_name && program->OpenLibrary(ToCppString(env, lib_name)));
-}
-
-jboolean Java_android_filterfw_core_NativeProgram_bindInitFunction(JNIEnv* env,
- jobject thiz,
- jstring func_name) {
- NativeProgram* program = ConvertFromJava<NativeProgram>(env, thiz);
- return ToJBool(program && func_name && program->BindInitFunction(ToCppString(env, func_name)));
-}
-
-jboolean Java_android_filterfw_core_NativeProgram_bindSetValueFunction(JNIEnv* env,
- jobject thiz,
- jstring func_name) {
- NativeProgram* program = ConvertFromJava<NativeProgram>(env, thiz);
- return ToJBool(program &&
- func_name &&
- program->BindSetValueFunction(ToCppString(env, func_name)));
-}
-
-jboolean Java_android_filterfw_core_NativeProgram_bindGetValueFunction(JNIEnv* env,
- jobject thiz,
- jstring func_name) {
- NativeProgram* program = ConvertFromJava<NativeProgram>(env, thiz);
- return ToJBool(program &&
- func_name &&
- program->BindGetValueFunction(ToCppString(env, func_name)));
-}
-
-jboolean Java_android_filterfw_core_NativeProgram_bindProcessFunction(JNIEnv* env,
- jobject thiz,
- jstring func_name) {
- NativeProgram* program = ConvertFromJava<NativeProgram>(env, thiz);
- return ToJBool(program && func_name && program->BindProcessFunction(ToCppString(env, func_name)));
-}
-
-jboolean Java_android_filterfw_core_NativeProgram_bindResetFunction(JNIEnv* env,
- jobject thiz,
- jstring func_name) {
- NativeProgram* program = ConvertFromJava<NativeProgram>(env, thiz);
- return ToJBool(program &&
- func_name &&
- program->BindResetFunction(ToCppString(env, func_name)));
-}
-
-jboolean Java_android_filterfw_core_NativeProgram_bindTeardownFunction(JNIEnv* env,
- jobject thiz,
- jstring func_name) {
- NativeProgram* program = ConvertFromJava<NativeProgram>(env, thiz);
- return ToJBool(program &&
- func_name &&
- program->BindTeardownFunction(ToCppString(env, func_name)));
-}
-
-jboolean Java_android_filterfw_core_NativeProgram_callNativeInit(JNIEnv* env, jobject thiz) {
- NativeProgram* program = ConvertFromJava<NativeProgram>(env, thiz);
- return ToJBool(program && program->CallInit());
-}
-
-jboolean Java_android_filterfw_core_NativeProgram_callNativeSetValue(JNIEnv* env,
- jobject thiz,
- jstring key,
- jstring value) {
- if (!value) {
- ALOGE("Native Program: Attempting to set null value for key %s!",
- ToCppString(env, key).c_str());
- }
- NativeProgram* program = ConvertFromJava<NativeProgram>(env, thiz);
- const std::string c_value = ToCppString(env, value);
- const std::string c_key = ToCppString(env, key);
- return ToJBool(program && program->CallSetValue(c_key, c_value));
-}
-
-jstring Java_android_filterfw_core_NativeProgram_callNativeGetValue(JNIEnv* env,
- jobject thiz,
- jstring key) {
- NativeProgram* program = ConvertFromJava<NativeProgram>(env, thiz);
- const std::string c_key = ToCppString(env, key);
- if (program) {
- return ToJString(env, program->CallGetValue(c_key));
- }
- return JNI_FALSE;
-}
-
-jboolean Java_android_filterfw_core_NativeProgram_callNativeProcess(JNIEnv* env,
- jobject thiz,
- jobjectArray inputs,
- jobject output) {
- NativeProgram* program = ConvertFromJava<NativeProgram>(env, thiz);
-
- // Sanity checks
- if (!program || !inputs) {
- return JNI_FALSE;
- }
-
- // Get the input buffers
- const int input_count = env->GetArrayLength(inputs);
- std::vector<const char*> input_buffers(input_count, NULL);
- std::vector<int> input_sizes(input_count, 0);
- for (int i = 0 ; i < input_count; ++i) {
- const char* input_data = NULL;
- int input_size = 0;
- jobject input = env->GetObjectArrayElement(inputs, i);
- if (input) {
- NativeFrame* native_frame = ConvertFromJava<NativeFrame>(env, input);
- if (!native_frame) {
- ALOGE("NativeProgram: Could not grab NativeFrame input %d!", i);
- return JNI_FALSE;
- }
- input_data = reinterpret_cast<const char*>(native_frame->Data());
- input_size = native_frame->Size();
- }
- input_buffers[i] = input_data;
- input_sizes[i] = input_size;
- }
-
- // Get the output buffer
- char* output_data = NULL;
- int output_size = 0;
- if (output) {
- NativeFrame* output_frame = ConvertFromJava<NativeFrame>(env, output);
- if (!output_frame) {
- ALOGE("NativeProgram: Could not grab NativeFrame output!");
- return JNI_FALSE;
- }
- output_data = reinterpret_cast<char*>(output_frame->MutableData());
- output_size = output_frame->Size();
- }
-
- // Process the frames!
- return ToJBool(program->CallProcess(input_buffers, input_sizes, output_data, output_size));
-}
-
-jboolean Java_android_filterfw_core_NativeProgram_callNativeReset(JNIEnv* env, jobject thiz) {
- NativeProgram* program = ConvertFromJava<NativeProgram>(env, thiz);
- return ToJBool(program && program->CallReset());
-}
-
-jboolean Java_android_filterfw_core_NativeProgram_callNativeTeardown(JNIEnv* env, jobject thiz) {
- NativeProgram* program = ConvertFromJava<NativeProgram>(env, thiz);
- return ToJBool(program && program->CallTeardown());
-}
+++ /dev/null
-/*
- * 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.
- */
-
-#ifndef ANDROID_FILTERFW_JNI_NATIVE_PROGRAM_H
-#define ANDROID_FILTERFW_JNI_NATIVE_PROGRAM_H
-
-#include <jni.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-JNIEXPORT jboolean JNICALL
-Java_android_filterfw_core_NativeProgram_allocate(JNIEnv* env, jobject thiz);
-
-JNIEXPORT jboolean JNICALL
-Java_android_filterfw_core_NativeProgram_deallocate(JNIEnv* env, jobject thiz);
-
-JNIEXPORT jboolean JNICALL
-Java_android_filterfw_core_NativeProgram_nativeInit(JNIEnv* env, jobject thiz);
-
-JNIEXPORT jboolean JNICALL
-Java_android_filterfw_core_NativeProgram_openNativeLibrary(JNIEnv* env,
- jobject thiz,
- jstring lib_name);
-
-JNIEXPORT jboolean JNICALL
-Java_android_filterfw_core_NativeProgram_bindInitFunction(JNIEnv* env,
- jobject thiz,
- jstring func_name);
-
-JNIEXPORT jboolean JNICALL
-Java_android_filterfw_core_NativeProgram_bindSetValueFunction(JNIEnv* env,
- jobject thiz,
- jstring func_name);
-
-JNIEXPORT jboolean JNICALL
-Java_android_filterfw_core_NativeProgram_bindGetValueFunction(JNIEnv* env,
- jobject thiz,
- jstring func_name);
-
-JNIEXPORT jboolean JNICALL
-Java_android_filterfw_core_NativeProgram_bindProcessFunction(JNIEnv* env,
- jobject thiz,
- jstring func_name);
-
-JNIEXPORT jboolean JNICALL
-Java_android_filterfw_core_NativeProgram_bindResetFunction(JNIEnv* env,
- jobject thiz,
- jstring func_name);
-
-JNIEXPORT jboolean JNICALL
-Java_android_filterfw_core_NativeProgram_bindTeardownFunction(JNIEnv* env,
- jobject thiz,
- jstring func_name);
-
-JNIEXPORT jboolean JNICALL
-Java_android_filterfw_core_NativeProgram_callNativeInit(JNIEnv* env, jobject thiz);
-
-JNIEXPORT jboolean JNICALL
-Java_android_filterfw_core_NativeProgram_callNativeSetValue(JNIEnv* env,
- jobject thiz,
- jstring key,
- jstring value);
-
-JNIEXPORT jstring JNICALL
-Java_android_filterfw_core_NativeProgram_callNativeGetValue(JNIEnv* env,
- jobject thiz,
- jstring key);
-
-JNIEXPORT jboolean JNICALL
-Java_android_filterfw_core_NativeProgram_callNativeProcess(JNIEnv* env,
- jobject thiz,
- jobjectArray inputs,
- jobject output);
-
-JNIEXPORT jboolean JNICALL
-Java_android_filterfw_core_NativeProgram_callNativeReset(JNIEnv* env, jobject thiz);
-
-JNIEXPORT jboolean JNICALL
-Java_android_filterfw_core_NativeProgram_callNativeTeardown(JNIEnv* env, jobject thiz);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif // ANDROID_FILTERFW_JNI_NATIVE_PROGRAM_H
+++ /dev/null
-/*
- * 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.
- */
-
-#include <string>
-#include <vector>
-
-#include "jni/jni_shader_program.h"
-#include "jni/jni_util.h"
-
-#include "native/base/logging.h"
-#include "native/core/geometry.h"
-#include "native/core/gl_env.h"
-#include "native/core/gl_frame.h"
-#include "native/core/shader_program.h"
-#include "native/core/vertex_frame.h"
-
-using android::filterfw::GLEnv;
-using android::filterfw::GLFrame;
-using android::filterfw::Point;
-using android::filterfw::ProgramVar;
-using android::filterfw::Quad;
-using android::filterfw::ShaderProgram;
-using android::filterfw::VertexFrame;
-
-jboolean Java_android_filterfw_core_ShaderProgram_allocate(JNIEnv* env,
- jobject thiz,
- jobject gl_env,
- jstring vertex_shader,
- jstring fragment_shader) {
- // Get the GLEnv pointer
- GLEnv* gl_env_ptr = ConvertFromJava<GLEnv>(env, gl_env);
-
- // Create the shader
- if (!fragment_shader || !gl_env_ptr)
- return false;
- else if (!vertex_shader)
- return ToJBool(WrapObjectInJava(new ShaderProgram(
- gl_env_ptr,
- ToCppString(env, fragment_shader)),
- env,
- thiz,
- true));
- else
- return ToJBool(WrapObjectInJava(new ShaderProgram(
- gl_env_ptr,
- ToCppString(env, vertex_shader),
- ToCppString(env, fragment_shader)),
- env,
- thiz,
- true));
-}
-
-jboolean Java_android_filterfw_core_ShaderProgram_deallocate(JNIEnv* env, jobject thiz) {
- return ToJBool(DeleteNativeObject<ShaderProgram>(env, thiz));
-}
-
-jboolean Java_android_filterfw_core_ShaderProgram_compileAndLink(JNIEnv* env, jobject thiz) {
- ShaderProgram* program = ConvertFromJava<ShaderProgram>(env, thiz);
- return program ? ToJBool(program->CompileAndLink()) : JNI_FALSE;
-}
-
-jboolean Java_android_filterfw_core_ShaderProgram_setUniformValue(JNIEnv* env,
- jobject thiz,
- jstring key,
- jobject value) {
- ShaderProgram* program = ConvertFromJava<ShaderProgram>(env, thiz);
- const Value c_value = ToCValue(env, value);
- const std::string c_key = ToCppString(env, key);
- if (c_value.value) {
- return ToJBool(program && program->SetUniformValue(c_key, c_value));
- } else {
- ALOGE("ShaderProgram: Could not convert java object value passed for key '%s'!", c_key.c_str());
- return JNI_FALSE;
- }
-}
-
-jobject Java_android_filterfw_core_ShaderProgram_getUniformValue(JNIEnv* env,
- jobject thiz,
- jstring key) {
- ShaderProgram* program = ConvertFromJava<ShaderProgram>(env, thiz);
- const std::string c_key = ToCppString(env, key);
- return program ? ToJObject(env, program->GetUniformValue(c_key)) : JNI_NULL;
-}
-
-jboolean Java_android_filterfw_core_ShaderProgram_shaderProcess(JNIEnv* env,
- jobject thiz,
- jobjectArray inputs,
- jobject output) {
- ShaderProgram* program = ConvertFromJava<ShaderProgram>(env, thiz);
- std::vector<const GLFrame*> input_frames;
- if (program && inputs && output) {
- // Get the input frames
- const int input_count = env->GetArrayLength(inputs);
- for (int i = 0; i < input_count; ++i) {
- jobject input = env->GetObjectArrayElement(inputs, i);
- const GLFrame* input_frame = ConvertFromJava<GLFrame>(env, input);
- if (!input || !input_frame) {
- ALOGE("ShaderProgram: invalid input frame %d!", i);
- return JNI_FALSE;
- }
- input_frames.push_back(input_frame);
- }
-
- // Get the output frame
- GLFrame* output_frame = ConvertFromJava<GLFrame>(env, output);
- if (!output_frame) {
- ALOGE("ShaderProgram: no output frame found!");
- return JNI_FALSE;
- }
-
- // Process the frames!
- if (!program->Process(input_frames, output_frame)) {
- ALOGE("ShaderProgram: error processing shader!");
- return JNI_FALSE;
- }
-
- return JNI_TRUE;
- }
- return JNI_FALSE;
-}
-
-jobject Java_android_filterfw_core_ShaderProgram_nativeCreateIdentity(JNIEnv* env,
- jclass,
- jobject gl_env) {
- GLEnv* gl_env_ptr = ConvertFromJava<GLEnv>(env, gl_env);
- ShaderProgram* program = gl_env_ptr ? ShaderProgram::CreateIdentity(gl_env_ptr) : NULL;
- return program ? WrapNewObjectInJava(program, env, false) : NULL;
-}
-
-jboolean Java_android_filterfw_core_ShaderProgram_setSourceRegion(JNIEnv* env,
- jobject thiz,
- jfloat x0,
- jfloat y0,
- jfloat x1,
- jfloat y1,
- jfloat x2,
- jfloat y2,
- jfloat x3,
- jfloat y3) {
- ShaderProgram* program = ConvertFromJava<ShaderProgram>(env, thiz);
- if (program) {
- program->SetSourceRegion(Quad(Point(x0, y0), Point(x1, y1), Point(x2, y2), Point(x3, y3)));
- return JNI_TRUE;
- }
- return JNI_FALSE;
-}
-
-jboolean Java_android_filterfw_core_ShaderProgram_setTargetRegion(JNIEnv* env,
- jobject thiz,
- jfloat x0,
- jfloat y0,
- jfloat x1,
- jfloat y1,
- jfloat x2,
- jfloat y2,
- jfloat x3,
- jfloat y3) {
- ShaderProgram* program = ConvertFromJava<ShaderProgram>(env, thiz);
- if (program) {
- program->SetTargetRegion(Quad(Point(x0, y0), Point(x1, y1), Point(x2, y2), Point(x3, y3)));
- return JNI_TRUE;
- }
- return JNI_FALSE;
-}
-
-jboolean Java_android_filterfw_core_ShaderProgram_setShaderClearsOutput(JNIEnv* env,
- jobject thiz,
- jboolean clears) {
- ShaderProgram* program = ConvertFromJava<ShaderProgram>(env, thiz);
- if (program) {
- program->SetClearsOutput(ToCppBool(clears));
- return JNI_TRUE;
- }
- return JNI_FALSE;
-}
-
-jboolean Java_android_filterfw_core_ShaderProgram_setShaderBlendEnabled(JNIEnv* env,
- jobject thiz,
- jboolean enable) {
- ShaderProgram* program = ConvertFromJava<ShaderProgram>(env, thiz);
- if (program) {
- program->SetBlendEnabled(ToCppBool(enable));
- return JNI_TRUE;
- }
- return JNI_FALSE;
-}
-
-jboolean Java_android_filterfw_core_ShaderProgram_setShaderBlendFunc(JNIEnv* env,
- jobject thiz,
- jint sfactor,
- jint dfactor) {
- ShaderProgram* program = ConvertFromJava<ShaderProgram>(env, thiz);
- if (program) {
- program->SetBlendFunc(sfactor, dfactor);
- return JNI_TRUE;
- }
- return JNI_FALSE;
-}
-
-jboolean Java_android_filterfw_core_ShaderProgram_setShaderClearColor(JNIEnv* env,
- jobject thiz,
- jfloat r,
- jfloat g,
- jfloat b) {
- ShaderProgram* program = ConvertFromJava<ShaderProgram>(env, thiz);
- if (program) {
- program->SetClearColor(r, g, b, 1.0f);
- return JNI_TRUE;
- }
- return JNI_FALSE;
-}
-
-jboolean Java_android_filterfw_core_ShaderProgram_setShaderDrawMode(JNIEnv* env,
- jobject thiz,
- jint draw_mode) {
- ShaderProgram* program = ConvertFromJava<ShaderProgram>(env, thiz);
- if (program) {
- program->SetDrawMode(draw_mode);
- return JNI_TRUE;
- }
- return JNI_FALSE;
-}
-
-jboolean Java_android_filterfw_core_ShaderProgram_setShaderTileCounts(JNIEnv* env,
- jobject thiz,
- jint x_count,
- jint y_count) {
- ShaderProgram* program = ConvertFromJava<ShaderProgram>(env, thiz);
- if (program) {
- program->SetTileCounts(x_count, y_count);
- return JNI_TRUE;
- }
- return JNI_FALSE;
-}
-
-jboolean Java_android_filterfw_core_ShaderProgram_setShaderVertexCount(JNIEnv* env,
- jobject thiz,
- jint vertex_count) {
- ShaderProgram* program = ConvertFromJava<ShaderProgram>(env, thiz);
- if (program) {
- program->SetVertexCount(vertex_count);
- return JNI_TRUE;
- }
- return JNI_FALSE;
-}
-
-jboolean Java_android_filterfw_core_ShaderProgram_beginShaderDrawing(JNIEnv* env, jobject thiz) {
- ShaderProgram* program = ConvertFromJava<ShaderProgram>(env, thiz);
- return ToJBool(program && program->BeginDraw());
-}
-
-jboolean Java_android_filterfw_core_ShaderProgram_setShaderAttributeValues(
- JNIEnv* env,
- jobject thiz,
- jstring attr_name,
- jfloatArray values,
- jint component_count) {
- ShaderProgram* program = ConvertFromJava<ShaderProgram>(env, thiz);
- if (program) {
- // Get the floats to set
- jfloat* float_ptr = env->GetFloatArrayElements(values, NULL);
- const int length = env->GetArrayLength(values);
-
- // Get the program variable to set
- const std::string attr_string = ToCppString(env, attr_name);
- ProgramVar program_var = program->GetAttribute(attr_string);
-
- // Set the variable
- if (float_ptr && ShaderProgram::IsVarValid(program_var)) {
- const bool success = program->SetAttributeValues(program_var,
- reinterpret_cast<float*>(float_ptr),
- length,
- component_count);
- env->ReleaseFloatArrayElements(values, float_ptr, JNI_ABORT);
- return ToJBool(success);
- }
- }
- return JNI_FALSE;
-}
-
-jboolean Java_android_filterfw_core_ShaderProgram_setShaderAttributeVertexFrame(
- JNIEnv* env,
- jobject thiz,
- jstring attr_name,
- jobject vertex_frame,
- jint type,
- jint component_count,
- jint stride,
- jint offset,
- jboolean normalize) {
- ShaderProgram* program = ConvertFromJava<ShaderProgram>(env, thiz);
- if (program) {
- // Get the vertex frame
- VertexFrame* v_frame = ConvertFromJava<VertexFrame>(env, vertex_frame);
-
- // Get the program variable to set
- const std::string attr_string = ToCppString(env, attr_name);
- ProgramVar program_var = program->GetAttribute(attr_string);
-
- // Set the variable
- if (v_frame && ShaderProgram::IsVarValid(program_var)) {
- const bool success = program->SetAttributeValues(program_var,
- v_frame,
- type,
- component_count,
- stride,
- offset,
- ToCppBool(normalize));
- return ToJBool(success);
- }
- }
- return JNI_FALSE;
-}
+++ /dev/null
-/*
- * 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.
- */
-
-#ifndef ANDROID_FILTERFW_JNI_SHADER_PROGRAM_H
-#define ANDROID_FILTERFW_JNI_SHADER_PROGRAM_H
-
-#include <jni.h>
-
-#include "native/core/value.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-JNIEXPORT jboolean JNICALL
-Java_android_filterfw_core_ShaderProgram_allocate(JNIEnv* env,
- jobject thiz,
- jobject gl_env,
- jstring vertex_shader,
- jstring fragment_shader);
-
-JNIEXPORT jboolean JNICALL
-Java_android_filterfw_core_ShaderProgram_deallocate(JNIEnv* env, jobject thiz);
-
-JNIEXPORT jboolean JNICALL
-Java_android_filterfw_core_ShaderProgram_compileAndLink(JNIEnv* env, jobject thiz);
-
-JNIEXPORT jboolean JNICALL
-Java_android_filterfw_core_ShaderProgram_setUniformValue(JNIEnv* env,
- jobject thiz,
- jstring key,
- jobject value);
-
-JNIEXPORT jobject JNICALL
-Java_android_filterfw_core_ShaderProgram_getUniformValue(JNIEnv* env,
- jobject thiz,
- jstring key);
-
-JNIEXPORT jboolean JNICALL
-Java_android_filterfw_core_ShaderProgram_shaderProcess(JNIEnv* env,
- jobject thiz,
- jobjectArray inputs,
- jobject output);
-
-JNIEXPORT jobject JNICALL
-Java_android_filterfw_core_ShaderProgram_nativeCreateIdentity(JNIEnv* env,
- jclass clazz,
- jobject gl_env);
-
-JNIEXPORT jboolean JNICALL
-Java_android_filterfw_core_ShaderProgram_setSourceRegion(JNIEnv* env,
- jobject thiz,
- jfloat x0,
- jfloat y0,
- jfloat x1,
- jfloat y1,
- jfloat x2,
- jfloat y2,
- jfloat x3,
- jfloat y3);
-
-JNIEXPORT jboolean JNICALL
-Java_android_filterfw_core_ShaderProgram_setTargetRegion(JNIEnv* env,
- jobject thiz,
- jfloat x0,
- jfloat y0,
- jfloat x1,
- jfloat y1,
- jfloat x2,
- jfloat y2,
- jfloat x3,
- jfloat y3);
-
-JNIEXPORT jboolean JNICALL
-Java_android_filterfw_core_ShaderProgram_setShaderClearsOutput(JNIEnv* env,
- jobject thiz,
- jboolean clears);
-
-JNIEXPORT jboolean JNICALL
-Java_android_filterfw_core_ShaderProgram_setShaderClearColor(JNIEnv* env,
- jobject thiz,
- jfloat r,
- jfloat g,
- jfloat b);
-
-JNIEXPORT jboolean JNICALL
-Java_android_filterfw_core_ShaderProgram_setShaderBlendEnabled(JNIEnv* env,
- jobject thiz,
- jboolean enable);
-
-JNIEXPORT jboolean JNICALL
-Java_android_filterfw_core_ShaderProgram_setShaderBlendFunc(JNIEnv* env,
- jobject thiz,
- jint sfactor,
- jint dfactor);
-JNIEXPORT jboolean JNICALL
-Java_android_filterfw_core_ShaderProgram_setShaderDrawMode(JNIEnv* env,
- jobject thiz,
- jint draw_mode);
-
-JNIEXPORT jboolean JNICALL
-Java_android_filterfw_core_ShaderProgram_setShaderTileCounts(JNIEnv* env,
- jobject thiz,
- jint x_count,
- jint y_count);
-
-JNIEXPORT jboolean JNICALL
-Java_android_filterfw_core_ShaderProgram_setShaderVertexCount(JNIEnv* env,
- jobject thiz,
- jint vertex_count);
-
-JNIEXPORT jboolean JNICALL
-Java_android_filterfw_core_ShaderProgram_beginShaderDrawing(JNIEnv* env, jobject thiz);
-
-JNIEXPORT jboolean JNICALL
-Java_android_filterfw_core_ShaderProgram_setShaderAttributeValues(JNIEnv* env,
- jobject thiz,
- jstring attr_name,
- jfloatArray values,
- jint component_count);
-
-JNIEXPORT jboolean JNICALL
-Java_android_filterfw_core_ShaderProgram_setShaderAttributeVertexFrame(JNIEnv* env,
- jobject thiz,
- jstring attr_name,
- jobject vertex_frame,
- jint type,
- jint component_count,
- jint stride,
- jint offset,
- jboolean normalize);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif // ANDROID_FILTERFW_JNI_SHADER_PROGRAM_H
+++ /dev/null
-/*
- * 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.
- */
-
-#include <string>
-
-#include "jni/jni_util.h"
-
-#include "base/logging.h"
-
-#if 0
-JavaObject::JavaObject()
- : object_(JNI_NULL),
- ref_count_(new int(0)) {
-}
-
-JavaObject::JavaObject(const JavaObject& java_obj)
- : object_(java_obj.object_),
- ref_count_(java_obj.ref_count_) {
- Retain();
-}
-
-JavaObject::JavaObject(jobject object, JNIEnv* env)
- : object_(NULL),
- ref_count_(new int(0)) {
- Retain();
- object_ = env->NewGlobalRef(object_);
-}
-
-JavaObject::~JavaObject() {
- Release();
-}
-
-JavaObject& JavaObject::operator=(const JavaObject& java_obj) {
- Release();
- object_ = java_obj.object_;
- ref_count_ = java_obj.ref_count_;
- Retain();
- return *this;
-}
-
-void JavaObject::Retain() {
- if (ref_count_)
- ++(*ref_count_);
- else
- ALOGE("JavaObject: Reference count is NULL! JavaObject may be corrupted.");
-}
-
-void JavaObject::Release() {
- if (ref_count_) {
- if (*ref_count_ > 0)
- --(*ref_count_);
- if (*ref_count_ == 0) {
- JNIEnv* env = GetCurrentJNIEnv();
- if (!env)
- ALOGE("JavaObject: Releasing outside of Java thread. Will just leak!");
- else if (object_)
- env->DeleteGlobalRef(object_);
- delete ref_count_;
- ref_count_ = NULL;
- }
- } else {
- ALOGE("JavaObject: Reference count is NULL! JavaObject may be corrupted.");
- }
-}
-
-void JavaObject::Reset() {
- Release();
- object_ = NULL;
- ref_count_ = new int(0);
-}
-
-JavaVM* GetCurrentJavaVM() {
- return g_current_java_vm_;
-}
-
-JNIEnv* GetCurrentJNIEnv() {
- JavaVM* vm = GetCurrentJavaVM();
- JNIEnv* env = NULL;
- const jint result = vm->GetEnv(reinterpret_cast<void**>(&env),
- JNI_VERSION_1_4);
- return result == JNI_OK ? env : NULL;
-}
-#endif
-
-jstring ToJString(JNIEnv* env, const std::string& value) {
- return env->NewStringUTF(value.c_str());
-}
-
-std::string ToCppString(JNIEnv* env, jstring value) {
- jboolean isCopy;
- const char* c_value = env->GetStringUTFChars(value, &isCopy);
- std::string result(c_value);
- if (isCopy == JNI_TRUE)
- env->ReleaseStringUTFChars(value, c_value);
- return result;
-}
-
-jboolean ToJBool(bool value) {
- return value ? JNI_TRUE : JNI_FALSE;
-}
-
-bool ToCppBool(jboolean value) {
- return value == JNI_TRUE;
-}
-
-// TODO: We actually shouldn't use such a function as it requires a class name lookup at every
-// invocation. Instead, store the class objects and use those.
-bool IsJavaInstanceOf(JNIEnv* env, jobject object, const std::string& class_name) {
- jclass clazz = env->FindClass(class_name.c_str());
- return clazz ? env->IsInstanceOf(object, clazz) == JNI_TRUE : false;
-}
-
-template<typename T>
-jobject CreateJObject(JNIEnv* env, const std::string& class_name, const std::string& signature, T value) {
- jobject result = JNI_NULL;
-
- return result;
-}
-
-Value ToCValue(JNIEnv* env, jobject object) {
- Value result = MakeNullValue();
- if (object != NULL) {
- if (IsJavaInstanceOf(env, object, "java/lang/Boolean")) {
- jmethodID method = env->GetMethodID(env->GetObjectClass(object), "booleanValue", "()Z");
- result = MakeIntValue(env->CallBooleanMethod(object, method) == JNI_TRUE ? 1 : 0);
- } else if (IsJavaInstanceOf(env, object, "java/lang/Integer")) {
- jmethodID method = env->GetMethodID(env->GetObjectClass(object), "intValue", "()I");
- result = MakeIntValue(env->CallIntMethod(object, method));
- } else if (IsJavaInstanceOf(env, object, "java/lang/Float")) {
- jmethodID method = env->GetMethodID(env->GetObjectClass(object), "floatValue", "()F");
- result = MakeFloatValue(env->CallFloatMethod(object, method));
- } else if (IsJavaInstanceOf(env, object, "java/lang/String")) {
- result = MakeStringValue(ToCppString(env, static_cast<jstring>(object)).c_str());
- } else if (IsJavaInstanceOf(env, object, "[I")) {
- jint* elems = env->GetIntArrayElements(static_cast<jintArray>(object), NULL);
- const jint count = env->GetArrayLength(static_cast<jintArray>(object));
- result = MakeIntArrayValue(elems, count);
- env->ReleaseIntArrayElements(static_cast<jintArray>(object), elems, JNI_ABORT);
- } else if (IsJavaInstanceOf(env, object, "[F")) {
- jfloat* elems = env->GetFloatArrayElements(static_cast<jfloatArray>(object), NULL);
- const jint count = env->GetArrayLength(static_cast<jfloatArray>(object));
- result = MakeFloatArrayValue(elems, count);
- env->ReleaseFloatArrayElements(static_cast<jfloatArray>(object), elems, JNI_ABORT);
- }
- }
- return result;
-}
-
-jobject ToJObject(JNIEnv* env, const Value& value) {
- jobject result = JNI_NULL;
- if (ValueIsInt(value)) {
- jclass clazz = env->FindClass("java/lang/Integer");
- jmethodID constructorID = env->GetMethodID(clazz, "<init>", "(I)V");
- result = env->NewObject(clazz, constructorID, GetIntValue(value));
- } else if (ValueIsFloat(value)) {
- jclass clazz = env->FindClass("java/lang/Float");
- jmethodID constructorID = env->GetMethodID(clazz, "<init>", "(F)V");
- result = env->NewObject(clazz, constructorID, GetFloatValue(value));
- } else if (ValueIsString(value)) {
- result = ToJString(env, GetStringValue(value));
- } else if (ValueIsIntArray(value)) {
- result = env->NewIntArray(GetValueCount(value));
- env->SetIntArrayRegion(static_cast<jintArray>(result),
- 0,
- GetValueCount(value),
- reinterpret_cast<const jint*>(GetIntArrayValue(value)));
- } else if (ValueIsFloatArray(value)) {
- result = env->NewFloatArray(GetValueCount(value));
- env->SetFloatArrayRegion(static_cast<jfloatArray>(result),
- 0,
- GetValueCount(value),
- reinterpret_cast<const jfloat*>(GetFloatArrayValue(value)));
- }
- return result;
-}
+++ /dev/null
-/*
- * 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.
- */
-
-#include <jni.h>
-
-#include <hash_map>
-#include <string>
-
-#include "base/utilities.h"
-#include "core/value.h"
-
-#ifndef ANDROID_FILTERFW_JNI_JNI_UTIL_H
-#define ANDROID_FILTERFW_JNI_JNI_UTIL_H
-
-// We add this JNI_NULL macro to allow consistent code separation of Java and
-// C++ types.
-#define JNI_NULL NULL
-
-#if 0
-// Pointer to current JavaVM. Do not use this directly. Instead use the funciton
-// GetCurrentJavaVM().
-extern JavaVM* g_current_java_vm_;
-
-// Wrapper around a java object pointer, which includes the environment
-// pointer in which the object "lives". This is used for passing down Java
-// objects from the Java layer to C++.
-// While an instance of this class does not own the underlying java object, it
-// does hold a global reference to it, so that the Java garbage collector does
-// not destroy it. It uses reference counting to determine when it can destroy
-// the reference.
-// TODO: Add multi-thread support!
-class JavaObject {
- public:
- // Creates a NULL JavaObject.
- JavaObject();
-
- // Creates a wrapper around the given object in the given JNI environment.
- JavaObject(jobject object, JNIEnv* env);
-
- // Copy constructor.
- JavaObject(const JavaObject& java_obj);
-
- // Destructor.
- ~JavaObject();
-
- // Assignment operator.
- JavaObject& operator=(const JavaObject& java_obj);
-
- // Access to the object (non-const as JNI functions are non-const).
- jobject object() const {
- return object_;
- }
-
- // Resets this object to the NULL JavaObject.
- void Reset();
-
- private:
- // Retain the instance, i.e. increase reference count.
- void Retain();
-
- // Release the instance, i.e. decrease reference count.
- void Release();
-
- // The object pointer (not owned).
- jobject object_;
-
- // The reference count of this object
- int* ref_count_;
-};
-#endif
-
-// ObjectPool template class. This class keeps track of C++ instances that are
-// coupled to Java objects. This is done by using an "id" field in the Java
-// object, which is then mapped to the correct instance here. It should not be
-// necessary to use this class directly. Instead, the convenience functions
-// below can be used.
-template<class T>
-class ObjectPool {
- public:
- // Create a new ObjectPool for a specific object type. Pass the path to the
- // Java equivalent class of the C++ class, and the name of the java member
- // field that will store the object's ID.
- static void Setup(const std::string& jclass_name,
- const std::string& id_fld_name) {
- instance_ = new ObjectPool<T>(jclass_name, id_fld_name);
- }
-
- // Return the shared instance to this type's pool.
- static ObjectPool* Instance() {
- return instance_;
- }
-
- // Delete this type's pool.
- static void TearDown() {
- delete instance_;
- }
-
- // Register a new C++ object with the pool. This does not affect the Java
- // layer. Use WrapObject() instead to perform the necessary Java-side
- // assignments. Pass true to owns if the object pool owns the object.
- int RegisterObject(T* object, bool owns) {
- const int id = next_id_;
- objects_[id] = object;
- owns_[id] = owns;
- ++next_id_;
- return id;
- }
-
- // Return the object in the pool with the specified ID.
- T* ObjectWithID(int obj_id) const {
- typename CObjMap::const_iterator iter = objects_.find(obj_id);
- return iter == objects_.end() ? NULL : iter->second;
- }
-
- // Get the ID of a Java object. This ID can be used to look-up the C++
- // object.
- int GetObjectID(JNIEnv* env, jobject j_object) {
- jclass cls = env->GetObjectClass(j_object);
- jfieldID id_field = env->GetFieldID(cls, id_field_name_.c_str(), "I");
- const int result = env->GetIntField(j_object, id_field);
- env->DeleteLocalRef(cls);
- return result;
- }
-
- // Take a C++ object and wrap it with a given Java object. This will
- // essentially set the ID member of the Java object to the ID of the C++
- // object. Pass true to owns if the object pool owns the object.
- bool WrapObject(T* c_object, JNIEnv* env, jobject j_object, bool owns) {
- const int id = RegisterObject(c_object, owns);
- jclass cls = env->GetObjectClass(j_object);
- jfieldID id_field = env->GetFieldID(cls, id_field_name_.c_str(), "I");
- env->SetIntField(j_object, id_field, id);
- env->DeleteLocalRef(cls);
- return true;
- }
-
- // Remove the object with the given ID from this pool, and delete it. This
- // does not affect the Java layer.
- bool DeleteObjectWithID(int obj_id) {
- typename CObjMap::iterator iter = objects_.find(obj_id);
- const bool found = iter != objects_.end();
- if (found) {
- if (owns_[obj_id])
- delete iter->second;
- objects_.erase(iter);
- }
- return found;
- }
-
- // Instantiates a new java object for this class. The Java class must have
- // a default constructor for this to succeed.
- jobject CreateJavaObject(JNIEnv* env) {
- jclass cls = env->FindClass(jclass_name_.c_str());
- jmethodID constructor = env->GetMethodID(
- cls,
- "<init>",
- "(Landroid/filterfw/core/NativeAllocatorTag;)V");
- jobject result = env->NewObject(cls, constructor, JNI_NULL);
- env->DeleteLocalRef(cls);
- return result;
- }
-
- int GetObjectCount() const {
- return objects_.size();
- }
-
- const std::string& GetJavaClassName() const {
- return jclass_name_;
- }
-
- private:
- explicit ObjectPool(const std::string& jclass_name,
- const std::string& id_fld_name)
- : jclass_name_(jclass_name),
- id_field_name_(id_fld_name),
- next_id_(0) { }
-
- typedef std::hash_map<int, T*> CObjMap;
- typedef std::hash_map<int, bool> FlagMap;
- static ObjectPool* instance_;
- std::string jclass_name_;
- std::string id_field_name_;
- int next_id_;
- CObjMap objects_;
- FlagMap owns_;
-
- DISALLOW_COPY_AND_ASSIGN(ObjectPool);
-};
-
-template<typename T> ObjectPool<T>* ObjectPool<T>::instance_ = NULL;
-
-// Convenience Functions ///////////////////////////////////////////////////////
-
-// This function "links" the C++ instance and the Java instance, so that they
-// can be mapped to one another. This must be called for every C++ instance
-// which is wrapped by a Java front-end interface. Pass true to owns, if the
-// Java layer should own the object.
-template<typename T>
-bool WrapObjectInJava(T* c_object, JNIEnv* env, jobject j_object, bool owns) {
- ObjectPool<T>* pool = ObjectPool<T>::Instance();
- return pool ? pool->WrapObject(c_object, env, j_object, owns) : false;
-}
-
-// Creates a new Java instance, which wraps the passed C++ instance. Returns
-// the wrapped object or JNI_NULL if there was an error. Pass true to owns, if
-// the Java layer should own the object.
-template<typename T>
-jobject WrapNewObjectInJava(T* c_object, JNIEnv* env, bool owns) {
- ObjectPool<T>* pool = ObjectPool<T>::Instance();
- if (pool) {
- jobject result = pool->CreateJavaObject(env);
- if (WrapObjectInJava(c_object, env, result, owns))
- return result;
- }
- return JNI_NULL;
-}
-
-// Use ConvertFromJava to obtain a C++ instance given a Java object. This
-// instance must have been wrapped in Java using the WrapObjectInJava()
-// function.
-template<typename T>
-T* ConvertFromJava(JNIEnv* env, jobject j_object) {
- ObjectPool<T>* pool = ObjectPool<T>::Instance();
- return pool && j_object
- ? pool->ObjectWithID(pool->GetObjectID(env, j_object))
- : NULL;
-}
-
-// Delete the native object given a Java instance. This should be called from
-// the Java object's finalizer.
-template<typename T>
-bool DeleteNativeObject(JNIEnv* env, jobject j_object) {
- ObjectPool<T>* pool = ObjectPool<T>::Instance();
- return pool && j_object
- ? pool->DeleteObjectWithID(pool->GetObjectID(env, j_object))
- : false;
-}
-
-#if 0
-// Get the current JNI VM, or NULL if there is no current VM
-JavaVM* GetCurrentJavaVM();
-
-// Get the current JNI environment, or NULL if this is not a JNI thread
-JNIEnv* GetCurrentJNIEnv();
-#endif
-
-// Convert C++ boolean to Java boolean.
-jboolean ToJBool(bool value);
-
-// Convert Java boolean to C++ boolean.
-bool ToCppBool(jboolean value);
-
-// Convert Java String to C++ string.
-jstring ToJString(JNIEnv* env, const std::string& value);
-
-// Convert C++ string to Java String.
-std::string ToCppString(JNIEnv* env, jstring value);
-
-// Convert Java object to a (C) Value object.
-Value ToCValue(JNIEnv* env, jobject object);
-
-// Convert a (C) Value object to a Java object.
-jobject ToJObject(JNIEnv* env, const Value& value);
-
-// Returns true, iff the passed object is an instance of the class specified
-// by its fully qualified class name.
-bool IsJavaInstanceOf(JNIEnv* env, jobject object,
- const std::string& class_name);
-
-#endif // ANDROID_FILTERFW_JNI_JNI_UTIL_H
+++ /dev/null
-/*
- * 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.
- */
-
-#include "jni/jni_vertex_frame.h"
-#include "jni/jni_util.h"
-
-#include "native/core/vertex_frame.h"
-
-using android::filterfw::VertexFrame;
-
-jboolean Java_android_filterfw_core_VertexFrame_nativeAllocate(JNIEnv* env,
- jobject thiz,
- jint size) {
- return ToJBool(WrapObjectInJava(new VertexFrame(size), env, thiz, true));
-}
-
-jboolean Java_android_filterfw_core_VertexFrame_nativeDeallocate(JNIEnv* env, jobject thiz) {
- return ToJBool(DeleteNativeObject<VertexFrame>(env, thiz));
-}
-
-jboolean Java_android_filterfw_core_VertexFrame_setNativeInts(JNIEnv* env,
- jobject thiz,
- jintArray ints) {
-
- VertexFrame* frame = ConvertFromJava<VertexFrame>(env, thiz);
- if (frame && ints) {
- jint* int_ptr = env->GetIntArrayElements(ints, NULL);
- const int length = env->GetArrayLength(ints);
- if (int_ptr) {
- const bool success = frame->WriteData(reinterpret_cast<const uint8_t*>(int_ptr),
- length * sizeof(jint));
- env->ReleaseIntArrayElements(ints, int_ptr, JNI_ABORT);
- return ToJBool(success);
- }
- }
- return JNI_FALSE;
-}
-
-jboolean Java_android_filterfw_core_VertexFrame_setNativeFloats(JNIEnv* env,
- jobject thiz,
- jfloatArray floats) {
- VertexFrame* frame = ConvertFromJava<VertexFrame>(env, thiz);
- if (frame && floats) {
- jfloat* float_ptr = env->GetFloatArrayElements(floats, NULL);
- const int length = env->GetArrayLength(floats);
- if (float_ptr) {
- const bool success = frame->WriteData(reinterpret_cast<const uint8_t*>(float_ptr),
- length * sizeof(jfloat));
- env->ReleaseFloatArrayElements(floats, float_ptr, JNI_ABORT);
- return ToJBool(success);
- }
- }
- return JNI_FALSE;
-}
-
-jboolean Java_android_filterfw_core_VertexFrame_setNativeData(JNIEnv* env,
- jobject thiz,
- jbyteArray data,
- jint offset,
- jint length) {
- VertexFrame* frame = ConvertFromJava<VertexFrame>(env, thiz);
- if (frame && data) {
- jbyte* bytes = env->GetByteArrayElements(data, NULL);
- if (bytes) {
- const bool success = frame->WriteData(reinterpret_cast<const uint8_t*>(bytes + offset),
- length);
- env->ReleaseByteArrayElements(data, bytes, JNI_ABORT);
- return ToJBool(success);
- }
- }
- return JNI_FALSE;
-}
-
-jint Java_android_filterfw_core_VertexFrame_getNativeVboId(JNIEnv* env, jobject thiz) {
- VertexFrame* frame = ConvertFromJava<VertexFrame>(env, thiz);
- return frame ? frame->GetVboId() : -1;
-}
+++ /dev/null
-/*
- * 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.
- */
-
-#ifndef ANDROID_FILTERFW_JNI_VERTEX_FRAME_H
-#define ANDROID_FILTERFW_JNI_VERTEX_FRAME_H
-
-#include <jni.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-JNIEXPORT jboolean JNICALL
-Java_android_filterfw_core_VertexFrame_nativeAllocate(JNIEnv* env, jobject thiz, jint size);
-
-JNIEXPORT jboolean JNICALL
-Java_android_filterfw_core_VertexFrame_nativeDeallocate(JNIEnv* env, jobject thiz);
-
-JNIEXPORT jboolean JNICALL
-Java_android_filterfw_core_VertexFrame_setNativeInts(JNIEnv* env, jobject thiz, jintArray ints);
-
-JNIEXPORT jboolean JNICALL
-Java_android_filterfw_core_VertexFrame_setNativeFloats(JNIEnv* env,
- jobject thiz,
- jfloatArray floats);
-
-JNIEXPORT jboolean JNICALL
-Java_android_filterfw_core_VertexFrame_setNativeData(JNIEnv* env,
- jobject thiz,
- jbyteArray data,
- jint offset,
- jint length);
-
-JNIEXPORT jint JNICALL
-Java_android_filterfw_core_VertexFrame_getNativeVboId(JNIEnv* env, jobject thiz);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif // ANDROID_FILTERFW_JNI_VERTEX_FRAME_H
+++ /dev/null
-# 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.
-#
-
-LOCAL_PATH := $(call my-dir)
-
-#####################
-# Build module libfilterfw_static
-
-include $(CLEAR_VARS)
-
-LOCAL_MODULE_TAGS := optional
-
-LOCAL_MODULE := libfilterfw_native
-
-LOCAL_SRC_FILES += core/geometry.cpp \
- core/gl_env.cpp \
- core/gl_frame.cpp \
- core/native_frame.cpp \
- core/native_program.cpp \
- core/shader_program.cpp \
- core/vertex_frame.cpp \
- core/value.cpp
-
-# add local includes
-include $(LOCAL_PATH)/libfilterfw.mk
-
-# gcc should always be placed at the end.
-LOCAL_EXPORT_LDLIBS := -llog -lgcc
-
-# TODO: Build a shared library as well?
-include $(BUILD_STATIC_LIBRARY)
-
+++ /dev/null
-/*
- * 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.
- */
-
-#ifndef ANDROID_FILTERFW_BASE_LOGGING_H
-#define ANDROID_FILTERFW_BASE_LOGGING_H
-
-#define LOG_EVERY_FRAME false
-
-#define LOG_FRAME(...) if (LOG_EVERY_FRAME) __android_log_print(ANDROID_LOG_VERBOSE, LOG_TAG, __VA_ARGS__)
-
-#define LOG_TAG "MCA"
-#include <utils/Log.h>
-
-#endif // ANDROID_FILTERFW_BASE_LOGGING_H
+++ /dev/null
-/*
- * 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.
- */
-
-#ifndef ANDROID_FILTERFW_BASE_UTILITIES_H
-#define ANDROID_FILTERFW_BASE_UTILITIES_H
-
-#include <set>
-#include <utility>
-
-namespace android {
-namespace filterfw {
-
-// Convenience Macro to make copy constructor and assignment operator private
-// (thereby disallowing copying and assigning).
-#define DISALLOW_COPY_AND_ASSIGN(TypeName) \
- TypeName(const TypeName&); \
- void operator=(const TypeName&)
-
-// A macro to disallow all the implicit constructors, namely the
-// default constructor, copy constructor and operator= functions.
-#define DISALLOW_IMPLICIT_CONSTRUCTORS(TypeName) \
- TypeName(); \
- DISALLOW_COPY_AND_ASSIGN(TypeName)
-
-// STLDeleteContainerPointers()
-// For a range within a container of pointers, calls delete
-// (non-array version) on these pointers.
-// NOTE: for these three functions, we could just implement a DeleteObject
-// functor and then call for_each() on the range and functor, but this
-// requires us to pull in all of algorithm.h, which seems expensive.
-// For hash_[multi]set, it is important that this deletes behind the iterator
-// because the hash_set may call the hash function on the iterator when it is
-// advanced, which could result in the hash function trying to deference a
-// stale pointer.
-template <class ForwardIterator>
-void STLDeleteContainerPointers(ForwardIterator begin,
- ForwardIterator end) {
- while (begin != end) {
- ForwardIterator temp = begin;
- ++begin;
- delete *temp;
- }
-}
-
-// Given an STL container consisting of (key, value) pairs, STLDeleteValues
-// deletes all the "value" components and clears the container. Does nothing
-// in the case it's given a NULL pointer.
-template <class T>
-void STLDeleteValues(T *v) {
- if (!v) return;
- for (typename T::iterator i = v->begin(); i != v->end(); ++i) {
- delete i->second;
- }
- v->clear();
-}
-
-// Perform a lookup in a map or hash_map.
-// If the key is present a const pointer to the associated value is returned,
-// otherwise a NULL pointer is returned.
-template <class Collection>
-const typename Collection::value_type::second_type*
-FindOrNull(const Collection& collection,
- const typename Collection::value_type::first_type& key) {
- typename Collection::const_iterator it = collection.find(key);
- if (it == collection.end()) {
- return 0;
- }
- return &it->second;
-}
-
-// A simple class that gives checklist functionality: There are essemtially two
-// operations defined on a CheckList:
-// - Adding a new (unchecked) item.
-// - Checking off an item.
-// When checking off the last remaining item CheckItem() returns true.
-template<typename T>
-class CheckList {
- public:
- // Add a new unchecked item. Does nothing if item is already in checklist.
- void AddItem(const T& item);
-
- // Check off an item in the checklist. Returns true if all items have been
- // checked.
- bool CheckItem(const T& item);
-
- // Clear the checklist.
- void Clear() {
- items_.clear();
- }
-
- private:
- std::set<T> items_;
-};
-
-template<typename T>
-void CheckList<T>::AddItem(const T& item) {
- if (!ContainsKey(items_, item))
- items_.insert(item);
-}
-
-template<typename T>
-bool CheckList<T>::CheckItem(const T& item) {
- typename std::set<T>::iterator iter = items_.find(item);
- if (iter != items_.end())
- items_.erase(iter);
- return items_.empty();
-}
-
-// Perform a lookup in a map or hash_map whose values are pointers.
-// If the key is present a const pointer to the associated value is returned,
-// otherwise a NULL pointer is returned.
-// This function does not distinguish between a missing key and a key mapped
-// to a NULL value.
-template <class Collection>
-const typename Collection::value_type::second_type
-FindPtrOrNull(const Collection& collection,
- const typename Collection::value_type::first_type& key) {
- typename Collection::const_iterator it = collection.find(key);
- if (it == collection.end()) {
- return 0;
- }
- return it->second;
-}
-
-// Test to see if a set, map, hash_set or hash_map contains a particular key.
-// Returns true if the key is in the collection.
-template <typename Collection, typename Key>
-bool ContainsKey(const Collection& collection, const Key& key) {
- return collection.find(key) != collection.end();
-}
-
-// Insert a new key and value into a map or hash_map.
-// If the key is not present in the map the key and value are
-// inserted, otherwise nothing happens. True indicates that an insert
-// took place, false indicates the key was already present.
-template <class Collection, class Key, class Value>
-bool InsertIfNotPresent(Collection * const collection,
- const Key& key, const Value& value) {
- std::pair<typename Collection::iterator, bool> ret =
- collection->insert(typename Collection::value_type(key, value));
- return ret.second;
-}
-
-} // namespace filterfw
-} // namespace android
-
-#endif // ANDROID_FILTERFW_BASE_UTILITIES_H
+++ /dev/null
-/*
- * 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.
- */
-
-#include "core/geometry.h"
-
-#include <cmath>
-
-#include "base/logging.h"
-
-namespace android {
-namespace filterfw {
-
-float Point::Length() const {
- return std::sqrt(x_ * x_ + y_ * y_);
-}
-
-bool Point::ScaleTo(float new_length) {
- float length = Length();
- if (length == 0.0f) {
- return false;
- }
- x_ *= new_length / length;
- y_ *= new_length / length;
- return true;
-}
-
-float Point::Distance(const Point& p0, const Point& p1) {
- Point diff = p1 - p0;
- return diff.Length();
-}
-
-Point Point::operator+(const Point& other) const {
- Point out;
- out.x_ = x_ + other.x_;
- out.y_ = y_ + other.y_;
- return out;
-}
-
-Point Point::operator-(const Point& other) const {
- Point out;
- out.x_ = x_ - other.x_;
- out.y_ = y_ - other.y_;
- return out;
-}
-
-Point Point::operator*(float factor) const {
- Point out;
- out.x_ = factor * x_;
- out.y_ = factor * y_;
- return out;
-}
-
-void Point::Rotate90Clockwise() {
- const float x = x_;
- x_ = y_;
- y_ = -x;
-}
-
-bool Rect::ExpandToAspectRatio(float ratio) {
- if (width <= 0.0f || height <= 0.0f || ratio <= 0.0f) {
- return false;
- }
-
- const float current_ratio = width / height;
- if (current_ratio < ratio) {
- const float dx = width * (ratio / current_ratio - 1.0f);
- x -= dx / 2.0f;
- width += dx;
- } else {
- const float dy = height * (current_ratio / ratio - 1.0f);
- y -= dy / 2.0f;
- height += dy;
- }
- return true;
-}
-
-bool Rect::ExpandToMinLength(float length) {
- if (width <= 0.0f || height <= 0.0f || length <= 0.0f) {
- return false;
- }
-
- const float current_length = width > height ? width : height;
- if (length > current_length) {
- const float dx = width * (length / current_length - 1.0f);
- x -= dx / 2.0f;
- width += dx;
- const float dy = height * (length / current_length - 1.0f);
- y -= dy / 2.0f;
- height += dy;
- }
- return true;
-}
-
-bool Rect::ScaleWithLengthLimit(float factor, float max_length) {
- if (width <= 0.0f || height <= 0.0f || factor <= 0.0f) {
- return false;
- }
-
- const float current_length = width > height ? width : height;
- if (current_length >= max_length) {
- return true;
- }
-
- float f = factor;
- if (current_length * f > max_length) {
- f *= max_length / (current_length * f);
- }
-
- const float dx = width * (f - 1.0f);
- x -= dx / 2.0f;
- width += dx;
- const float dy = height * (f - 1.0f);
- y -= dy / 2.0f;
- height += dy;
- return true;
-}
-
-const Point& Quad::point(int ix) const {
- ALOG_ASSERT(ix < static_cast<int>(points_.size()), "Access out of bounds");
- return points_[ix];
-}
-
-} // namespace filterfw
-} // namespace android
+++ /dev/null
-/*
- * 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.
- */
-
-#ifndef ANDROID_FILTERFW_CORE_GEOMETRY_H
-#define ANDROID_FILTERFW_CORE_GEOMETRY_H
-
-#include <vector>
-
-namespace android {
-namespace filterfw {
-
-// This is an initial implementation of some geometrical structures. This is
-// likely to grow and become more sophisticated in the future.
-
-class Point {
- public:
- Point() : x_(0.0f), y_(0.0f) {}
- Point(float x, float y) : x_(x), y_(y) {}
-
- float x() const { return x_; }
- float y() const { return y_; }
-
- float Length() const;
- bool ScaleTo(float new_length);
- static float Distance(const Point& p0, const Point& p1);
-
- // Add more of these as needed:
- Point operator+(const Point& other) const;
- Point operator-(const Point& other) const;
- Point operator*(float factor) const;
-
- void Rotate90Clockwise();
-
- private:
- float x_, y_;
-};
-
-class Quad {
- public:
- Quad() : points_(4) {}
- virtual ~Quad() {}
-
- Quad(const Point& p0, const Point& p1, const Point& p2, const Point& p3)
- : points_(4) {
- points_[0] = p0;
- points_[1] = p1;
- points_[2] = p2;
- points_[3] = p3;
- }
-
- const std::vector<Point>& points() const { return points_; }
- const Point& point(int ix) const;
-
- protected:
- std::vector<Point> points_;
-};
-
-struct Rect {
- float x, y, width, height;
-
- Rect() {
- x = y = 0.0f;
- width = height = 1.0f;
- }
-
- Rect(float x, float y, float width, float height) {
- this->x = x;
- this->y = y;
- this->width = width;
- this->height = height;
- }
-
- bool ExpandToAspectRatio(float ratio);
- bool ExpandToMinLength(float length);
- bool ScaleWithLengthLimit(float factor, float max_length);
-};
-
-} // namespace filterfw
-} // namespace android
-
-#endif // ANDROID_FILTERFW_CORE_GEOMETRY_H
+++ /dev/null
-/*
- * 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.
- */
-
-#ifndef ANDROID_FILTERFW_CORE_GL_BUFFER_INTERFACE_H
-#define ANDROID_FILTERFW_CORE_GL_BUFFER_INTERFACE_H
-
-#include <GLES2/gl2.h>
-
-namespace android {
-namespace filterfw {
-
-class GLTextureHandle {
- public:
- virtual ~GLTextureHandle() { }
-
- // Returns the held texture id.
- virtual GLuint GetTextureId() const = 0;
-
- // Binds the held texture. This may result in creating the texture if it
- // is not yet available.
- virtual bool FocusTexture() = 0;
-
- // Generates the mipmap chain of the held texture. Returns true, iff
- // generating was successful.
- virtual bool GenerateMipMap() = 0;
-
- // Set a texture parameter (see glTextureParameter documentation). Returns
- // true iff the parameter was set successfully.
- virtual bool SetTextureParameter(GLenum pname, GLint value) = 0;
-
- // Returns the texture target used.
- // Texture Target should be: GL_TEXTURE_2D, GL_TEXTURE_EXTERNAL_OES.
- virtual GLuint GetTextureTarget() const = 0;
-};
-
-class GLFrameBufferHandle {
- public:
- virtual ~GLFrameBufferHandle() { }
-
- // Returns the held FBO id.
- virtual GLuint GetFboId() const = 0;
-
- // Binds the held FBO. This may result in creating the FBO if it
- // is not yet available.
- virtual bool FocusFrameBuffer() = 0;
-};
-
-// Interface to instances that hold GL textures and frame-buffer-objects.
-// The GLFrame class implements this interface.
-class GLBufferHandle : public GLTextureHandle, public GLFrameBufferHandle {
- public:
- virtual ~GLBufferHandle() { }
-};
-
-} // namespace filterfw
-} // namespace android
-
-#endif // ANDROID_FILTERFW_CORE_GL_BUFFER_INTERFACE_H
+++ /dev/null
-/*
- * 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.
- */
-// #define LOG_NDEBUG 0
-
-#include "base/logging.h"
-#include "base/utilities.h"
-#include "core/gl_env.h"
-#include "core/shader_program.h"
-#include "core/vertex_frame.h"
-#include "system/window.h"
-
-#include <map>
-#include <string>
-#include <EGL/eglext.h>
-
-namespace android {
-namespace filterfw {
-
-GLEnv::GLEnv()
- : display_(EGL_NO_DISPLAY),
- context_id_(0),
- surface_id_(0),
- max_surface_id_(0),
- created_context_(false),
- created_surface_(false),
- initialized_(false) {
-}
-
-GLEnv::~GLEnv() {
- // Destroy surfaces
- for (std::map<int, SurfaceWindowPair>::iterator it = surfaces_.begin();
- it != surfaces_.end();
- ++it) {
- if (it->first != 0 || created_surface_) {
- eglDestroySurface(display(), it->second.first);
- if (it->second.second) {
- it->second.second->Destroy();
- delete it->second.second;
- }
- }
- }
-
- // Destroy contexts
- for (std::map<int, EGLContext>::iterator it = contexts_.begin();
- it != contexts_.end();
- ++it) {
- if (it->first != 0 || created_context_)
- eglDestroyContext(display(), it->second);
- }
-
- // Destroy attached shaders and frames
- STLDeleteValues(&attached_shaders_);
- STLDeleteValues(&attached_vframes_);
-
- // Destroy display
- if (initialized_)
- eglTerminate(display());
-
- // Log error if this did not work
- if (CheckEGLError("TearDown!"))
- ALOGE("GLEnv: Error tearing down GL Environment!");
-}
-
-bool GLEnv::IsInitialized() const {
- return (contexts_.size() > 0 &&
- surfaces_.size() > 0 &&
- display_ != EGL_NO_DISPLAY);
-}
-
-bool GLEnv::Deactivate() {
- eglMakeCurrent(display(), EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
- return !CheckEGLError("eglMakeCurrent");
-}
-
-bool GLEnv::Activate() {
- ALOGV("Activate()");
- if (display() != eglGetCurrentDisplay() ||
- context() != eglGetCurrentContext() ||
- surface() != eglGetCurrentSurface(EGL_DRAW)) {
- // Make sure we are initialized
- if (context() == EGL_NO_CONTEXT || surface() == EGL_NO_SURFACE)
- return false;
-
- // Make our context current
- ALOGV("eglMakeCurrent");
- eglMakeCurrent(display(), surface(), surface(), context());
-
- return !CheckEGLMakeCurrentError();
- }
- return true;
-}
-
-bool GLEnv::SwapBuffers() {
- const bool result = eglSwapBuffers(display(), surface()) == EGL_TRUE;
- return !CheckEGLError("eglSwapBuffers") && result;
-}
-
-bool GLEnv::InitWithCurrentContext() {
- if (IsInitialized())
- return true;
-
- display_ = eglGetCurrentDisplay();
- contexts_[0] = eglGetCurrentContext();
- surfaces_[0] = SurfaceWindowPair(eglGetCurrentSurface(EGL_DRAW), NULL);
-
- return (context() != EGL_NO_CONTEXT) &&
- (display() != EGL_NO_DISPLAY) &&
- (surface() != EGL_NO_SURFACE);
-}
-
-bool GLEnv::InitWithNewContext() {
- if (IsInitialized()) {
- ALOGE("GLEnv: Attempting to reinitialize environment!");
- return false;
- }
-
- display_ = eglGetDisplay(EGL_DEFAULT_DISPLAY);
- if (CheckEGLError("eglGetDisplay")) return false;
-
- EGLint majorVersion;
- EGLint minorVersion;
- eglInitialize(display(), &majorVersion, &minorVersion);
- if (CheckEGLError("eglInitialize")) return false;
- initialized_ = true;
-
- // Configure context/surface
- EGLConfig config;
- EGLint numConfigs = -1;
-
- // TODO(renn): Do we need the window bit here?
- // TODO: Currently choosing the config that includes all
- // This is not needed if the encoding is not being used
- EGLint configAttribs[] = {
- EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
- EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
- EGL_RED_SIZE, 8,
- EGL_GREEN_SIZE, 8,
- EGL_BLUE_SIZE, 8,
- EGL_RECORDABLE_ANDROID, EGL_TRUE,
- EGL_NONE
- };
-
- eglChooseConfig(display(), configAttribs, &config, 1, &numConfigs);
- if (numConfigs < 1) {
- ALOGE("GLEnv::Init: No suitable EGL configuration found!");
- return false;
- }
-
- // Create dummy surface using a SurfaceTexture
- surfaceTexture_ = new SurfaceTexture(0);
- window_ = new SurfaceTextureClient(static_cast<sp<ISurfaceTexture> >(
- surfaceTexture_->getBufferQueue()));
-
- surfaces_[0] = SurfaceWindowPair(eglCreateWindowSurface(display(), config, window_.get(), NULL), NULL);
- if (CheckEGLError("eglCreateWindowSurface")) return false;
-
- // Create context
- EGLint context_attribs[] = { EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE };
- contexts_[0] = eglCreateContext(display(),
- config,
- EGL_NO_CONTEXT,
- context_attribs);
- if (CheckEGLError("eglCreateContext")) return false;
-
- created_context_ = created_surface_ = true;
-
- return true;
-}
-
-bool GLEnv::IsActive() const {
- ALOGV("IsActive()");
- return context() == eglGetCurrentContext()
- && display() == eglGetCurrentDisplay()
- && surface() == eglGetCurrentSurface(EGL_DRAW);
-}
-
-bool GLEnv::IsContextActive() const {
- return context() == eglGetCurrentContext();
-}
-
-bool GLEnv::IsAnyContextActive() {
- return eglGetCurrentContext() != EGL_NO_CONTEXT;
-}
-
-int GLEnv::AddWindowSurface(const EGLSurface& surface, WindowHandle* window_handle) {
- const int id = ++max_surface_id_;
- surfaces_[id] = SurfaceWindowPair(surface, window_handle);
- return id;
-}
-
-int GLEnv::AddSurface(const EGLSurface& surface) {
- return AddWindowSurface(surface, NULL);
-}
-
-bool GLEnv::SwitchToSurfaceId(int surface_id) {
- ALOGV("SwitchToSurfaceId");
- if (surface_id_ != surface_id) {
- const SurfaceWindowPair* surface = FindOrNull(surfaces_, surface_id);
- if (surface) {
- bool wasActive = IsActive();
- surface_id_ = surface_id;
- return wasActive ? Activate() : true;
- }
- return false;
- }
- return true;
-}
-
-bool GLEnv::ReleaseSurfaceId(int surface_id) {
- if (surface_id > 0) {
- const SurfaceWindowPair* surface_window_pair = FindOrNull(surfaces_, surface_id);
- if (surface_window_pair) {
- if (surface_id_ == surface_id)
- SwitchToSurfaceId(0);
- eglDestroySurface(display(), surface_window_pair->first);
- if (surface_window_pair->second) {
- surface_window_pair->second->Destroy();
- delete surface_window_pair->second;
- }
- surfaces_.erase(surface_id);
- return true;
- }
- }
- return false;
-}
-
-bool GLEnv::SetSurfaceTimestamp(int64_t timestamp) {
- if (surface_id_ > 0) {
- const SurfaceWindowPair* surface_window_pair = FindOrNull(surfaces_,
- surface_id_);
- if (surface_window_pair) {
- ANativeWindow *window = static_cast<ANativeWindow*>(
- surface_window_pair->second->InternalHandle());
- native_window_set_buffers_timestamp(window, timestamp);
- return true;
- }
- }
- return false;
-}
-
-int GLEnv::FindSurfaceIdForWindow(const WindowHandle* window_handle) {
- for (std::map<int, SurfaceWindowPair>::iterator it = surfaces_.begin();
- it != surfaces_.end();
- ++it) {
- const WindowHandle* my_handle = it->second.second;
- if (my_handle && my_handle->Equals(window_handle)) {
- return it->first;
- }
- }
- return -1;
-}
-
-
-int GLEnv::AddContext(const EGLContext& context) {
- const int id = contexts_.size();
- contexts_[id] = context;
- return id;
-}
-
-bool GLEnv::SwitchToContextId(int context_id) {
- const EGLContext* context = FindOrNull(contexts_, context_id);
- if (context) {
- if (context_id_ != context_id) {
- context_id_ = context_id;
- return Activate();
- }
- return true;
- }
- return false;
-}
-
-void GLEnv::ReleaseContextId(int context_id) {
- if (context_id > 0) {
- const EGLContext* context = FindOrNull(contexts_, context_id);
- if (context) {
- contexts_.erase(context_id);
- if (context_id_ == context_id && IsActive())
- SwitchToContextId(0);
- eglDestroyContext(display(), *context);
- }
- }
-}
-
-bool GLEnv::CheckGLError(const std::string& op) {
- bool err = false;
- for (GLint error = glGetError(); error; error = glGetError()) {
- ALOGE("GL Error: Operation '%s' caused GL error (0x%x)\n",
- op.c_str(),
- error);
- err = true;
- }
- return err;
-}
-
-bool GLEnv::CheckEGLError(const std::string& op) {
- bool err = false;
- for (EGLint error = eglGetError();
- error != EGL_SUCCESS;
- error = eglGetError()) {
- ALOGE("EGL Error: Operation '%s' caused EGL error (0x%x)\n",
- op.c_str(),
- error);
- err = true;
- }
- return err;
-}
-
-bool GLEnv::CheckEGLMakeCurrentError() {
- bool err = false;
- for (EGLint error = eglGetError();
- error != EGL_SUCCESS;
- error = eglGetError()) {
- switch (error) {
- case EGL_BAD_DISPLAY:
- ALOGE("EGL Error: Attempting to activate context with bad display!");
- break;
- case EGL_BAD_SURFACE:
- ALOGE("EGL Error: Attempting to activate context with bad surface!");
- break;
- case EGL_BAD_ACCESS:
- ALOGE("EGL Error: Attempting to activate context, which is "
- "already active in another thread!");
- break;
- default:
- ALOGE("EGL Error: Making EGL rendering context current caused "
- "error: 0x%x\n", error);
- }
- err = true;
- }
- return err;
-}
-
-GLuint GLEnv::GetCurrentProgram() {
- GLint result;
- glGetIntegerv(GL_CURRENT_PROGRAM, &result);
- ALOG_ASSERT(result >= 0);
- return static_cast<GLuint>(result);
-}
-
-EGLDisplay GLEnv::GetCurrentDisplay() {
- return eglGetCurrentDisplay();
-}
-
-int GLEnv::NumberOfComponents(GLenum type) {
- switch (type) {
- case GL_BOOL:
- case GL_FLOAT:
- case GL_INT:
- return 1;
- case GL_BOOL_VEC2:
- case GL_FLOAT_VEC2:
- case GL_INT_VEC2:
- return 2;
- case GL_INT_VEC3:
- case GL_FLOAT_VEC3:
- case GL_BOOL_VEC3:
- return 3;
- case GL_BOOL_VEC4:
- case GL_FLOAT_VEC4:
- case GL_INT_VEC4:
- case GL_FLOAT_MAT2:
- return 4;
- case GL_FLOAT_MAT3:
- return 9;
- case GL_FLOAT_MAT4:
- return 16;
- default:
- return 0;
- }
-}
-
-void GLEnv::AttachShader(int key, ShaderProgram* shader) {
- ShaderProgram* existingShader = ShaderWithKey(key);
- if (existingShader)
- delete existingShader;
- attached_shaders_[key] = shader;
-}
-
-void GLEnv::AttachVertexFrame(int key, VertexFrame* frame) {
- VertexFrame* existingFrame = VertexFrameWithKey(key);
- if (existingFrame)
- delete existingFrame;
- attached_vframes_[key] = frame;
-}
-
-ShaderProgram* GLEnv::ShaderWithKey(int key) {
- return FindPtrOrNull(attached_shaders_, key);
-}
-
-VertexFrame* GLEnv::VertexFrameWithKey(int key) {
- return FindPtrOrNull(attached_vframes_, key);
-}
-
-} // namespace filterfw
-} // namespace android
+++ /dev/null
-/*
- * 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.
- */
-
-#ifndef ANDROID_FILTERFW_CORE_GL_ENV_H
-#define ANDROID_FILTERFW_CORE_GL_ENV_H
-
-#include <string>
-#include <utility>
-#include <map>
-
-#include "base/logging.h"
-#include "base/utilities.h"
-
-#include <GLES2/gl2.h>
-#include <EGL/egl.h>
-
-#include <gui/ISurfaceTexture.h>
-#include <gui/SurfaceTextureClient.h>
-
-namespace android {
-namespace filterfw {
-
-class ShaderProgram;
-class VertexFrame;
-
-class WindowHandle {
- public:
- virtual ~WindowHandle() {
- }
-
- virtual void Destroy() = 0;
-
- virtual bool Equals(const WindowHandle* window) const {
- return InternalHandle() == window->InternalHandle();
- }
-
- virtual const void* InternalHandle() const = 0;
-
- virtual void* InternalHandle() = 0;
-};
-
-// The GLEnv class provides functionality related to the EGL environment, which
-// includes the display, context, and surface. It is possible to either create
-// a new environment or base it off the currently active EGL environment. In
-// order to do the latter, an EGL environment must be setup already (though not
-// necessarily through this class), and have an active display, context, and
-// surface.
-class GLEnv {
- public:
- // Constructing and Activating /////////////////////////////////////////////
- // Constructs a new GLEnv object. This does not create a GL context.
- GLEnv();
-
- // Destructor. Tears down and deallocates any GL objects that were created
- // by this instance.
- ~GLEnv();
-
- // Inits a new GL environment, including a new surface and context. You
- // must call Activate() before performing any GL operations.
- bool InitWithNewContext();
-
- // Inits the GL environment from the current GL environment. Use this when
- // there is already a display, surface and context available (possibly
- // created by the host application). You do not need to call Activate() as
- // this context is active already.
- bool InitWithCurrentContext();
-
- // Activates the environment, and makes the associated GL context the
- // current context. Creates the environment, if it has not been created
- // already. Returns true if the activation was successful.
- bool Activate();
-
- // Deactivates the environment. Returns true if the deactivation was
- // successful. You may want to call this when moving a context to another
- // thread. In this case, deactivate the GLEnv in the old thread, and
- // reactivate it in the new thread.
- bool Deactivate();
-
- // When rendering to a visible surface, call this to swap between the
- // offscreen and onscreen buffers. Returns true if the buffer swap was
- // successful.
- bool SwapBuffers();
-
- // Working with Surfaces ///////////////////////////////////////////////////
-
- // Add a surface to the environment. This surface will now be managed (and
- // owned) by the GLEnv instance. Returns the id of the surface.
- int AddSurface(const EGLSurface& surface);
-
- // Add a window surface to the environment. The window is passed in as
- // an opaque window handle.
- // This surface will now be managed (and owned) by the GLEnv instance.
- // Returns the id of the surface.
- int AddWindowSurface(const EGLSurface& surface, WindowHandle* window_handle);
-
- // Switch to the surface with the specified id. This will make the surface
- // active, if it is not active already. Specify an ID of 0 if you would like
- // to switch to the default surface. Returns true if successful.
- bool SwitchToSurfaceId(int surface_id);
-
- // Release the surface with the specified id. This will deallocate the
- // surface. If this is the active surface, the environment will switch to
- // the default surface (0) first. You cannot release the default surface.
- bool ReleaseSurfaceId(int surface_id);
-
- // Set the timestamp for the current surface. Must be called
- // before swapBuffers to associate the timestamp with the frame
- // resulting from swapBuffers.
- bool SetSurfaceTimestamp(int64_t timestamp);
-
- // Looks for a surface with the associated window handle. Returns -1 if no
- // surface with such a window was found.
- int FindSurfaceIdForWindow(const WindowHandle* window_handle);
-
- // Obtain the environment's EGL surface.
- const EGLSurface& surface() const {
- return surfaces_.find(surface_id_)->second.first;
- }
-
- // Working with Contexts ///////////////////////////////////////////////////
-
- // Add a context to the environment. This context will now be managed (and
- // owned) by the GLEnv instance. Returns the id of the context.
- int AddContext(const EGLContext& context);
-
- // Switch to the context with the specified id. This will make the context
- // active, if it is not active already. Specify an ID of 0 if you would like
- // to switch to the default context. Returns true if successful.
- bool SwitchToContextId(int context_id);
-
- // Release the context with the specified id. This will deallocate the
- // context. If this is the active context, the environment will switch to
- // the default context (0) first. You cannot release the default context.
- void ReleaseContextId(int context_id);
-
- // Obtain the environment's EGL context.
- const EGLContext& context() const {
- return contexts_.find(context_id_)->second;
- }
-
- // Working with the Display ////////////////////////////////////////////////
-
- // Obtain the environment's EGL display.
- const EGLDisplay& display() const {
- return display_;
- }
-
- // Inspecting the environment //////////////////////////////////////////////
- // Returns true if the environment is active in the current thread.
- bool IsActive() const;
-
- // Returns true if the environment's context is active in the curent thread.
- bool IsContextActive() const;
-
- // Returns true if there is any EGL context active in the current thread.
- // This need not be a context created by a GLEnv instance.
- static bool IsAnyContextActive();
-
- // Attaching GL objects ////////////////////////////////////////////////////
-
- // Attach a shader to the environment. The environment takes ownership of
- // the shader.
- void AttachShader(int key, ShaderProgram* shader);
-
- // Attach a vertex frame to the environment. The environment takes ownership
- // of the frame.
- void AttachVertexFrame(int key, VertexFrame* frame);
-
- // Return the shader with the specified key, or NULL if there is no such
- // shader attached to this environment.
- ShaderProgram* ShaderWithKey(int key);
-
- // Return the vertex frame with the specified key, or NULL if there is no
- // such frame attached to this environment.
- VertexFrame* VertexFrameWithKey(int key);
-
- // Static methods //////////////////////////////////////////////////////////
- // These operate on the currently active environment!
-
- // Checks if the current environment is in a GL error state. If so, it will
- // output an error message referencing the given operation string. Returns
- // true if there was at least one error.
- static bool CheckGLError(const std::string& operation);
-
- // Checks if the current environment is in an EGL error state. If so, it
- // will output an error message referencing the given operation string.
- // Returns true if there was at least one error.
- static bool CheckEGLError(const std::string& operation);
-
- // Get the currently used (shader) program.
- static GLuint GetCurrentProgram();
-
- // Get the currently active display.
- static EGLDisplay GetCurrentDisplay();
-
- // Returns the number of components for a given GL type. For instance,
- // returns 4 for vec4, and 16 for mat4.
- static int NumberOfComponents(GLenum type);
-
- private:
- typedef std::pair<EGLSurface, WindowHandle*> SurfaceWindowPair;
-
- // Initializes a new GL environment.
- bool Init();
-
- // Returns true if one of the Inits has been called successfully on this
- // instance.
- bool IsInitialized() const;
-
- // Outputs error messages specific to the operation eglMakeCurrent().
- // Returns true if there was at least one error.
- static bool CheckEGLMakeCurrentError();
-
- // The EGL display, contexts, and surfaces.
- EGLDisplay display_;
- std::map<int, EGLContext> contexts_;
- std::map<int, SurfaceWindowPair> surfaces_;
-
- // The currently active context and surface ids.
- int context_id_;
- int surface_id_;
-
- // Dummy surface for context
- sp<ANativeWindow> window_;
-
- // Dummy SurfaceTexture for context
- sp<SurfaceTexture> surfaceTexture_;
-
- // The maximum surface id used.
- int max_surface_id_;
-
- // These bools keep track of which objects this GLEnv has created (and
- // owns).
- bool created_context_;
- bool created_surface_;
- bool initialized_;
-
- // Attachments that GL objects can add to the environment.
- std::map<int, ShaderProgram*> attached_shaders_;
- std::map<int, VertexFrame*> attached_vframes_;
-
- DISALLOW_COPY_AND_ASSIGN(GLEnv);
-};
-
-} // namespace filterfw
-} // namespace android
-
-#endif // ANDROID_FILTERFW_CORE_GL_ENV_H
+++ /dev/null
-/*
- * 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.
- */
-
-#include "base/logging.h"
-
-#include "core/gl_env.h"
-#include "core/gl_frame.h"
-#include "core/shader_program.h"
-
-#include <vector>
-
-namespace android {
-namespace filterfw {
-
-static const int kIdentityShaderKey = 1;
-
-//
-// A GLFrame stores pixel data on the GPU. It uses two kinds of GL data
-// containers for this: Textures and Frame Buffer Objects (FBOs). Textures are
-// used whenever pixel data needs to be read into a shader or the host program,
-// and when pixel data is uploaded to a GLFrame. The FBO is used as a rendering
-// target for shaders.
-//
-
-GLFrame::GLFrame(GLEnv* gl_env)
- : gl_env_(gl_env),
- width_(0),
- height_(0),
- vp_x_(0),
- vp_y_(0),
- vp_width_(0),
- vp_height_(0),
- texture_id_(0),
- fbo_id_(0),
- texture_target_(GL_TEXTURE_2D),
- texture_state_(kStateUninitialized),
- fbo_state_(kStateUninitialized),
- owns_texture_(false),
- owns_fbo_(false) {
- SetDefaultTexParameters();
-}
-
-bool GLFrame::Init(int width, int height) {
- // Make sure we haven't been initialized already
- if (width_ == 0 && height_ == 0) {
- InitDimensions(width, height);
- return true;
- }
- return false;
-}
-
-bool GLFrame::InitWithTexture(GLint texture_id, int width, int height) {
- texture_id_ = texture_id;
- texture_state_ = glIsTexture(texture_id) ? kStateComplete : kStateGenerated;
- InitDimensions(width, height);
- return true;
-}
-
-bool GLFrame::InitWithFbo(GLint fbo_id, int width, int height) {
- fbo_id_ = fbo_id;
- fbo_state_ = glIsFramebuffer(fbo_id) ? kStateComplete : kStateGenerated;
- texture_state_ = kStateUnmanaged;
- InitDimensions(width, height);
- return true;
-}
-
-bool GLFrame::InitWithExternalTexture() {
- texture_target_ = GL_TEXTURE_EXTERNAL_OES;
- width_ = 0;
- height_ = 0;
- return GenerateTextureName();
-}
-
-void GLFrame::InitDimensions(int width, int height) {
- width_ = width;
- height_ = height;
- vp_width_ = width;
- vp_height_ = height;
-}
-
-GLFrame::~GLFrame() {
- // Delete texture
- if (owns_texture_) {
- // Bind FBO so that texture is unbound from it during deletion
- if (fbo_state_ == kStateComplete) {
- glBindFramebuffer(GL_FRAMEBUFFER, fbo_id_);
- }
- glDeleteTextures(1, &texture_id_);
- }
-
- // Delete FBO
- if (owns_fbo_) {
- glDeleteFramebuffers(1, &fbo_id_);
- }
-}
-
-bool GLFrame::GenerateMipMap() {
- if (FocusTexture()) {
- glGenerateMipmap(GL_TEXTURE_2D);
- return !GLEnv::CheckGLError("Generating MipMap!");
- }
- return false;
-}
-
-bool GLFrame::SetTextureParameter(GLenum pname, GLint value) {
- if (value != tex_params_[pname]) {
- if (FocusTexture()) {
- glTexParameteri(GL_TEXTURE_2D, pname, value);
- if (!GLEnv::CheckGLError("Setting texture parameter!")) {
- tex_params_[pname] = value;
- return true;
- }
- }
- } else {
- return true;
- }
- return false;
-}
-
-bool GLFrame::UpdateTexParameters() {
- glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, tex_params_[GL_TEXTURE_MAG_FILTER]);
- glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, tex_params_[GL_TEXTURE_MIN_FILTER]);
- glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, tex_params_[GL_TEXTURE_WRAP_S]);
- glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, tex_params_[GL_TEXTURE_WRAP_T]);
- return !GLEnv::CheckGLError("Resetting texture parameters!");
-}
-
-bool GLFrame::TexParametersModifed() {
- return tex_params_[GL_TEXTURE_MAG_FILTER] != GL_LINEAR
- || tex_params_[GL_TEXTURE_MIN_FILTER] != GL_LINEAR
- || tex_params_[GL_TEXTURE_WRAP_S] != GL_CLAMP_TO_EDGE
- || tex_params_[GL_TEXTURE_WRAP_T] != GL_CLAMP_TO_EDGE;
-}
-
-void GLFrame::SetDefaultTexParameters() {
- tex_params_[GL_TEXTURE_MAG_FILTER] = GL_LINEAR;
- tex_params_[GL_TEXTURE_MIN_FILTER] = GL_LINEAR;
- tex_params_[GL_TEXTURE_WRAP_S] = GL_CLAMP_TO_EDGE;
- tex_params_[GL_TEXTURE_WRAP_T] = GL_CLAMP_TO_EDGE;
-}
-
-bool GLFrame::ResetTexParameters() {
- if (TexParametersModifed()) {
- if (BindTexture()) {
- SetDefaultTexParameters();
- return UpdateTexParameters();
- }
- return false;
- }
- return true;
-}
-
-bool GLFrame::CopyDataTo(uint8_t* buffer, int size) {
- return (size >= Size())
- ? CopyPixelsTo(buffer)
- : false;
-}
-
-bool GLFrame::CopyPixelsTo(uint8_t* buffer) {
- // Use one of the pixel reading methods below, ordered from most
- // efficient to least efficient.
- if (fbo_state_ == kStateComplete)
- return ReadFboPixels(buffer);
- else if (texture_state_ == kStateComplete)
- return ReadTexturePixels(buffer);
- else
- return false;
-}
-
-bool GLFrame::WriteData(const uint8_t* data, int data_size) {
- return (data_size == Size()) ? UploadTexturePixels(data) : false;
-}
-
-bool GLFrame::SetViewport(int x, int y, int width, int height) {
- vp_x_ = x;
- vp_y_ = y;
- vp_width_ = width;
- vp_height_ = height;
- return true;
-}
-
-GLFrame* GLFrame::Clone() const {
- GLFrame* target = new GLFrame(gl_env_);
- target->Init(width_, height_);
- target->CopyPixelsFrom(this);
- return target;
-}
-
-bool GLFrame::CopyPixelsFrom(const GLFrame* frame) {
- if (frame == this) {
- return true;
- } else if (frame && frame->width_ == width_ && frame->height_ == height_) {
- std::vector<const GLFrame*> sources;
- sources.push_back(frame);
- GetIdentity()->Process(sources, this);
- return true;
- }
- return false;
-}
-
-int GLFrame::Size() const {
- return width_ * height_ * 4;
-}
-
-ShaderProgram* GLFrame::GetIdentity() const {
- ShaderProgram* stored_shader = gl_env_->ShaderWithKey(kIdentityShaderKey);
- if (!stored_shader) {
- stored_shader = ShaderProgram::CreateIdentity(gl_env_);
- gl_env_->AttachShader(kIdentityShaderKey, stored_shader);
- }
- return stored_shader;
-}
-
-bool GLFrame::BindFrameBuffer() const {
- // Bind the FBO
- glBindFramebuffer(GL_FRAMEBUFFER, fbo_id_);
- if (GLEnv::CheckGLError("FBO Binding")) return false;
-
- // Set viewport
- glViewport(vp_x_, vp_y_, vp_width_, vp_height_);
- if (GLEnv::CheckGLError("ViewPort Setup")) return false;
-
- return true;
-}
-
-bool GLFrame::FocusFrameBuffer() {
- // Create texture backing if necessary
- if (texture_state_ == kStateUninitialized) {
- if (!GenerateTextureName())
- return false;
- }
-
- // Create and bind FBO to texture if necessary
- if (fbo_state_ != kStateComplete) {
- if (!GenerateFboName() || !AttachTextureToFbo())
- return false;
- }
-
- // And bind it.
- return BindFrameBuffer();
-}
-
-bool GLFrame::BindTexture() const {
- glBindTexture(GL_TEXTURE_2D, texture_id_);
- return !GLEnv::CheckGLError("Texture Binding");
-}
-
-GLuint GLFrame::GetTextureId() const {
- return texture_id_;
-}
-
-// Returns the held FBO id. Only call this if the GLFrame holds an FBO. You
-// can check this by calling HoldsFbo().
-GLuint GLFrame::GetFboId() const {
- return fbo_id_;
-}
-
-bool GLFrame::FocusTexture() {
- // Make sure we have a texture
- if (!GenerateTextureName())
- return false;
-
- // Bind the texture
- if (!BindTexture())
- return false;
-
- return !GLEnv::CheckGLError("Texture Binding");
-}
-
-bool GLFrame::GenerateTextureName() {
- if (texture_state_ == kStateUninitialized) {
- // Make sure texture not in use already
- if (glIsTexture(texture_id_)) {
- ALOGE("GLFrame: Cannot generate texture id %d, as it is in use already!", texture_id_);
- return false;
- }
-
- // Generate the texture
- glGenTextures (1, &texture_id_);
- if (GLEnv::CheckGLError("Texture Generation"))
- return false;
- texture_state_ = kStateGenerated;
- owns_texture_ = true;
- }
-
- return true;
-}
-
-bool GLFrame::AllocateTexture() {
- // Allocate or re-allocate (if texture was deleted externally).
- if (texture_state_ == kStateGenerated || TextureWasDeleted()) {
- LOG_FRAME("GLFrame: Allocating texture: %d", texture_id_);
- glBindTexture(GL_TEXTURE_2D, texture_id_);
- glTexImage2D(GL_TEXTURE_2D,
- 0,
- GL_RGBA,
- width_,
- height_,
- 0,
- GL_RGBA,
- GL_UNSIGNED_BYTE,
- NULL);
- if (!GLEnv::CheckGLError("Texture Allocation")) {
- UpdateTexParameters();
- texture_state_ = kStateComplete;
- }
- }
- return texture_state_ == kStateComplete;
-}
-
-bool GLFrame::TextureWasDeleted() const {
- return texture_state_ == kStateComplete && !glIsTexture(texture_id_);
-}
-
-bool GLFrame::GenerateFboName() {
- if (fbo_state_ == kStateUninitialized) {
- // Make sure FBO not in use already
- if (glIsFramebuffer(fbo_id_)) {
- ALOGE("GLFrame: Cannot generate FBO id %d, as it is in use already!", fbo_id_);
- return false;
- }
-
- // Create FBO
- glGenFramebuffers(1, &fbo_id_);
- if (GLEnv::CheckGLError("FBO Generation"))
- return false;
- fbo_state_ = kStateGenerated;
- owns_fbo_ = true;
- }
-
- return true;
-}
-
-bool GLFrame::ReadFboPixels(uint8_t* pixels) const {
- if (fbo_state_ == kStateComplete) {
- BindFrameBuffer();
- glReadPixels(0,
- 0,
- width_,
- height_,
- GL_RGBA,
- GL_UNSIGNED_BYTE,
- pixels);
- return !GLEnv::CheckGLError("FBO Pixel Readout");
- }
- return false;
-}
-
-bool GLFrame::ReadTexturePixels(uint8_t* pixels) const {
- // Read pixels from texture if we do not have an FBO
- // NOTE: OpenGL ES does NOT support glGetTexImage() for reading out texture
- // data. The only way for us to get texture data is to create a new FBO and
- // render the current texture frame into it. As this is quite inefficient,
- // and unnecessary (this can only happen if the user is reading out data
- // that was just set, and not run through a filter), we warn the user about
- // this here.
- ALOGW("Warning: Reading pixel data from unfiltered GL frame. This is highly "
- "inefficient. Please consider using your original pixel buffer "
- "instead!");
-
- // Create source frame set (unfortunately this requires an ugly const-cast,
- // as we need to wrap ourselves in a frame-set. Still, as this set is used
- // as input only, we are certain we will not be modified).
- std::vector<const GLFrame*> sources;
- sources.push_back(this);
-
- // Create target frame
- GLFrame target(gl_env_);
- target.Init(width_, height_);
-
- // Render the texture to the target
- GetIdentity()->Process(sources, &target);
-
- // Get the pixel data
- return target.ReadFboPixels(pixels);
-}
-
-bool GLFrame::AttachTextureToFbo() {
- // Check FBO and texture state. We do not do anything if we are not managing the texture.
- if (fbo_state_ == kStateComplete || texture_state_ == kStateUnmanaged) {
- return true;
- } else if (fbo_state_ != kStateGenerated) {
- ALOGE("Attempting to attach texture to FBO with no FBO in place!");
- return false;
- }
-
- // If texture has been generated, make sure it is allocated.
- if (!AllocateTexture())
- return false;
-
- // Bind the frame buffer, and check if we it is already bound
- glBindFramebuffer(GL_FRAMEBUFFER, fbo_id_);
-
- // Bind the texture to the frame buffer
- LOG_FRAME("Attaching tex %d w %d h %d to fbo %d", texture_id_, width_, height_, fbo_id_);
- glFramebufferTexture2D(GL_FRAMEBUFFER,
- GL_COLOR_ATTACHMENT0,
- GL_TEXTURE_2D,
- texture_id_,
- 0);
-
- // Cleanup
- glBindTexture(GL_TEXTURE_2D, 0);
- glBindFramebuffer(GL_FRAMEBUFFER, 0);
-
- if (GLEnv::CheckGLError("Texture Binding to FBO"))
- return false;
- else
- fbo_state_ = kStateComplete;
-
- return true;
-}
-
-bool GLFrame::ReattachTextureToFbo() {
- return (fbo_state_ == kStateGenerated) ? AttachTextureToFbo() : true;
-}
-
-bool GLFrame::DetachTextureFromFbo() {
- if (fbo_state_ == kStateComplete && texture_state_ == kStateComplete) {
- LOG_FRAME("Detaching tex %d w %d h %d from fbo %d", texture_id_, width_, height_, fbo_id_);
- glBindFramebuffer(GL_FRAMEBUFFER, fbo_id_);
- glFramebufferTexture2D(GL_FRAMEBUFFER,
- GL_COLOR_ATTACHMENT0,
- GL_TEXTURE_2D,
- 0,
- 0);
- if (GLEnv::CheckGLError("Detaching texture to FBO"))
- return false;
- else
- fbo_state_ = kStateGenerated;
- }
- return true;
-}
-
-bool GLFrame::UploadTexturePixels(const uint8_t* pixels) {
- // Bind the texture object
- FocusTexture();
-
- // Load mipmap level 0
- glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width_, height_,
- 0, GL_RGBA, GL_UNSIGNED_BYTE, pixels);
-
- // Set the user specified texture parameters
- UpdateTexParameters();
-
- if (GLEnv::CheckGLError("Texture Pixel Upload"))
- return false;
-
- texture_state_ = kStateComplete;
- return true;
-}
-
-} // namespace filterfw
-} // namespace android
+++ /dev/null
-/*
- * 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.
- */
-
-#ifndef ANDROID_FILTERFW_CORE_GL_FRAME_H
-#define ANDROID_FILTERFW_CORE_GL_FRAME_H
-
-#include <map>
-
-#include <GLES2/gl2.h>
-
-#include "core/gl_buffer_interface.h"
-
-namespace android {
-namespace filterfw {
-
-class GLEnv;
-class ShaderProgram;
-
-// A GLFrame stores pixel data on the GPU. While pixel data may be uploaded to
-// a GLFrame and also read out of a GLFrame (access in place is not supported),
-// it is strongly recommended to use ShaderProgram objects for any kind of
-// processing from one GLFrame to another.
-class GLFrame : public GLBufferHandle {
- public:
- // Create an empty GL frame in the specified GL environment. Note, that the GLFrame does NOT
- // take ownership. The caller must make sure the GLEnv stays valid as long as the GLFrame is
- // alive.
- GLFrame(GLEnv* gl_env);
-
- // Deallocate a GL frame.
- ~GLFrame();
-
- // Initialize a GL frame to the given width, height, format. Also specify
- // whether this is a read-only GL frame or not.
- bool Init(int width, int height);
-
- // Initialize as using an external texture.
- bool InitWithExternalTexture();
-
- // Initialize using an existing texture.
- bool InitWithTexture(GLint texture_id, int width, int height);
-
- // Initialize using an existing FBO.
- bool InitWithFbo(GLint fbo_id, int width, int height);
-
- // Write the data with the given size in bytes to the frame. The frame size must match the
- // size of the data.
- bool WriteData(const uint8_t* data, int size);
-
- // Copies the frame data to the given buffer.
- bool CopyDataTo(uint8_t* buffer, int size);
-
- // Copies the pixels from another GL frame to this frame.
- bool CopyPixelsFrom(const GLFrame* frame);
-
- // Returns the size of the buffer in bytes.
- int Size() const;
-
- // Clone the current frame by creating a new GL frame and copying all data to it.
- GLFrame* Clone() const;
-
- // Returns the held texture id. Only call this if the GLFrame holds a
- // texture. You can check this by calling HoldsTexture().
- // Note, that a texture is created only when needed. If you are creating a
- // new GLFrame, and you need it to be bound to a texture, upload (zeroed)
- // data to it first, before calling this method.
- GLuint GetTextureId() const;
-
- // Returns the held FBO id. Only call this if the GLFrame holds an FBO. You
- // can check this by calling HoldsFbo().
- GLuint GetFboId() const;
-
- // Returns the texture target: GL_TEXTURE_2D or GL_TEXTURE_EXTERNAL_OES.
- GLuint GetTextureTarget() const {
- return texture_target_;
- }
-
- // Set the viewport that will be used when focusing this frame for rendering. Defaults to
- // the dimensions of the frame.
- bool SetViewport(int x, int y, int width, int height);
-
- // Binds the held texture. This may result in creating the texture if it
- // is not yet available.
- bool FocusTexture();
-
- // Binds the held FBO. This may result in creating the FBO if it
- // is not yet available.
- bool FocusFrameBuffer();
-
- // Generates the mipmap chain of the held texture. Returns true, iff
- // generating was successful.
- bool GenerateMipMap();
-
- // Set a texture parameter (see glTextureParameter documentation). Returns
- // true iff the parameter was set successfully.
- bool SetTextureParameter(GLenum pname, GLint value);
-
- // Reset any modifed texture parameters.
- bool ResetTexParameters();
-
- // Detaches the internal texture from the FBO.
- bool DetachTextureFromFbo();
-
- // Reattaches the internal texture to the FBO after detachment.
- bool ReattachTextureToFbo();
-
- private:
- // Type to keep track of texture and FBO states
- enum GLObjectState {
- kStateUnmanaged, // We do not manage this object (externally managed)
- kStateUninitialized, // Not yet initialized
- kStateGenerated, // Tex/FBO id is generated
- kStateComplete // FBO has valid attachment / Tex has valid pixel data
- };
-
- // Sets the frame and viewport dimensions.
- void InitDimensions(int width, int height);
-
- // Generates the internal texture name.
- bool GenerateTextureName();
-
- // Allocates the internal texture.
- bool AllocateTexture();
-
- // Creates the internal FBO.
- bool GenerateFboName();
-
- // Copies pixels from texture or FBO to the specified buffer.
- bool CopyPixelsTo(uint8_t* buffer);
-
- // Reads the pixels from the internal texture to the given buffer.
- bool ReadTexturePixels(uint8_t* pixels) const;
-
- // Reads the pixels from the internal FBO to the given buffer.
- bool ReadFboPixels(uint8_t* pixels) const;
-
- // Writes the specified pixels to the internal texture.
- bool UploadTexturePixels(const uint8_t* pixels);
-
- // Binds the internal texture.
- bool BindTexture() const;
-
- // Binds the internal FBO.
- bool BindFrameBuffer() const;
-
- // Attaches the internal texture to the internal FBO.
- bool AttachTextureToFbo();
-
- // Update the texture parameters to the user specified parameters
- bool UpdateTexParameters();
-
- // Returns true if the current texture parameters are not the GLES2
- // default parameters.
- bool TexParametersModifed();
-
- // Sets the current texture parameters to the GLES2 default
- // parameters. This still requires a call to UpdateTexParameters()
- // for the changes to take effect.
- void SetDefaultTexParameters();
-
- // Returns true if the texture we assume to be allocated has been
- // deleted externally. In this case we assume the texture name is
- // still valid (otherwise we were provided with a bad texture id).
- bool TextureWasDeleted() const;
-
- // Get the (cached) identity shader.
- ShaderProgram* GetIdentity() const;
-
- // The GL environment this frame belongs to
- GLEnv* gl_env_;
-
- // The width, height and format of the frame
- int width_;
- int height_;
-
- // The viewport dimensions
- int vp_x_;
- int vp_y_;
- int vp_width_;
- int vp_height_;
-
- // The texture and FBO ids
- GLuint texture_id_;
- GLuint fbo_id_;
-
- // The texture target: GL_TEXTURE_2D or GL_TEXTURE_EXTERNAL_OES
- GLuint texture_target_;
-
- // Flags whether or not frame holds a texture and FBO
- GLObjectState texture_state_;
- GLObjectState fbo_state_;
-
- // Set of current texture parameters
- std::map<GLenum, GLint> tex_params_;
-
- // Flag whether frame owns the texture and FBO
- bool owns_texture_;
- bool owns_fbo_;
-};
-
-} // namespace filterfw
-} // namespace android
-
-#endif // ANDROID_FILTERFW_CORE_GL_FRAME_H
+++ /dev/null
-/*
- * 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.
- */
-
-#include "core/native_frame.h"
-
-namespace android {
-namespace filterfw {
-
-NativeFrame::NativeFrame(int size) : data_(NULL), size_(size), capacity_(size) {
- data_ = capacity_ == 0 ? NULL : new uint8_t[capacity_];
-}
-
-NativeFrame::~NativeFrame() {
- delete[] data_;
-}
-
-bool NativeFrame::WriteData(const uint8_t* data, int offset, int size) {
- if (size_ >= (offset + size)) {
- memcpy(data_ + offset, data, size);
- return true;
- }
- return false;
-}
-
-bool NativeFrame::SetData(uint8_t* data, int size) {
- delete[] data_;
- size_ = capacity_ = size;
- data_ = data;
- return true;
-}
-
-NativeFrame* NativeFrame::Clone() const {
- NativeFrame* result = new NativeFrame(size_);
- if (data_)
- result->WriteData(data_, 0, size_);
- return result;
-}
-
-bool NativeFrame::Resize(int newSize) {
- if (newSize <= capacity_ && newSize >= 0) {
- size_ = newSize;
- return true;
- }
- return false;
-}
-
-} // namespace filterfw
-} // namespace android
+++ /dev/null
-/*
- * 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.
- */
-
-#ifndef ANDROID_FILTERFW_CORE_NATIVE_FRAME_H
-#define ANDROID_FILTERFW_CORE_NATIVE_FRAME_H
-
-#include "base/utilities.h"
-
-namespace android {
-namespace filterfw {
-
-// A NativeFrame stores data in a memory buffer (on the heap). It is used for
-// data processing on the CPU.
-class NativeFrame {
- public:
- // Create an empty native frame.
- NativeFrame(int size);
-
- ~NativeFrame();
-
- // Set the frame data and size in bytes. The NativeFrame object takes ownership of the data.
- // To copy data into an existing frame, use WriteData().
- bool SetData(uint8_t* data, int size);
-
- // Write the specified data of the given size to the frame at the specified offset. The
- // receiver must be large enough to hold the data.
- bool WriteData(const uint8_t* data, int offset, int size);
-
- // Returns a pointer to the data, or NULL if no data was set.
- const uint8_t* Data() const {
- return data_;
- }
-
- // Returns a non-const pointer to the data, or NULL if no data was set.
- uint8_t* MutableData() {
- return data_;
- }
-
- // Resize the frame. You can only resize to a size that fits within the frame's capacity.
- // Returns true if the resize was successful.
- bool Resize(int newSize);
-
- // Returns the size of the frame in bytes.
- int Size() {
- return size_;
- }
-
- // Returns the capacity of the frame in bytes.
- int Capacity() {
- return capacity_;
- }
-
- // Returns a new native frame
- NativeFrame* Clone() const;
-
- private:
- // Pointer to the data. Owned by the frame.
- uint8_t* data_;
-
- // Size of data buffer in bytes.
- int size_;
-
- // Capacity of data buffer in bytes.
- int capacity_;
-
- DISALLOW_COPY_AND_ASSIGN(NativeFrame);
-};
-
-} // namespace filterfw
-} // namespace android
-
-#endif // ANDROID_FILTERFW_CORE_NATIVE_FRAME_H
+++ /dev/null
-/*
- * 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.
- */
-
-#include <dlfcn.h>
-
-#include "base/logging.h"
-#include "core/native_frame.h"
-#include "core/native_program.h"
-
-#include <string>
-#include <vector>
-
-namespace android {
-namespace filterfw {
-
-NativeProgram::NativeProgram()
- : lib_handle_(NULL),
- init_function_(NULL),
- setvalue_function_(NULL),
- getvalue_function_(NULL),
- process_function_(NULL),
- reset_function_(NULL),
- teardown_function_(NULL),
- user_data_(NULL) {
-}
-
-NativeProgram::~NativeProgram() {
- if (lib_handle_)
- dlclose(lib_handle_);
-}
-
-bool NativeProgram::OpenLibrary(const std::string& lib_name) {
- if (!lib_handle_) {
- lib_handle_ = dlopen(lib_name.c_str(), RTLD_NOW);
- if (!lib_handle_) {
- ALOGE("NativeProgram: Error opening library: '%s': %s", lib_name.c_str(), dlerror());
- return false;
- }
- return true;
- }
- return false;
-}
-
-bool NativeProgram::BindProcessFunction(const std::string& func_name) {
- if (!lib_handle_)
- return false;
- process_function_ = reinterpret_cast<ProcessFunctionPtr>(dlsym(lib_handle_, func_name.c_str()));
- if (!process_function_) {
- ALOGE("NativeProgram: Could not find process function symbol: '%s'!", func_name.c_str());
- return false;
- }
- return true;
-}
-
-bool NativeProgram::BindInitFunction(const std::string& func_name) {
- if (!lib_handle_)
- return false;
- init_function_ = reinterpret_cast<InitFunctionPtr>(dlsym(lib_handle_, func_name.c_str()));
- return init_function_ != NULL;
-}
-
-bool NativeProgram::BindSetValueFunction(const std::string& func_name) {
- if (!lib_handle_)
- return false;
- setvalue_function_ = reinterpret_cast<SetValueFunctionPtr>(dlsym(lib_handle_, func_name.c_str()));
- return setvalue_function_ != NULL;
-}
-
-bool NativeProgram::BindGetValueFunction(const std::string& func_name) {
- if (!lib_handle_)
- return false;
- getvalue_function_ = reinterpret_cast<GetValueFunctionPtr>(dlsym(lib_handle_, func_name.c_str()));
- return getvalue_function_ != NULL;
-}
-
-bool NativeProgram::BindResetFunction(const std::string& func_name) {
- if (!lib_handle_)
- return false;
- reset_function_ = reinterpret_cast<ResetFunctionPtr>(dlsym(lib_handle_, func_name.c_str()));
- return reset_function_ != NULL;
-}
-
-bool NativeProgram::BindTeardownFunction(const std::string& func_name) {
- if (!lib_handle_)
- return false;
- teardown_function_ = reinterpret_cast<TeardownFunctionPtr>(dlsym(lib_handle_, func_name.c_str()));
- return teardown_function_ != NULL;
-}
-
-bool NativeProgram::CallProcess(const std::vector<const char*>& inputs,
- const std::vector<int>& input_sizes,
- char* output,
- int output_size) {
- if (process_function_) {
- return process_function_(const_cast<const char**>(&inputs[0]),
- &input_sizes[0],
- inputs.size(),
- output,
- output_size,
- user_data_) == 1;
- }
- return false;
-}
-
-bool NativeProgram::CallInit() {
- if (init_function_) {
- init_function_(&user_data_);
- return true;
- }
- return false;
-}
-
-bool NativeProgram::CallSetValue(const std::string& key, const std::string& value) {
- if (setvalue_function_) {
- setvalue_function_(key.c_str(), value.c_str(), user_data_);
- return true;
- }
- return false;
-}
-
-std::string NativeProgram::CallGetValue(const std::string& key) {
- if (getvalue_function_) {
- static const int buffer_size = 1024;
- char result[buffer_size];
- result[buffer_size - 1] = '\0';
- getvalue_function_(key.c_str(), result, buffer_size, user_data_);
- return std::string(result);
- }
- return std::string();
-}
-
-bool NativeProgram::CallReset() {
- if (reset_function_) {
- reset_function_(user_data_);
- return true;
- }
- return false;
-}
-
-bool NativeProgram::CallTeardown() {
- if (teardown_function_) {
- teardown_function_(user_data_);
- return true;
- }
- return false;
-}
-
-} // namespace filterfw
-} // namespace android
+++ /dev/null
-/*
- * 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.
- */
-
-#ifndef ANDROID_FILTERFW_CORE_NATIVE_PROGRAM_H
-#define ANDROID_FILTERFW_CORE_NATIVE_PROGRAM_H
-
-#include <vector>
-#include <string>
-
-#include "base/utilities.h"
-
-namespace android {
-namespace filterfw {
-
-class NativeFrame;
-
-typedef void (*InitFunctionPtr)(void**);
-typedef void (*SetValueFunctionPtr)(const char*, const char*, void*);
-typedef void (*GetValueFunctionPtr)(const char*, char*, int, void*);
-typedef int (*ProcessFunctionPtr)(const char**, const int*, int, char*, int, void*);
-typedef void (*ResetFunctionPtr)(void*);
-typedef void (*TeardownFunctionPtr)(void*);
-
-class NativeProgram {
- public:
- // Create an empty native frame.
- NativeProgram();
-
- ~NativeProgram();
-
- bool OpenLibrary(const std::string& lib_name);
-
- bool BindInitFunction(const std::string& func_name);
- bool BindSetValueFunction(const std::string& func_name);
- bool BindGetValueFunction(const std::string& func_name);
- bool BindProcessFunction(const std::string& func_name);
- bool BindResetFunction(const std::string& func_name);
- bool BindTeardownFunction(const std::string& func_name);
-
- bool CallInit();
- bool CallSetValue(const std::string& key, const std::string& value);
- std::string CallGetValue(const std::string& key);
- bool CallProcess(const std::vector<const char*>& inputs,
- const std::vector<int>& input_sizes,
- char* output,
- int output_size);
- bool CallReset();
- bool CallTeardown();
-
- private:
- // Pointer to the data. Owned by the frame.
- void* lib_handle_;
-
- // The function pointers to the native function implementations.
- InitFunctionPtr init_function_;
- SetValueFunctionPtr setvalue_function_;
- GetValueFunctionPtr getvalue_function_;
- ProcessFunctionPtr process_function_;
- ResetFunctionPtr reset_function_;
- TeardownFunctionPtr teardown_function_;
-
- // Pointer to user data
- void* user_data_;
-
- DISALLOW_COPY_AND_ASSIGN(NativeProgram);
-};
-
-} // namespace filterfw
-} // namespace android
-
-#endif // ANDROID_FILTERFW_CORE_NATIVE_PROGRAM_H
+++ /dev/null
-/*
- * 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.
- */
-
-#include "base/logging.h"
-
-#include "core/geometry.h"
-#include "core/gl_buffer_interface.h"
-#include "core/gl_env.h"
-#include "core/gl_frame.h"
-#include "core/shader_program.h"
-#include "core/vertex_frame.h"
-
-#include <string>
-#include <sstream>
-#include <vector>
-
-namespace android {
-namespace filterfw {
-
-// VBO attachment keys
-static const int kDefaultVboKey = 1;
-
-static const char* s_default_vertex_shader_source_ =
- "attribute vec4 a_position;\n"
- "attribute vec2 a_texcoord;\n"
- "varying vec2 v_texcoord;\n"
- "void main() {\n"
- " gl_Position = a_position;\n"
- " v_texcoord = a_texcoord;\n"
- "}\n";
-
-// Helper Functions ////////////////////////////////////////////////////////////
-// Maps coordinates x,y in the unit rectangle over to the quadrangle specified
-// by the four points in b. The result coordinates are written to xt and yt.
-static void GetTileCoords(const float* b, float x, float y, float* xt, float* yt) {
- const float w0 = (1.0f - x) * (1.0f - y);
- const float w1 = x * (1.0f - y);
- const float w2 = (1.0f - x) * y;
- const float w3 = x * y;
-
- *xt = w0 * b[0] + w1 * b[2] + w2 * b[4] + w3 * b[6];
- *yt = w0 * b[1] + w1 * b[3] + w2 * b[5] + w3 * b[7];
-}
-
-static inline float AdjustRatio(float current, float next) {
- return (current + next) / 2.0;
-}
-
-// VertexAttrib implementation /////////////////////////////////////////////////
-ShaderProgram::VertexAttrib::VertexAttrib()
- : is_const(true),
- index(-1),
- normalized(false),
- stride(0),
- components(0),
- offset(0),
- type(GL_FLOAT),
- vbo(0),
- values(NULL),
- owned_data(NULL) {
-}
-
-// ShaderProgram implementation ////////////////////////////////////////////////
-ShaderProgram::ShaderProgram(GLEnv* gl_env, const std::string& fragment_shader)
- : fragment_shader_source_(fragment_shader),
- vertex_shader_source_(s_default_vertex_shader_source_),
- fragment_shader_(0),
- vertex_shader_(0),
- program_(0),
- gl_env_(gl_env),
- base_texture_unit_(GL_TEXTURE0),
- source_coords_(NULL),
- target_coords_(NULL),
- manage_coordinates_(false),
- tile_x_count_(1),
- tile_y_count_(1),
- vertex_count_(4),
- draw_mode_(GL_TRIANGLE_STRIP),
- clears_(false),
- blending_(false),
- sfactor_(GL_SRC_ALPHA),
- dfactor_(GL_ONE_MINUS_SRC_ALPHA) {
- SetDefaultCoords();
-}
-
-ShaderProgram::ShaderProgram(GLEnv* gl_env,
- const std::string& vertex_shader,
- const std::string& fragment_shader)
- : fragment_shader_source_(fragment_shader),
- vertex_shader_source_(vertex_shader),
- fragment_shader_(0),
- vertex_shader_(0),
- program_(0),
- gl_env_(gl_env),
- base_texture_unit_(GL_TEXTURE0),
- source_coords_(NULL),
- target_coords_(NULL),
- manage_coordinates_(false),
- tile_x_count_(1),
- tile_y_count_(1),
- vertex_count_(4),
- draw_mode_(GL_TRIANGLE_STRIP),
- clears_(false),
- blending_(false),
- sfactor_(GL_SRC_ALPHA),
- dfactor_(GL_ONE_MINUS_SRC_ALPHA) {
- SetDefaultCoords();
-}
-
-ShaderProgram::~ShaderProgram() {
- // Delete our vertex data
- delete[] source_coords_;
- delete[] target_coords_;
-
- // Delete any owned attribute data
- VertexAttribMap::const_iterator iter;
- for (iter = attrib_values_.begin(); iter != attrib_values_.end(); ++iter) {
- const VertexAttrib& attrib = iter->second;
- if (attrib.owned_data)
- delete[] attrib.owned_data;
- }
-}
-
-void ShaderProgram::SetDefaultCoords() {
- if (!source_coords_)
- source_coords_ = new float[8];
- if (!target_coords_)
- target_coords_ = new float[8];
-
- source_coords_[0] = 0.0f;
- source_coords_[1] = 0.0f;
- source_coords_[2] = 1.0f;
- source_coords_[3] = 0.0f;
- source_coords_[4] = 0.0f;
- source_coords_[5] = 1.0f;
- source_coords_[6] = 1.0f;
- source_coords_[7] = 1.0f;
-
- target_coords_[0] = -1.0f;
- target_coords_[1] = -1.0f;
- target_coords_[2] = 1.0f;
- target_coords_[3] = -1.0f;
- target_coords_[4] = -1.0f;
- target_coords_[5] = 1.0f;
- target_coords_[6] = 1.0f;
- target_coords_[7] = 1.0f;
-
-}
-
-ShaderProgram* ShaderProgram::CreateIdentity(GLEnv* gl_env) {
- const char* s_id_fragment_shader =
- "precision mediump float;\n"
- "uniform sampler2D tex_sampler_0;\n"
- "varying vec2 v_texcoord;\n"
- "void main() {\n"
- " gl_FragColor = texture2D(tex_sampler_0, v_texcoord);\n"
- "}\n";
- ShaderProgram* result = new ShaderProgram(gl_env, s_id_fragment_shader);
- result->CompileAndLink();
- return result;
-}
-
-bool ShaderProgram::IsVarValid(ProgramVar var) {
- return var != -1;
-}
-
-bool ShaderProgram::Process(const std::vector<const GLTextureHandle*>& input,
- GLFrameBufferHandle* output) {
- // TODO: This can be optimized: If the input and output are the same, as in
- // the last iteration (typical of a multi-pass filter), a lot of this setup
- // may be skipped.
-
- // Abort if program did not successfully compile and link
- if (!IsExecutable()) {
- ALOGE("ShaderProgram: unexecutable program!");
- return false;
- }
-
- // Focus the FBO of the output
- if (!output->FocusFrameBuffer()) {
- ALOGE("Unable to focus frame buffer");
- return false;
- }
-
- // Get all required textures
- std::vector<GLuint> textures;
- std::vector<GLenum> targets;
- for (unsigned i = 0; i < input.size(); ++i) {
- // Get the current input frame and make sure it is a GL frame
- if (input[i]) {
- // Get the texture bound to that frame
- const GLuint tex_id = input[i]->GetTextureId();
- const GLenum target = input[i]->GetTextureTarget();
- if (tex_id == 0) {
- ALOGE("ShaderProgram: invalid texture id at input: %d!", i);
- return false;
- }
- textures.push_back(tex_id);
- targets.push_back(target);
- }
- }
-
- // And render!
- if (!RenderFrame(textures, targets)) {
- ALOGE("Unable to render frame");
- return false;
- }
- return true;
-}
-
-bool ShaderProgram::Process(const std::vector<const GLFrame*>& input, GLFrame* output) {
- std::vector<const GLTextureHandle*> textures(input.size());
- std::copy(input.begin(), input.end(), textures.begin());
- return Process(textures, output);
-}
-
-void ShaderProgram::SetSourceRect(float x, float y, float width, float height) {
- Quad quad(Point(x, y),
- Point(x + width, y),
- Point(x, y + height),
- Point(x + width, y + height));
- SetSourceRegion(quad);
-}
-
-void ShaderProgram::SetSourceRegion(const Quad& quad) {
- int index = 0;
- for (int i = 0; i < 4; ++i, index += 2) {
- source_coords_[index] = quad.point(i).x();
- source_coords_[index+1] = quad.point(i).y();
- }
-}
-
-void ShaderProgram::SetTargetRect(float x, float y, float width, float height) {
- Quad quad(Point(x, y),
- Point(x + width, y),
- Point(x, y + height),
- Point(x + width, y + height));
- SetTargetRegion(quad);
-}
-
-void ShaderProgram::SetTargetRegion(const Quad& quad) {
- int index = 0;
- for (int i = 0; i < 4; ++i, index += 2) {
- target_coords_[index] = (quad.point(i).x() * 2.0) - 1.0;
- target_coords_[index+1] = (quad.point(i).y() * 2.0) - 1.0;
- }
-}
-
-bool ShaderProgram::CompileAndLink() {
- // Make sure we haven't compiled and linked already
- if (vertex_shader_ != 0 || fragment_shader_ != 0 || program_ != 0) {
- ALOGE("Attempting to re-compile shaders!");
- return false;
- }
-
- // Compile vertex shader
- vertex_shader_ = CompileShader(GL_VERTEX_SHADER,
- vertex_shader_source_.c_str());
- if (!vertex_shader_) {
- ALOGE("Shader compilation failed!");
- return false;
- }
-
- // Compile fragment shader
- fragment_shader_ = CompileShader(GL_FRAGMENT_SHADER,
- fragment_shader_source_.c_str());
- if (!fragment_shader_)
- return false;
-
- // Link
- GLuint shaders[2] = { vertex_shader_, fragment_shader_ };
- program_ = LinkProgram(shaders, 2);
-
- // Scan for all uniforms in the program
- ScanUniforms();
-
- // Check if we manage all coordinates
- if (program_ != 0) {
- ProgramVar tex_coord_attr = glGetAttribLocation(program_, TexCoordAttributeName().c_str());
- ProgramVar pos_coord_attr = glGetAttribLocation(program_, PositionAttributeName().c_str());
- manage_coordinates_ = (tex_coord_attr >= 0 && pos_coord_attr >= 0);
- } else {
- ALOGE("Could not link shader program!");
- return false;
- }
-
- return true;
-}
-
-GLuint ShaderProgram::CompileShader(GLenum shader_type, const char* source) {
- LOG_FRAME("Compiling source:\n[%s]", source);
-
- // Create shader
- GLuint shader = glCreateShader(shader_type);
- if (shader) {
- // Compile source
- glShaderSource(shader, 1, &source, NULL);
- glCompileShader(shader);
-
- // Check for compilation errors
- GLint compiled = 0;
- glGetShaderiv(shader, GL_COMPILE_STATUS, &compiled);
- if (!compiled) {
- // Log the compilation error messages
- ALOGE("Problem compiling shader! Source:");
- ALOGE("%s", source);
- std::string src(source);
- unsigned int cur_pos = 0;
- unsigned int next_pos = 0;
- int line_number = 1;
- while ( (next_pos = src.find_first_of('\n', cur_pos)) != std::string::npos) {
- ALOGE("%03d : %s", line_number, src.substr(cur_pos, next_pos-cur_pos).c_str());
- cur_pos = next_pos + 1;
- line_number++;
- }
- ALOGE("%03d : %s", line_number, src.substr(cur_pos, next_pos-cur_pos).c_str());
-
- GLint log_length = 0;
- glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &log_length);
- if (log_length) {
- char* error_log = new char[log_length];
- if (error_log) {
- glGetShaderInfoLog(shader, log_length, NULL, error_log);
- ALOGE("Shader compilation error %d:\n%s\n", shader_type, error_log);
- delete[] error_log;
- }
- }
- glDeleteShader(shader);
- shader = 0;
- }
- }
- return shader;
-}
-
-GLuint ShaderProgram::LinkProgram(GLuint* shaders, GLuint count) {
- GLuint program = glCreateProgram();
- if (program) {
- // Attach all compiled shaders
- for (GLuint i = 0; i < count; ++i) {
- glAttachShader(program, shaders[i]);
- if (GLEnv::CheckGLError("glAttachShader")) return 0;
- }
-
- // Link
- glLinkProgram(program);
-
- // Check for linking errors
- GLint linked = 0;
- glGetProgramiv(program, GL_LINK_STATUS, &linked);
- if (linked != GL_TRUE) {
- // Log the linker error messages
- GLint log_length = 0;
- glGetProgramiv(program, GL_INFO_LOG_LENGTH, &log_length);
- if (log_length) {
- char* error_log = new char[log_length];
- if (error_log) {
- glGetProgramInfoLog(program, log_length, NULL, error_log);
- ALOGE("Program Linker Error:\n%s\n", error_log);
- delete[] error_log;
- }
- }
- glDeleteProgram(program);
- program = 0;
- }
- }
- return program;
-}
-
-void ShaderProgram::ScanUniforms() {
- int uniform_count;
- int buffer_size;
- GLenum type;
- GLint capacity;
- glGetProgramiv(program_, GL_ACTIVE_UNIFORMS, &uniform_count);
- glGetProgramiv(program_, GL_ACTIVE_UNIFORM_MAX_LENGTH, &buffer_size);
- std::vector<GLchar> name(buffer_size);
- for (int i = 0; i < uniform_count; ++i) {
- glGetActiveUniform(program_, i, buffer_size, NULL, &capacity, &type, &name[0]);
- ProgramVar uniform_id = glGetUniformLocation(program_, &name[0]);
- uniform_indices_[uniform_id] = i;
- }
-}
-
-bool ShaderProgram::PushCoords(ProgramVar attr, float* coords) {
- // If the shader does not define these, we simply ignore the coordinates, and assume that the
- // user is managing coordinates.
- if (attr >= 0) {
- const uint8_t* data = reinterpret_cast<const uint8_t*>(coords);
- glBindBuffer(GL_ARRAY_BUFFER, 0);
- glVertexAttribPointer(attr, 2, GL_FLOAT, false, 2 * sizeof(float), data);
- glEnableVertexAttribArray(attr);
- return !GLEnv::CheckGLError("Pushing vertex coordinates");
- }
- return true;
-}
-
-bool ShaderProgram::PushSourceCoords(float* coords) {
- ProgramVar tex_coord_attr = glGetAttribLocation(program_, TexCoordAttributeName().c_str());
- return PushCoords(tex_coord_attr, coords);
-}
-
-bool ShaderProgram::PushTargetCoords(float* coords) {
- ProgramVar pos_coord_attr = glGetAttribLocation(program_, PositionAttributeName().c_str());
- return PushCoords(pos_coord_attr, coords);
-}
-
-std::string ShaderProgram::InputTextureUniformName(int index) {
- std::stringstream tex_name;
- tex_name << "tex_sampler_" << index;
- return tex_name.str();
-}
-
-bool ShaderProgram::BindInputTextures(const std::vector<GLuint>& textures,
- const std::vector<GLenum>& targets) {
- for (unsigned i = 0; i < textures.size(); ++i) {
- // Activate texture unit i
- glActiveTexture(BaseTextureUnit() + i);
- if (GLEnv::CheckGLError("Activating Texture Unit"))
- return false;
-
- // Bind our texture
- glBindTexture(targets[i], textures[i]);
- LOG_FRAME("Binding texture %d", textures[i]);
- if (GLEnv::CheckGLError("Binding Texture"))
- return false;
-
- // Set the texture handle in the shader to unit i
- ProgramVar tex_var = GetUniform(InputTextureUniformName(i));
- if (tex_var >= 0) {
- glUniform1i(tex_var, i);
- } else {
- ALOGE("ShaderProgram: Shader does not seem to support %d number of "
- "inputs! Missing uniform 'tex_sampler_%d'!", textures.size(), i);
- return false;
- }
-
- if (GLEnv::CheckGLError("Texture Variable Binding"))
- return false;
- }
-
- return true;
-}
-
-bool ShaderProgram::UseProgram() {
- if (GLEnv::GetCurrentProgram() != program_) {
- LOG_FRAME("Using program %d", program_);
- glUseProgram(program_);
- return !GLEnv::CheckGLError("Use Program");
- }
- return true;
-}
-
-bool ShaderProgram::RenderFrame(const std::vector<GLuint>& textures,
- const std::vector<GLenum>& targets) {
- // Make sure we have enough texture units to accomodate the textures
- if (textures.size() > static_cast<unsigned>(MaxTextureUnits())) {
- ALOGE("ShaderProgram: Number of input textures is unsupported on this "
- "platform!");
- return false;
- }
-
- // Prepare to render
- if (!BeginDraw()) {
- ALOGE("ShaderProgram: couldn't initialize gl for drawing!");
- return false;
- }
-
- // Bind input textures
- if (!BindInputTextures(textures, targets)) {
- ALOGE("BindInputTextures failed");
- return false;
- }
-
- if (LOG_EVERY_FRAME) {
- int fbo, program, buffer;
- glGetIntegerv(GL_FRAMEBUFFER_BINDING, &fbo);
- glGetIntegerv(GL_CURRENT_PROGRAM, &program);
- glGetIntegerv(GL_ARRAY_BUFFER_BINDING, &buffer);
- ALOGV("RenderFrame: fbo %d prog %d buff %d", fbo, program, buffer);
- }
-
- // Render!
- const bool requestTile = (tile_x_count_ != 1 || tile_y_count_ != 1);
- const bool success = (!requestTile || !manage_coordinates_ || vertex_count_ != 4)
- ? Draw()
- : DrawTiled();
-
- // Pop vertex attributes
- PopAttributes();
-
- return success && !GLEnv::CheckGLError("Rendering");
-}
-
-bool ShaderProgram::Draw() {
- if (PushSourceCoords(source_coords_) && PushTargetCoords(target_coords_)) {
- glDrawArrays(draw_mode_, 0, vertex_count_);
- return true;
- }
- return false;
-}
-
-bool ShaderProgram::DrawTiled() {
- // Target coordinate step size
- float s[8];
- float t[8];
-
- // Step sizes
- const float xs = 1.0f / static_cast<float>(tile_x_count_);
- const float ys = 1.0f / static_cast<float>(tile_y_count_);
-
- // Tile drawing loop
- for (int i = 0; i < tile_x_count_; ++i) {
- for (int j = 0; j < tile_y_count_; ++j) {
- // Current coordinates in unit rectangle
- const float x = i / static_cast<float>(tile_x_count_);
- const float y = j / static_cast<float>(tile_y_count_);
-
- // Source coords
- GetTileCoords(source_coords_, x, y, &s[0], &s[1]);
- GetTileCoords(source_coords_, x + xs, y, &s[2], &s[3]);
- GetTileCoords(source_coords_, x, y + ys, &s[4], &s[5]);
- GetTileCoords(source_coords_, x + xs, y + ys, &s[6], &s[7]);
-
- // Target coords
- GetTileCoords(target_coords_, x, y, &t[0], &t[1]);
- GetTileCoords(target_coords_, x + xs, y, &t[2], &t[3]);
- GetTileCoords(target_coords_, x, y + ys, &t[4], &t[5]);
- GetTileCoords(target_coords_, x + xs, y + ys, &t[6], &t[7]);
-
- if (PushSourceCoords(s) && PushTargetCoords(t)) {
- glDrawArrays(draw_mode_, 0, vertex_count_);
- Yield();
- } else {
- return false;
- }
- }
- }
- return true;
-}
-
-void ShaderProgram::Yield() {
- glFinish();
-}
-
-bool ShaderProgram::BeginDraw() {
- // Activate shader program
- if (!UseProgram())
- return false;
-
- // Push vertex attributes
- PushAttributes();
-
- // Clear output, if requested
- if (clears_) {
- glClearColor(clear_color_.red,
- clear_color_.green,
- clear_color_.blue,
- clear_color_.alpha);
- glClear(GL_COLOR_BUFFER_BIT);
- }
-
- // Enable/Disable blending
- if (blending_) {
- glEnable(GL_BLEND);
- glBlendFunc(sfactor_, dfactor_);
- } else glDisable(GL_BLEND);
-
- return true;
-}
-
-int ShaderProgram::MaxVaryingCount() {
- GLint result;
- glGetIntegerv(GL_MAX_VARYING_VECTORS, &result);
- return result;
-}
-
-int ShaderProgram::MaxTextureUnits() {
- return GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS - 1;
-}
-
-void ShaderProgram::SetDrawMode(GLenum mode) {
- draw_mode_ = mode;
-}
-
-void ShaderProgram::SetClearsOutput(bool clears) {
- clears_ = clears;
-}
-
-void ShaderProgram::SetClearColor(float red, float green, float blue, float alpha) {
- clear_color_.red = red;
- clear_color_.green = green;
- clear_color_.blue = blue;
- clear_color_.alpha = alpha;
-}
-
-void ShaderProgram::SetTileCounts(int x_count, int y_count) {
- tile_x_count_ = x_count;
- tile_y_count_ = y_count;
-}
-
-// Variable Value Setting Helpers //////////////////////////////////////////////
-bool ShaderProgram::CheckValueCount(const std::string& var_type,
- const std::string& var_name,
- int expected_count,
- int components,
- int value_size) {
- if (expected_count != (value_size / components)) {
- ALOGE("Shader Program: %s Value Error (%s): Expected value length %d "
- "(%d components), but received length of %d (%d components)!",
- var_type.c_str(), var_name.c_str(),
- expected_count, components * expected_count,
- value_size / components, value_size);
- return false;
- }
- return true;
-}
-
-bool ShaderProgram::CheckValueMult(const std::string& var_type,
- const std::string& var_name,
- int components,
- int value_size) {
- if (value_size % components != 0) {
- ALOGE("Shader Program: %s Value Error (%s): Value must be multiple of %d, "
- "but %d elements were passed!", var_type.c_str(), var_name.c_str(),
- components, value_size);
- return false;
- }
- return true;
-}
-
-bool ShaderProgram::CheckVarValid(ProgramVar var) {
- if (!IsVarValid(var)) {
- ALOGE("Shader Program: Attempting to access invalid variable!");
- return false;
- }
- return true;
-}
-
-// Uniforms ////////////////////////////////////////////////////////////////////
-bool ShaderProgram::CheckUniformValid(ProgramVar var) {
- if (!IsVarValid(var) || uniform_indices_.find(var) == uniform_indices_.end()) {
- ALOGE("Shader Program: Attempting to access unknown uniform %d!", var);
- return false;
- }
- return true;
-}
-
-int ShaderProgram::MaxUniformCount() {
- // Here we return the minimum of the max uniform count for fragment and vertex
- // shaders.
- GLint count1, count2;
- glGetIntegerv(GL_MAX_VERTEX_UNIFORM_VECTORS, &count1);
- glGetIntegerv(GL_MAX_FRAGMENT_UNIFORM_VECTORS, &count2);
- return count1 < count2 ? count1 : count2;
-}
-
-ProgramVar ShaderProgram::GetUniform(const std::string& name) const {
- if (!IsExecutable()) {
- ALOGE("ShaderProgram: Error: Must link program before querying uniforms!");
- return -1;
- }
- return glGetUniformLocation(program_, name.c_str());
-}
-
-bool ShaderProgram::SetUniformValue(ProgramVar var, int value) {
- if (!CheckVarValid(var))
- return false;
-
- // Uniforms are local to the currently used program.
- if (UseProgram()) {
- glUniform1i(var, value);
- return !GLEnv::CheckGLError("Set Uniform Value (int)");
- }
- return false;
-}
-
-bool ShaderProgram::SetUniformValue(ProgramVar var, float value) {
- if (!CheckVarValid(var))
- return false;
-
- // Uniforms are local to the currently used program.
- if (UseProgram()) {
- glUniform1f(var, value);
- return !GLEnv::CheckGLError("Set Uniform Value (float)");
- }
- return false;
-}
-
-bool ShaderProgram::SetUniformValue(ProgramVar var,
- const int* values,
- int count) {
- if (!CheckUniformValid(var))
- return false;
-
- // Make sure we have values at all
- if (count == 0)
- return false;
-
- // Uniforms are local to the currently used program.
- if (UseProgram()) {
- // Get uniform information
- GLint capacity;
- GLenum type;
- char name[128];
- glGetActiveUniform(program_, IndexOfUniform(var), 128, NULL, &capacity, &type, name);
-
- // Make sure passed values are compatible
- const int components = GLEnv::NumberOfComponents(type);
- if (!CheckValueCount("Uniform (int)", name, capacity, components, count)
- || !CheckValueMult ("Uniform (int)", name, components, count))
- return false;
-
- // Set value based on type
- const int n = count / components;
- switch(type) {
- case GL_INT:
- glUniform1iv(var, n, values);
- break;
-
- case GL_INT_VEC2:
- glUniform2iv(var, n, values);
- break;
-
- case GL_INT_VEC3:
- glUniform3iv(var, n, values);
- break;
-
- case GL_INT_VEC4:
- glUniform4iv(var, n, values);
- break;
-
- default:
- return false;
- };
- return !GLEnv::CheckGLError("Set Uniform Value");
- }
- return false;
-}
-
-bool ShaderProgram::SetUniformValue(ProgramVar var,
- const float* values,
- int count) {
- if (!CheckUniformValid(var))
- return false;
-
- // Make sure we have values at all
- if (count == 0)
- return false;
-
- // Uniforms are local to the currently used program.
- if (UseProgram()) {
- // Get uniform information
- GLint capacity;
- GLenum type;
- char name[128];
- glGetActiveUniform(program_, IndexOfUniform(var), 128, NULL, &capacity, &type, name);
-
- // Make sure passed values are compatible
- const int components = GLEnv::NumberOfComponents(type);
- if (!CheckValueCount("Uniform (float)", name, capacity, components, count)
- || !CheckValueMult ("Uniform (float)", name, components, count))
- return false;
-
- // Set value based on type
- const int n = count / components;
- switch(type) {
- case GL_FLOAT:
- glUniform1fv(var, n, values);
- break;
-
- case GL_FLOAT_VEC2:
- glUniform2fv(var, n, values);
- break;
-
- case GL_FLOAT_VEC3:
- glUniform3fv(var, n, values);
- break;
-
- case GL_FLOAT_VEC4:
- glUniform4fv(var, n, values);
- break;
-
- case GL_FLOAT_MAT2:
- glUniformMatrix2fv(var, n, GL_FALSE, values);
- break;
-
- case GL_FLOAT_MAT3:
- glUniformMatrix3fv(var, n, GL_FALSE, values);
- break;
-
- case GL_FLOAT_MAT4:
- glUniformMatrix4fv(var, n, GL_FALSE, values);
- break;
-
- default:
- return false;
- };
- return !GLEnv::CheckGLError("Set Uniform Value");
- }
- return false;
-}
-
-bool ShaderProgram::SetUniformValue(ProgramVar var, const std::vector<int>& values) {
- return SetUniformValue(var, &values[0], values.size());
-}
-
-bool ShaderProgram::SetUniformValue(ProgramVar var,
- const std::vector<float>& values) {
- return SetUniformValue(var, &values[0], values.size());
-}
-
-bool ShaderProgram::SetUniformValue(const std::string& name, const Value& value) {
- if (ValueIsFloat(value))
- return SetUniformValue(GetUniform(name), GetFloatValue(value));
- else if (ValueIsInt(value))
- return SetUniformValue(GetUniform(name), GetIntValue(value));
- else if (ValueIsFloatArray(value))
- return SetUniformValue(GetUniform(name), GetFloatArrayValue(value), GetValueCount(value));
- else if (ValueIsIntArray(value))
- return SetUniformValue(GetUniform(name), GetIntArrayValue(value), GetValueCount(value));
- else
- return false;
-}
-
-Value ShaderProgram::GetUniformValue(const std::string& name) {
- ProgramVar var = GetUniform(name);
- if (CheckUniformValid(var)) {
- // Get uniform information
- GLint capacity;
- GLenum type;
- glGetActiveUniform(program_, IndexOfUniform(var), 0, NULL, &capacity, &type, NULL);
- if (!GLEnv::CheckGLError("Get Active Uniform")) {
- // Get value based on type, and wrap in value object
- switch(type) {
- case GL_INT: {
- int value;
- glGetUniformiv(program_, var, &value);
- return !GLEnv::CheckGLError("GetVariableValue") ? MakeIntValue(value)
- : MakeNullValue();
- } break;
-
- case GL_INT_VEC2: {
- int value[2];
- glGetUniformiv(program_, var, &value[0]);
- return !GLEnv::CheckGLError("GetVariableValue") ? MakeIntArrayValue(value, 2)
- : MakeNullValue();
- } break;
-
- case GL_INT_VEC3: {
- int value[3];
- glGetUniformiv(program_, var, &value[0]);
- return !GLEnv::CheckGLError("GetVariableValue") ? MakeIntArrayValue(value, 3)
- : MakeNullValue();
- } break;
-
- case GL_INT_VEC4: {
- int value[4];
- glGetUniformiv(program_, var, &value[0]);
- return !GLEnv::CheckGLError("GetVariableValue") ? MakeIntArrayValue(value, 4)
- : MakeNullValue();
- } break;
-
- case GL_FLOAT: {
- float value;
- glGetUniformfv(program_, var, &value);
- return !GLEnv::CheckGLError("GetVariableValue") ? MakeFloatValue(value)
- : MakeNullValue();
- } break;
-
- case GL_FLOAT_VEC2: {
- float value[2];
- glGetUniformfv(program_, var, &value[0]);
- return !GLEnv::CheckGLError("GetVariableValue") ? MakeFloatArrayValue(value, 2)
- : MakeNullValue();
- } break;
-
- case GL_FLOAT_VEC3: {
- float value[3];
- glGetUniformfv(program_, var, &value[0]);
- return !GLEnv::CheckGLError("GetVariableValue") ? MakeFloatArrayValue(value, 3)
- : MakeNullValue();
- } break;
-
- case GL_FLOAT_VEC4: {
- float value[4];
- glGetUniformfv(program_, var, &value[0]);
- return !GLEnv::CheckGLError("GetVariableValue") ? MakeFloatArrayValue(value, 4)
- : MakeNullValue();
- } break;
-
- case GL_FLOAT_MAT2: {
- float value[4];
- glGetUniformfv(program_, var, &value[0]);
- return !GLEnv::CheckGLError("GetVariableValue") ? MakeFloatArrayValue(value, 4)
- : MakeNullValue();
- } break;
-
- case GL_FLOAT_MAT3: {
- float value[9];
- glGetUniformfv(program_, var, &value[0]);
- return !GLEnv::CheckGLError("GetVariableValue") ? MakeFloatArrayValue(value, 9)
- : MakeNullValue();
- } break;
-
- case GL_FLOAT_MAT4: {
- float value[16];
- glGetUniformfv(program_, var, &value[0]);
- return !GLEnv::CheckGLError("GetVariableValue") ? MakeFloatArrayValue(value, 16)
- : MakeNullValue();
- } break;
- }
- }
- }
- return MakeNullValue();
-}
-
-GLuint ShaderProgram::IndexOfUniform(ProgramVar var) {
- return uniform_indices_[var];
-}
-
-// Attributes //////////////////////////////////////////////////////////////////////////////////////
-int ShaderProgram::MaxAttributeCount() {
- GLint result;
- glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &result);
- return result;
-}
-
-ProgramVar ShaderProgram::GetAttribute(const std::string& name) const {
- if (!IsExecutable()) {
- ALOGE("ShaderProgram: Error: Must link program before querying attributes!");
- return -1;
- } else if (name == PositionAttributeName() || name == TexCoordAttributeName()) {
- ALOGW("ShaderProgram: Attempting to overwrite internal vertex attribute '%s'!", name.c_str());
- }
- return glGetAttribLocation(program_, name.c_str());
-}
-
-bool ShaderProgram::SetAttributeValues(ProgramVar var,
- const VertexFrame* vbo,
- GLenum type,
- int components,
- int stride,
- int offset,
- bool normalize) {
- if (!CheckVarValid(var))
- return false;
-
- if (vbo) {
- VertexAttrib attrib;
- attrib.is_const = false;
- attrib.index = var;
- attrib.components = components;
- attrib.normalized = normalize;
- attrib.stride = stride;
- attrib.type = type;
- attrib.vbo = vbo->GetVboId();
- attrib.offset = offset;
-
- return StoreAttribute(attrib);
- }
- return false;
-}
-
-bool ShaderProgram::SetAttributeValues(ProgramVar var,
- const uint8_t* data,
- GLenum type,
- int components,
- int stride,
- int offset,
- bool normalize) {
- if (!CheckVarValid(var))
- return false;
-
- if (data) {
- VertexAttrib attrib;
- attrib.is_const = false;
- attrib.index = var;
- attrib.components = components;
- attrib.normalized = normalize;
- attrib.stride = stride;
- attrib.type = type;
- attrib.values = data + offset;
-
- return StoreAttribute(attrib);
- }
- return false;
-}
-
-bool ShaderProgram::SetAttributeValues(ProgramVar var,
- const std::vector<float>& data,
- int components) {
- return SetAttributeValues(var, &data[0], data.size(), components);
-}
-
-bool ShaderProgram::SetAttributeValues(ProgramVar var,
- const float* data,
- int total,
- int components) {
- if (!CheckVarValid(var))
- return false;
-
- // Make sure the passed data vector has a valid size
- if (total % components != 0) {
- ALOGE("ShaderProgram: Invalid attribute vector given! Specified a component "
- "count of %d, but passed a non-multiple vector of size %d!",
- components, total);
- return false;
- }
-
- // Copy the data to a buffer we own
- float* data_cpy = new float[total];
- memcpy(data_cpy, data, sizeof(float) * total);
-
- // Store the attribute
- VertexAttrib attrib;
- attrib.is_const = false;
- attrib.index = var;
- attrib.components = components;
- attrib.normalized = false;
- attrib.stride = components * sizeof(float);
- attrib.type = GL_FLOAT;
- attrib.values = data_cpy;
- attrib.owned_data = data_cpy; // Marks this for deletion later on
-
- return StoreAttribute(attrib);
-}
-
-bool ShaderProgram::StoreAttribute(VertexAttrib attrib) {
- if (attrib.index >= 0) {
- attrib_values_[attrib.index] = attrib;
- return true;
- }
- return false;
-}
-
-bool ShaderProgram::PushAttributes() {
- for (VertexAttribMap::const_iterator iter = attrib_values_.begin();
- iter != attrib_values_.end();
- ++iter) {
- const VertexAttrib& attrib = iter->second;
-
- if (attrib.is_const) {
- // Set constant attribute values (must be specified as host values)
- if (!attrib.values)
- return false;
-
- const float* values = reinterpret_cast<const float*>(attrib.values);
- switch (attrib.components) {
- case 1: glVertexAttrib1fv(attrib.index, values); break;
- case 2: glVertexAttrib2fv(attrib.index, values); break;
- case 3: glVertexAttrib3fv(attrib.index, values); break;
- case 4: glVertexAttrib4fv(attrib.index, values); break;
- default: return false;
- }
- glDisableVertexAttribArray(attrib.index);
- } else {
- // Set per-vertex values
- if (attrib.values) {
- // Make sure no buffer is bound and set attribute
- glBindBuffer(GL_ARRAY_BUFFER, 0);
-
- glVertexAttribPointer(attrib.index,
- attrib.components,
- attrib.type,
- attrib.normalized,
- attrib.stride,
- attrib.values);
- } else if (attrib.vbo) {
- // Bind VBO and set attribute
- glBindBuffer(GL_ARRAY_BUFFER, attrib.vbo);
-
- glVertexAttribPointer(attrib.index,
- attrib.components,
- attrib.type,
- attrib.normalized,
- attrib.stride,
- reinterpret_cast<const void*>(attrib.offset));
- } else {
- return false;
- }
- glEnableVertexAttribArray(attrib.index);
- }
-
- // Make sure everything worked
- if (GLEnv::CheckGLError("Pushing Vertex Attributes"))
- return false;
- }
-
- return true;
-}
-
-bool ShaderProgram::PopAttributes() {
- // Disable vertex attributes
- for (VertexAttribMap::const_iterator iter = attrib_values_.begin();
- iter != attrib_values_.end();
- ++iter) {
- glDisableVertexAttribArray(iter->second.index);
- }
- // Unbind buffer: Very important as this greatly affects what glVertexAttribPointer does!
- glBindBuffer(GL_ARRAY_BUFFER, 0);
- return !GLEnv::CheckGLError("Popping Vertex Attributes");
-}
-
-void ShaderProgram::SetVertexCount(int count) {
- vertex_count_ = count;
-}
-
-} // namespace filterfw
-} // namespace android
+++ /dev/null
-/*
- * 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.
- */
-
-#ifndef ANDROID_FILTERFW_CORE_SHADER_PROGRAM_H
-#define ANDROID_FILTERFW_CORE_SHADER_PROGRAM_H
-
-#include <vector>
-#include <map>
-#include <string>
-
-#include <GLES2/gl2.h>
-#include <GLES2/gl2ext.h>
-#include <EGL/egl.h>
-
-#include "core/gl_env.h"
-#include "core/value.h"
-
-namespace android {
-namespace filterfw {
-
-class GLFrame;
-class GLFrameBufferHandle;
-class GLTextureHandle;
-class Quad;
-class VertexFrame;
-
-typedef GLint ProgramVar;
-
-// A ShaderProgram is a Program object that holds a GLSL shader implementation.
-// It provides functionality for compiling, linking, and executing the shader.
-// On top of that, it provides access to the shaders source code, uniforms,
-// attributes, and other properties.
-// By default a ShaderProgram provides its own vertex shader. However, a custom
-// vertex shader may be passed and used instead.
-// When implementing a vertex shader, the following attribute names have special
-// meaning:
-//
-// - a_position: The vertex position
-// - a_texcoord: The texture cooridnates
-//
-// The shader program will bind these attributes to the correct values, if they
-// are present in the vertex shader source code.
-//
-// When implementing the fragment shader, the following variable names must be
-// defined:
-//
-// - tex_sampler_<n>: The n'th input texture. For instance, use tex_sampler_0
-// for the first input texture. Must be a uniform sampler2D.
-// - v_texcoord: The current texture coordinate.
-//
-// If more input textures are given than the shader can handle, this will result
-// in an error.
-//
-class ShaderProgram {
- public:
- // General Functionality ///////////////////////////////////////////////////
- // Create a new shader program with the given fragment shader source code.
- // A default vertex shader is used, which renders the input texture to a
- // rectangular region of the output texture. You can modify the input and
- // output regions by using the SetSourceRegion(...) and SetTargetRegion(...)
- // (and related) functions below.
- // This program will not be executable until you have compiled and linked
- // it.
- // Note, that the ShaderProgram does NOT take ownership of the GLEnv. The
- // caller must make sure the GLEnv stays valid as long as the GLFrame is
- // alive.
- explicit ShaderProgram(GLEnv* gl_env, const std::string& fragment_shader);
-
- // Create a new shader program with the given fragment and vertex shader
- // source code. This program will not be executable until you have compiled
- // and linked it.
- // Note, that the ShaderProgram does NOT take ownership of the GLEnv. The
- // caller must make sure the GLEnv stays valid as long as the GLFrame is
- // alive.
- ShaderProgram(GLEnv* gl_env,
- const std::string& vertex_shader,
- const std::string& fragment_shader);
-
- // Destructor.
- ~ShaderProgram();
-
- // Process the given input frames and write the result to the output frame.
- // Returns false if there was an error processing.
- bool Process(const std::vector<const GLFrame*>& inputs, GLFrame* output);
-
- // Same as above, but pass GL interfaces rather than frame objects. Use this
- // only if you are not working on Frame objects, but rather directly on GL
- // textures and FBOs.
- bool Process(const std::vector<const GLTextureHandle*>& input,
- GLFrameBufferHandle* output);
-
- // Compile and link the shader source code. Returns true if compilation
- // and linkage was successful. Compilation and linking error messages are
- // written to the error log.
- bool CompileAndLink();
-
- // Returns true if this Program has been compiled and linked successfully.
- bool IsExecutable() const {
- return program_ != 0;
- }
-
- // Returns true if the shader program variable is valid.
- static bool IsVarValid(ProgramVar var);
-
- // Special ShaderPrograms //////////////////////////////////////////////////
- // A (compiled) shader program which assigns the sampled pixels from the
- // input to the output. Note that transformations may be applied to achieve
- // effects such as cropping, scaling or rotation.
- // The caller takes ownership of the result!
- static ShaderProgram* CreateIdentity(GLEnv* env);
-
- // Geometry ////////////////////////////////////////////////////////////////
- // These functions modify the source and target regions used during
- // rasterization. Note, that these functions will ONLY take effect if
- // the default vertex shader is used, or your custom vertex shader defines
- // the a_position and a_texcoord attributes.
-
- // Set the program to read from a subregion of the input frame, given by
- // the origin (x, y) and dimensions (width, height). Values are considered
- // normalized between 0.0 and 1.0. If this region exceeds the input frame
- // dimensions the results are undefined.
- void SetSourceRect(float x, float y, float width, float height) ;
-
- // Set the program to read from a subregion of the input frame, given by
- // the passed Quad. Values are considered normalized between 0.0 and 1.0.
- // The Quad points are expected to be in the order top-left, top-right,
- // bottom-left, bottom-right.
- // If this region exceeds the input frame dimensions the results are
- // undefined.
- void SetSourceRegion(const Quad& quad);
-
- // Set the program to write to a subregion of the output frame, given by
- // the origin (x, y) and dimensions (width, height). Values are considered
- // normalized between 0.0 and 1.0. If this region exceeds the output frame
- // dimensions the image will be clipped.
- void SetTargetRect(float x, float y, float width, float height);
-
- // Set the program to write to a subregion of the output frame, given by
- // the passed Quad. Values are considered normalized between 0.0 and 1.0.
- // The Quad points are expected to be in the order top-left, top-right,
- // bottom-left, bottom-right.
- // If this region exceeds the output frame dimensions the image will be
- // clipped.
- void SetTargetRegion(const Quad& quad);
-
- // Uniform Variable access /////////////////////////////////////////////////
- // Note: In order to get and set uniforms, the program must have been
- // successfully compiled and linked. Otherwise, the getters will return an
- // invalid ProgramVar variable (check with IsVarValid()).
- // When setting values, the value type must be match the type of the uniform
- // in the shader. For instance, a vector of 3 elements cannot be assigned to
- // a vec2. Similarly, an integer value cannot be assigned to a float value.
- // Such a type mismatch will result in failure to set the value (which will
- // remain untouched). Check the return value of the setters to determine
- // success.
-
- // Returns the maximum number of uniforms supported by this implementation.
- static int MaxUniformCount();
-
- // Returns a handle to the uniform with the given name, or invalid if no
- // such uniform variable exists in the shader.
- ProgramVar GetUniform(const std::string& name) const;
-
- // Set the specified uniform value to the given integer value. Returns true
- // if the assignment was successful.
- bool SetUniformValue(ProgramVar var, int value);
-
- // Set the specified uniform value to the given float value. Returns true
- // if the assignment was successful.
- bool SetUniformValue(ProgramVar var, float value);
-
- // Set the specified uniform value to the given values. Returns true
- // if the assignment was successful.
- bool SetUniformValue(ProgramVar var, const int* values, int count);
-
- // Set the specified uniform value to the given values. Returns true
- // if the assignment was successful.
- bool SetUniformValue(ProgramVar var, const float* values, int count);
-
- // Set the specified uniform value to the given vector value. Returns true
- // if the assignment was successful.
- bool SetUniformValue(ProgramVar var, const std::vector<int>& values);
-
- // Set the specified uniform value to the given vector value. Returns true
- // if the assignment was successful.
- bool SetUniformValue(ProgramVar var, const std::vector<float>& values);
-
- // Generic variable setter, which in the case of GL programs always attempts
- // to set the value of a uniform variable with the given name. Only values
- // of type float, float array (or vector), and int are supported.
- bool SetUniformValue(const std::string& name, const Value& value);
-
- // Generic variable getter, which in the case of GL programs always attempts
- // to get the value of a uniform variable with the given name.
- Value GetUniformValue(const std::string& name);
-
- // Returns the default name of the input texture uniform variable for the
- // given input index.
- static std::string InputTextureUniformName(int index);
-
- // Attribute access ////////////////////////////////////////////////////////
- // Note: In order to get and set attributes, the program must have been
- // successfully compiled and linked. Otherwise, the getters will return an
- // invalid ProgramVar variable (check with IsVarValid()). Constant attribute
- // values must be floats. Attribute pointers must be associated with a
- // specific type, which can be any of the following:
- // GL_BYTE, GL_UNSIGNED_BYTE, GL_SHORT, GL_UNSIGNED_SHORT, GL_FLOAT,
- // GL_FIXED, GL_HALF_FLOAT_OES.
- // When storing vertex data, it is recommended to use VertexFrames when
- // possible as these will be kept in GPU memory, and no copying of vertex
- // attributes between system and GPU memory needs to take place.
-
- // Returns the maximum number of attributes supported by this
- // implementation.
- static int MaxAttributeCount();
-
- // Returns a handle to the attribute with the given name, or invalid if no
- // such attribute exists in the vertex shader.
- ProgramVar GetAttribute(const std::string& name) const;
-
- // Set an attribute value that will be constant for each vertex. Returns
- // true if the assignment was successful.
- bool SetConstAttributeValue(ProgramVar var, float value);
-
- // Set an attribute vector value that will be constant for each vertex.
- // Returns true if the assignment was successful.
- bool SetConstAttributeValue(ProgramVar var, const std::vector<float>& value);
-
- // Set attribute values that differ across vertexes, using a VertexFrame.
- // This is the recommended method of specifying vertex data, that does not
- // change from iteration to iteration. The parameters are as follows:
- // var: The shader variable to bind the values to.
- // data: The vertex frame which holds the vertex data. This may be a
- // superset of the data required for this particular vertex. Use the
- // offset and stride to select the correct data portion.
- // type: The type of the data values. This may differ from the type of the
- // shader variables. See the normalize flag on how values are
- // converted.
- // components: The number of components per value. Valid values are 1-4.
- // stride: The delta of one element to the next in bytes.
- // offset: The offset of the first element.
- // normalize: True, if not float values should be normalized to the range
- // 0-1, when converted to a float.
- // Returns true, if the assignment was successful.
- bool SetAttributeValues(ProgramVar var,
- const VertexFrame* data,
- GLenum type,
- int components,
- int stride,
- int offset,
- bool normalize);
-
- // Set attribute values that differ across vertexes, using a data buffer.
- // This is the recommended method of specifying vertex data, if your data
- // changes often. Note that this data may need to be copied to GPU memory
- // for each render pass. Please see above for a description of the
- // parameters.
- // Note: The data passed here MUST be valid until all executions of this
- // Program instance have been completed!
- bool SetAttributeValues(ProgramVar var,
- const uint8_t* data,
- GLenum type,
- int components,
- int stride,
- int offset,
- bool normalize);
-
- // Convenience method for setting vertex values using a vector of floats.
- // The components parameter specifies how many elements per variable should
- // be assigned (The variable must be able to fit the number of components).
- // It must be a value between 1 and 4.
- // While this method is not as flexible as the methods above, this can be
- // used when more advanced methods are not necessary. Note, that if your
- // vertex data does not change, it is recommended to use a VertexFrame.
- bool SetAttributeValues(ProgramVar var,
- const std::vector<float>& data,
- int components);
-
- // Same as above, but using a float pointer instead of vector. Pass the
- // total number of elements in total.
- bool SetAttributeValues(ProgramVar var,
- const float* data,
- int total,
- int components);
-
- // By default, rendering only uses the first 4 vertices. You should only
- // adjust this value if you are providing your own vertex attributes with
- // a count unequal to 4. Adjust this value before calling Process().
- void SetVertexCount(int count);
-
- // Returns the default name of the attribute used to hold the texture
- // coordinates. Use this when you need to access the texture coordinate
- // attribute of the shader's default vertex shader.
- static const std::string& TexCoordAttributeName() {
- static std::string s_texcoord("a_texcoord");
- return s_texcoord;
- }
-
- // Returns the default name of the attribute used to hold the output
- // coordinates. Use this when you need to access the output coordinate
- // attribute of the shader's default vertex shader.
- static const std::string& PositionAttributeName() {
- static std::string s_position("a_position");
- return s_position;
- }
-
- // Rendering ///////////////////////////////////////////////////////////////
- // Set the draw mode, which can be any of GL_POINTS, GL_LINES,
- // GL_LINE_STRIP, GL_LINE_LOOP, GL_TRIANGLES, GL_TRIANGLE_STRIP,
- // GL_TRIANGLE_FAN. The default is GL_TRIANGLE_STRIP.
- // Warning: Do NOT change this if you are not specifying your own vertex
- // data with SetAttributeValues(...).
- void SetDrawMode(GLenum mode);
-
- // If you are doing your own drawing you should call this before beginning
- // to draw. This will activate the program, push all used attributes, and
- // clear the frame if requested. You do not need to call this if you are
- // not doing your own GL drawing!
- bool BeginDraw();
-
- // Render a single frame with the given input textures. You may override
- // this, if you need custom rendering behavior. However, you must take
- // care of the following things when overriding:
- // - Use the correct program (e.g. by calling UseProgram()).
- // - Bind the given textures
- // - Bind vertex attributes
- // - Draw
- bool RenderFrame(const std::vector<GLuint>& textures,
- const std::vector<GLenum>& targets);
-
- // Pass true to clear the output frame before rendering. The color used
- // to clear is set in SetClearColor().
- void SetClearsOutput(bool clears);
-
- // Set the color used to clear the output frame before rendering. You
- // must activate clearing by calling SetClearsOutput(true).
- void SetClearColor(float red, float green, float blue, float alpha);
-
- // Set the number of tiles to split rendering into. Higher tile numbers
- // will affect performance negatively, but will allow other GPU threads
- // to render more frequently. Defaults to 1, 1.
- void SetTileCounts(int x_count, int y_count);
-
- // Enable or Disable Blending
- // Set to true to enable, false to disable.
- void SetBlendEnabled(bool enable) {
- blending_ = enable;
- }
-
- // Specify pixel arithmetic for blending
- // The values of sfactor and dfactor can be:
- // GL_ZERO, GL_ONE, GL_SRC_COLOR, GL_ONE_MINUS_SRC_COLOR, GL_SRC_ALPHA,
- // GL_ONE_MINUS_SRC_ALPHA, GL_DST_ALPHA, GL_ONE_MINUS_DST_ALPHA,
- // GL_DST_COLOR, GL_ONE_MINUS_DST_COLOR, GL_SRC_ALPHA_SATURATE
- // Default values for blending are set to:
- // sfactor = GL_SRC_ALPHA
- // dfactor = GL_ONE_MINUS_SRC_ALPHA
- void SetBlendFunc(int sfactor, int dfactor) {
- sfactor_ = sfactor;
- dfactor_ = dfactor;
- }
-
- // Accessing the Compiled Program //////////////////////////////////////////
- // Use the compiled and linked program for rendering. You should not need
- // to call this, unless you are implementing your own rendering method.
- bool UseProgram();
-
- // Other Properties ////////////////////////////////////////////////////////
- // Returns the maximum number of varyings supported by this implementation.
- static int MaxVaryingCount();
-
- // Returns the maximum number of texture units supported by this
- // implementation.
- static int MaxTextureUnits();
-
- // Lower level functionality ///////////////////////////////////////////////
- // Compile the shader with the given source. The shader_type must be either
- // GL_VERTEX_SHADER or GL_FRAGMENT_SHADER.
- static GLuint CompileShader(GLenum shader_type, const char* source);
-
- // Link the compiled shader objects and return the resulting program.
- static GLuint LinkProgram(GLuint* shaders, GLuint count);
-
- // Returns the lowest texture unit that will be used to bind textures.
- GLuint BaseTextureUnit() const {
- return base_texture_unit_;
- }
-
- // Sets the lowest texture unit that will be used to bind textures. The
- // default value is GL_TEXTURE0.
- void SetBaseTextureUnit(GLuint texture_unit) {
- base_texture_unit_ = texture_unit;
- }
-
- private:
- // Structure to store vertex attribute data.
- struct VertexAttrib {
- bool is_const;
- int index;
- bool normalized;
- int stride;
- int components;
- int offset;
- GLenum type;
- GLuint vbo;
- const void* values;
- float* owned_data;
-
- VertexAttrib();
- };
- typedef std::map<ProgramVar, VertexAttrib> VertexAttribMap;
-
- struct RGBAColor {
- float red;
- float green;
- float blue;
- float alpha;
-
- RGBAColor() : red(0), green(0), blue(0), alpha(1) {
- }
- };
-
- // Scans for all uniforms in the shader and creates index -> id map.
- void ScanUniforms();
-
- // Returns the index of the given uniform. The caller must make sure
- // that the variable id passed is valid.
- GLuint IndexOfUniform(ProgramVar var);
-
- // Binds the given input textures.
- bool BindInputTextures(const std::vector<GLuint>& textures,
- const std::vector<GLenum>& targets);
-
- // Sets the default source and target coordinates.
- void SetDefaultCoords();
-
- // Pushes the specified coordinates to the shader attribute.
- bool PushCoords(ProgramVar attr, float* coords);
-
- // Pushes the source coordinates.
- bool PushSourceCoords(float* coords);
-
- // Pushes the target coordinates.
- bool PushTargetCoords(float* coords);
-
- // Performs (simple) GL drawing.
- bool Draw();
-
- // Performs tiled GL drawing.
- bool DrawTiled();
-
- // Yields to other GPU threads.
- void Yield();
-
- // Helper method to assert that the variable value passed has the correct
- // total size.
- static bool CheckValueCount(const std::string& var_type,
- const std::string& var_name,
- int expected_count,
- int components,
- int value_size);
-
- // Helper method to assert that the variable value passed has a size, that
- // is compatible with the type size (must be divisible).
- static bool CheckValueMult(const std::string& var_type,
- const std::string& var_name,
- int components,
- int value_size);
-
- // Checks that the variable is valid. Logs an error and returns false if
- // not.
- static bool CheckVarValid(ProgramVar var);
-
- // Returns true if the uniform specified by var is an active uniform in the
- // program.
- bool CheckUniformValid(ProgramVar var);
-
- // Store an attribute to use when rendering.
- bool StoreAttribute(VertexAttrib attrib);
-
- // Push all assigned attributes before rendering.
- bool PushAttributes();
-
- // Pop all assigned attributes after rendering.
- bool PopAttributes();
-
- // The shader source code
- std::string fragment_shader_source_;
- std::string vertex_shader_source_;
-
- // The compiled shaders and linked program
- GLuint fragment_shader_;
- GLuint vertex_shader_;
- GLuint program_;
-
- // The GL environment this shader lives in.
- GLEnv* gl_env_;
-
- // The lowest texture unit this program will use
- GLuint base_texture_unit_;
-
- // The current source and target coordinates to render from/to.
- float* source_coords_;
- float* target_coords_;
-
- // True, if the program has control over both source and target coordinates.
- bool manage_coordinates_;
-
- // The number of tiles to split rendering into.
- int tile_x_count_;
- int tile_y_count_;
-
- // List of attribute data that we need to set before rendering
- VertexAttribMap attrib_values_;
-
- // The number of vertices to render
- int vertex_count_;
-
- // The draw mode used during rendering
- GLenum draw_mode_;
-
- // True, iff the output frame is cleared before rendering
- bool clears_;
-
- // The color used to clear the output frame.
- RGBAColor clear_color_;
-
- // Set to true to enable blending.
- bool blending_;
- int sfactor_;
- int dfactor_;
-
- // Map from uniform ids to indices
- std::map<ProgramVar, GLuint> uniform_indices_;
-};
-
-} // namespace filterfw
-} // namespace android
-
-#endif // ANDROID_FILTERFW_CORE_SHADER_PROGRAM_H
+++ /dev/null
-/*
- * 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.
- */
-
-#include "core/statistics.h"
-
-#include <math.h>
-
-namespace android {
-namespace filterfw {
-
-IncrementalGaussian::IncrementalGaussian()
- : n_(0),
- sum_x_(0.0f),
- sum_x2_(0.0f),
- mean_(0.0f),
- var_(0.0f),
- exp_denom_(0.0f),
- pdf_denom_(0.0f) {
-}
-
-void IncrementalGaussian::Add(float value) {
- ++n_;
- sum_x_ += value;
- sum_x2_ += value * value;
-
- mean_ = sum_x_ / n_;
- var_ = sum_x2_ / n_ - mean_ * mean_;
-
- exp_denom_ = 2.0f * var_;
- pdf_denom_ = sqrtf(M_PI * exp_denom_);
-}
-
-float IncrementalGaussian::Std() const {
- return sqrtf(var_);
-}
-
-float IncrementalGaussian::Pdf(float value) const {
- if (var_ == 0.0f) { return n_ > 0 ? value == mean_ : 0.0f; }
- const float diff = value - mean_;
- return expf(-diff * diff / exp_denom_) / pdf_denom_;
-}
-
-} // namespace filterfw
-} // namespace android
+++ /dev/null
-/*
- * 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.
- */
-
-#ifndef ANDROID_FILTERFW_CORE_STATISTICS_H
-#define ANDROID_FILTERFW_CORE_STATISTICS_H
-
-namespace android {
-namespace filterfw {
-
-// An incrementally-constructed Normal distribution.
-class IncrementalGaussian {
- public:
- IncrementalGaussian();
-
- void Add(float value);
-
- float NumSamples() const { return n_; }
- float Mean() const { return mean_; }
- float Var() const { return var_; }
- float Std() const;
- float Pdf(float value) const;
-
- private:
- int n_;
- float sum_x_;
- float sum_x2_;
- float mean_;
- float var_;
- float exp_denom_;
- float pdf_denom_;
-};
-
-// Discrete-time implementation of a simple RC low-pass filter:
-// exponentially-weighted moving average.
-class RCFilter {
- public:
- explicit RCFilter(float gain)
- : gain_(gain), n_(0), value_(0.0f) {}
-
- void Add(float measurement) {
- value_ = n_++ ? gain_ * measurement + (1.0f - gain_) * value_ : measurement;
- }
-
- void Reset() { n_ = 0; }
-
- int NumMeasurements() const { return n_; }
- float Output() const { return value_; }
-
- private:
- float gain_;
- int n_;
- float value_;
-};
-
-} // namespace filterfw
-} // namespace android
-
-#endif // ANDROID_FILTERFW_CORE_STATISTICS_H
+++ /dev/null
-/*
- * 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.
- */
-
-#include "base/logging.h"
-#include "base/utilities.h"
-
-#include "core/time_util.h"
-
-#include <map>
-#include <string>
-#include <sys/time.h>
-
-namespace android {
-namespace filterfw {
-
-uint64_t getTimeUs() {
- static long basesec;
- struct timeval tv;
- uint64_t nowtime;
- gettimeofday(&tv, 0);
- if (basesec == 0) {
- basesec = tv.tv_sec;
- }
- nowtime = (uint64_t)(tv.tv_sec - basesec) * (uint64_t)1000000 +
- (uint64_t)tv.tv_usec;
- return nowtime;
-}
-
-const uint64_t NamedStopWatch::kDefaultLoggingPeriodInFrames = 100;
-
-NamedStopWatch::NamedStopWatch(const std::string& name)
- : mName(name),
- mLoggingPeriodInFrames(kDefaultLoggingPeriodInFrames),
- mStartUSec(0),
- mNumCalls(0),
- mTotalUSec(0) {
-}
-
-void NamedStopWatch::Start() {
- mStartUSec = getTimeUs();
-}
-
-void NamedStopWatch::Stop() {
- if (!mStartUSec) {
- return;
- }
- uint64_t stopUSec = getTimeUs();
- if (stopUSec > mStartUSec) {
- ++mNumCalls;
- mTotalUSec += stopUSec - mStartUSec;
- if (mNumCalls % mLoggingPeriodInFrames == 0) {
- const float mSec = TotalUSec() * 1.0E-3f / NumCalls();
- ALOGE("%s: %f ms", Name().c_str(), mSec);
- }
- }
- mStartUSec = 0;
-}
-
-namespace {
-static NamedStopWatch* GetWatchForName(const string& watch_name) {
- // TODO: this leaks the NamedStopWatch objects. Replace it with a
- // singleton to avoid that and make it thread safe.
- static map<string, NamedStopWatch*> watches;
- NamedStopWatch* watch = FindPtrOrNull(watches, watch_name);
- if (!watch) {
- watch = new NamedStopWatch(watch_name);
- watches[watch_name] = watch;
- }
- return watch;
-};
-} // namespace
-
-ScopedTimer::ScopedTimer(const string& stop_watch_name) {
- mWatch = GetWatchForName(stop_watch_name);
- mWatch->Start();
-}
-
-} // namespace filterfw
-} // namespace android
+++ /dev/null
-/*
- * 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.
- */
-
-#ifndef ANDROID_FILTERFW_CORE_TIME_UTIL_H
-#define ANDROID_FILTERFW_CORE_TIME_UTIL_H
-
-#include <string>
-#include <utils/RefBase.h>
-
-#define LOG_MFF_RUNNING_TIMES 0
-
-namespace android {
-namespace filterfw {
-
-uint64_t getTimeUs();
-
-class NamedStopWatch : public RefBase {
- public:
- static const uint64_t kDefaultLoggingPeriodInFrames;
-
- explicit NamedStopWatch(const string& name);
- void Start();
- void Stop();
-
- void SetName(const string& name) { mName = name; }
- void SetLoggingPeriodInFrames(uint64_t numFrames) {
- mLoggingPeriodInFrames = numFrames;
- }
-
- const string& Name() const { return mName; }
- uint64_t NumCalls() const { return mNumCalls; }
- uint64_t TotalUSec() const { return mTotalUSec; }
-
- private:
- string mName;
- uint64_t mLoggingPeriodInFrames;
- uint64_t mStartUSec;
- uint64_t mNumCalls;
- uint64_t mTotalUSec;
-};
-
-class ScopedTimer {
- public:
- explicit ScopedTimer(const string& stop_watch_name);
- explicit ScopedTimer(NamedStopWatch* watch)
- : mWatch(watch) { mWatch->Start(); }
- ~ScopedTimer() { mWatch->Stop(); }
-
- private:
- NamedStopWatch* mWatch;
-};
-
-} // namespace filterfw
-} // namespace android
-
-#endif // ANDROID_FILTERFW_CORE_TIME_UTIL_H
+++ /dev/null
-/*
- * 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.
- */
-
-#include <stddef.h>
-#include <stdlib.h>
-
-#include "value.h"
-
-#define NULL_VALUE_TYPE 0
-#define INT_VALUE_TYPE 1
-#define FLOAT_VALUE_TYPE 2
-#define STRING_VALUE_TYPE 3
-#define BUFFER_VALUE_TYPE 4
-#define MUTABLE_BUFFER_VALUE_TYPE 5
-#define INT_ARRAY_VALUE_TYPE 6
-#define FLOAT_ARRAY_VALUE_TYPE 7
-
-// Templated versions //////////////////////////////////////////////////////////////////////////////
-template<typename POD, int TYPEID>
-POD GetPODValue(Value value) {
- return value.type == TYPEID ? *reinterpret_cast<POD*>(value.value) : POD();
-}
-
-template<typename PTR, int TYPEID>
-PTR GetPtrValue(Value value) {
- return value.type == TYPEID ? reinterpret_cast<PTR>(value.value) : NULL;
-}
-
-template<typename POD, int TYPEID>
-Value MakePODValue(POD value) {
- Value result;
- result.type = TYPEID;
- result.value = malloc(sizeof(POD));
- result.count = 1;
- *reinterpret_cast<POD*>(result.value) = value;
- return result;
-}
-
-template<typename BASE, int TYPEID>
-Value MakePtrValue(const BASE* values, int count) {
- Value result;
- result.type = TYPEID;
- result.value = malloc(sizeof(BASE) * count);
- memcpy(result.value, values, sizeof(BASE) * count);
- result.count = count;
- return result;
-}
-
-template<typename POD, int TYPEID>
-int SetPODValue(Value* value, POD new_value) {
- if (value->type == NULL_VALUE_TYPE) {
- value->type = TYPEID;
- value->value = malloc(sizeof(POD));
- value->count = 1;
- }
- if (value->type == TYPEID) {
- *reinterpret_cast<POD*>(value->value) = new_value;
- return 1;
- }
- return 0;
-}
-
-template<typename BASE, int TYPEID>
-int SetPtrValue(Value* value, const BASE* new_values, int count) {
- if (value->type == NULL_VALUE_TYPE) {
- value->type = TYPEID;
- value->value = malloc(sizeof(BASE) * count);
- value->count = count;
- }
- if (value->type == TYPEID && value->count == count) {
- memcpy(value->value, new_values, sizeof(BASE) * count);
- return 1;
- }
- return 0;
-}
-
-// C Wrappers //////////////////////////////////////////////////////////////////////////////////////
-int GetIntValue(Value value) {
- return GetPODValue<int, INT_VALUE_TYPE>(value);
-}
-
-float GetFloatValue(Value value) {
- return GetPODValue<float, FLOAT_VALUE_TYPE>(value);
-}
-
-const char* GetStringValue(Value value) {
- return GetPtrValue<const char*, STRING_VALUE_TYPE>(value);
-}
-
-const char* GetBufferValue(Value value) {
- return (value.type == BUFFER_VALUE_TYPE || value.type == MUTABLE_BUFFER_VALUE_TYPE)
- ? (const char*)value.value
- : NULL;
-}
-
-char* GetMutableBufferValue(Value value) {
- return GetPtrValue<char*, MUTABLE_BUFFER_VALUE_TYPE>(value);
-}
-
-int* GetIntArrayValue(Value value) {
- return GetPtrValue<int*, INT_ARRAY_VALUE_TYPE>(value);
-}
-
-float* GetFloatArrayValue(Value value) {
- return GetPtrValue<float*, FLOAT_ARRAY_VALUE_TYPE>(value);
-}
-
-int ValueIsNull(Value value) {
- return value.type == NULL_VALUE_TYPE;
-}
-
-int ValueIsInt(Value value) {
- return value.type == INT_VALUE_TYPE;
-}
-
-int ValueIsFloat(Value value) {
- return value.type == FLOAT_VALUE_TYPE;
-}
-
-int ValueIsString(Value value) {
- return value.type == STRING_VALUE_TYPE;
-}
-
-int ValueIsBuffer(Value value) {
- return value.type == BUFFER_VALUE_TYPE || value.type == MUTABLE_BUFFER_VALUE_TYPE;
-}
-
-int ValueIsIntArray(Value value) {
- return value.type == INT_ARRAY_VALUE_TYPE;
-}
-
-int ValueIsFloatArray(Value value) {
- return value.type == FLOAT_ARRAY_VALUE_TYPE;
-}
-
-Value MakeNullValue() {
- Value result;
- result.type = NULL_VALUE_TYPE;
- result.value = NULL;
- result.count = 0;
- return result;
-}
-
-Value MakeIntValue(int value) {
- return MakePODValue<int, INT_VALUE_TYPE>(value);
-}
-
-Value MakeFloatValue(float value) {
- return MakePODValue<float, FLOAT_VALUE_TYPE>(value);
-}
-
-Value MakeStringValue(const char* value) {
- return MakePtrValue<char, STRING_VALUE_TYPE>(value, strlen(value) + 1);
-}
-
-Value MakeBufferValue(const char* buffer, int size) {
- return MakePtrValue<char, BUFFER_VALUE_TYPE>(buffer, size);
-}
-
-Value MakeBufferValueNoCopy(const char* buffer, int size) {
- Value result;
- result.type = BUFFER_VALUE_TYPE;
- result.value = (void*)buffer;
- result.count = size;
- return result;
-}
-
-Value MakeMutableBufferValue(const char* buffer, int size) {
- return MakePtrValue<const char, MUTABLE_BUFFER_VALUE_TYPE>(buffer, size);
-}
-
-Value MakeMutableBufferValueNoCopy(char* buffer, int size) {
- Value result;
- result.type = MUTABLE_BUFFER_VALUE_TYPE;
- result.value = (void*)buffer;
- result.count = size;
- return result;
-}
-
-Value MakeIntArrayValue(const int* values, int count) {
- return MakePtrValue<int, INT_ARRAY_VALUE_TYPE>(values, count);
-}
-
-Value MakeFloatArrayValue(const float* values, int count) {
- return MakePtrValue<float, FLOAT_ARRAY_VALUE_TYPE>(values, count);
-}
-
-int SetIntValue(Value* value, int new_value) {
- return SetPODValue<int, INT_VALUE_TYPE>(value, new_value);
-}
-
-int SetFloatValue(Value* value, float new_value) {
- return SetPODValue<float, FLOAT_VALUE_TYPE>(value, new_value);
-}
-
-int SetStringValue(Value* value, const char* new_value) {
- return SetPtrValue<char, STRING_VALUE_TYPE>(value, new_value, strlen(new_value) + 1);
-}
-
-int SetMutableBufferValue(Value* value, const char* new_data, int size) {
- return SetPtrValue<char, MUTABLE_BUFFER_VALUE_TYPE>(value, new_data, size);
-}
-
-int SetIntArrayValue(Value* value, const int* new_values, int count) {
- return SetPtrValue<int, INT_ARRAY_VALUE_TYPE>(value, new_values, count);
-}
-
-int SetFloatArrayValue(Value* value, const float* new_values, int count) {
- return SetPtrValue<float, FLOAT_ARRAY_VALUE_TYPE>(value, new_values, count);
-}
-
-int GetValueCount(Value value) {
- return value.count;
-}
-
-void ReleaseValue(Value* value) {
- if (value && value->value) {
- free(value->value);
- value->value = NULL;
- value->type = NULL_VALUE_TYPE;
- }
-}
-
+++ /dev/null
-/*
- * 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.
- */
-
-#ifndef ANDROID_FILTERFW_CORE_VALUE_H
-#define ANDROID_FILTERFW_CORE_VALUE_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-// TODO: As this is no longer part of the proposed NDK, should we make this object-oriented (C++)
-// instead? We can also probably clean this up a bit.
-
-// TODO: Change this to an opaque handle?
-typedef struct {
- void* value;
- int type;
- int count;
-} Value;
-
-// TODO: Probably should make these const Value*?
-int GetIntValue(Value value);
-float GetFloatValue(Value value);
-const char* GetStringValue(Value value);
-const char* GetBufferValue(Value value);
-char* GetMutableBufferValue(Value value);
-int* GetIntArrayValue(Value value);
-float* GetFloatArrayValue(Value value);
-
-// TODO: Probably should make these const Value*?
-int ValueIsNull(Value value);
-int ValueIsInt(Value value);
-int ValueIsFloat(Value value);
-int ValueIsString(Value value);
-int ValueIsBuffer(Value value);
-int ValueIsMutableBuffer(Value value);
-int ValueIsIntArray(Value value);
-int ValueIsFloatArray(Value value);
-
-Value MakeNullValue();
-Value MakeIntValue(int value);
-Value MakeFloatValue(float value);
-Value MakeStringValue(const char* value);
-Value MakeBufferValue(const char* data, int size);
-Value MakeBufferValueNoCopy(const char* data, int size);
-Value MakeMutableBufferValue(const char* data, int size);
-Value MakeMutableBufferValueNoCopy(char* data, int size);
-Value MakeIntArrayValue(const int* values, int count);
-Value MakeFloatArrayValue(const float* values, int count);
-
-// Note: These only alloc if value is Null! Otherwise they overwrite, so data must fit!
-int SetIntValue(Value* value, int new_value);
-int SetFloatValue(Value* value, float new_value);
-int SetStringValue(Value* value, const char* new_value);
-int SetMutableBufferValue(Value* value, const char* new_data, int size);
-int SetIntArrayValue(Value* value, const int* new_values, int count);
-int SetFloatArrayValue(Value* value, const float* new_values, int count);
-
-int GetValueCount(Value value);
-
-void ReleaseValue(Value* value);
-
-#ifdef __cplusplus
-} // extern "C"
-#endif
-
-#endif // ANDROID_FILTERFW_FILTER_VALUE_H
+++ /dev/null
-/*
- * 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.
- */
-
-#include "base/logging.h"
-
-#include "core/gl_env.h"
-#include "core/vertex_frame.h"
-
-#include <GLES2/gl2ext.h>
-#include <EGL/egl.h>
-
-namespace android {
-namespace filterfw {
-
-// GL Extensions that are dynamically looked up at runtime
-static PFNGLMAPBUFFEROESPROC GLMapBufferOES = NULL;
-static PFNGLUNMAPBUFFEROESPROC GLUnmapBufferOES = NULL;
-
-VertexFrame::VertexFrame(int size)
- : vbo_(0),
- size_(size) {
-}
-
-VertexFrame::~VertexFrame() {
- glDeleteBuffers(1, &vbo_);
-}
-
-bool VertexFrame::CreateBuffer() {
- glGenBuffers(1, &vbo_);
- return !GLEnv::CheckGLError("Generating VBO");
-}
-
-bool VertexFrame::WriteData(const uint8_t* data, int size) {
- // Create buffer if not created already
- const bool first_upload = !HasVBO();
- if (first_upload && !CreateBuffer()) {
- ALOGE("VertexFrame: Could not create vertex buffer!");
- return false;
- }
-
- // Upload the data
- glBindBuffer(GL_ARRAY_BUFFER, vbo_);
- if (GLEnv::CheckGLError("VBO Bind Buffer"))
- return false;
-
- if (first_upload && size == size_)
- glBufferData(GL_ARRAY_BUFFER, size, data, GL_STATIC_DRAW);
- else if (!first_upload && size <= size_)
- glBufferSubData(GL_ARRAY_BUFFER, 0, size, data);
- else {
- ALOGE("VertexFrame: Attempting to upload more data (%d bytes) than fits "
- "inside the vertex frame (%d bytes)!", size, size_);
- return false;
- }
-
- // Make sure it worked
- if (GLEnv::CheckGLError("VBO Data Upload"))
- return false;
-
- // Subsequent uploads are now bound to the size given here
- size_ = size;
-
- return true;
-}
-
-int VertexFrame::Size() const {
- return size_;
-}
-
-} // namespace filterfw
-} // namespace android
+++ /dev/null
-/*
- * 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.
- */
-
-#ifndef ANDROID_FILTERFW_CORE_VERTEXFRAME_H
-#define ANDROID_FILTERFW_CORE_VERTEXFRAME_H
-
-#include <GLES2/gl2.h>
-
-namespace android {
-namespace filterfw {
-
-// A VertexFrame stores vertex attribute data in a VBO. Unlike other frames,
-// you often create instances of VertexFrame yourself, to pass vertex data to
-// a ShaderProgram. Note, that any kind of reading from VertexFrames is NOT
-// supported. Once data is uploaded to a VertexFrame, it cannot be read from
-// again.
-class VertexFrame {
- public:
- // Create a VertexFrame of the specified size (in bytes).
- explicit VertexFrame(int size);
-
- ~VertexFrame();
-
- // Upload the given data to the vertex buffer. The size must match the size
- // passed in the constructor for the first upload. Subsequent uploads must
- // be able to fit within the allocated space (i.e. size must not exceed the
- // frame's size).
- bool WriteData(const uint8_t* data, int size);
-
- // The size of the vertex buffer in bytes.
- int Size() const;
-
- // Return the id of the internal VBO. Returns 0 if no VBO has been
- // generated yet. The internal VBO is generated the first time data is
- // uploaded.
- GLuint GetVboId() const {
- return vbo_;
- }
-
- // Returns true if the frame contains an allocated VBO.
- bool HasBuffer() const {
- return vbo_ != 0;
- }
-
- private:
- // Create the VBO
- bool CreateBuffer();
-
- // Returns true if the VBO has been created.
- bool HasVBO() const {
- return vbo_ != 0;
- }
-
- // The internal VBO handle
- GLuint vbo_;
-
- // The size of this frame in bytes
- int size_;
-};
-
-} // namespace filterfw
-} // namespace android
-
-#endif // ANDROID_FILTERFW_CORE_VERTEXFRAME_H
+++ /dev/null
-# 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.
-#
-
-# Add include paths for native code.
-FFW_PATH := $(call my-dir)
-
-# Uncomment the requirements below, once we need them:
-
-# STLport
-include external/stlport/libstlport.mk
-
-# Neven FaceDetect SDK
-#LOCAL_C_INCLUDES += external/neven/FaceRecEm/common/src/b_FDSDK \
-# external/neven/FaceRecEm/common/src \
-# external/neven/Embedded/common/conf \
-# external/neven/Embedded/common/src \
-# external/neven/unix/src
-
-# Finally, add this directory
-LOCAL_C_INCLUDES += $(FFW_PATH)
-
+++ /dev/null
-# 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.
-#
-
-LOCAL_PATH := $(call my-dir)
-
-##
-# base
-##
-include $(CLEAR_VARS)
-
-LOCAL_MODULE_TAGS := optional
-
-LOCAL_MODULE := libfilterpack_base
-LOCAL_SRC_FILES := native/base/geometry.cpp \
- native/base/time_util.cpp
-
-LOCAL_CFLAGS := -DANDROID
-
-include external/stlport/libstlport.mk
-
-include $(BUILD_STATIC_LIBRARY)
-
-##
-# filterpack_imageproc
-##
-include $(CLEAR_VARS)
-
-LOCAL_MODULE_TAGS := optional
-
-LOCAL_MODULE := libfilterpack_imageproc
-
-LOCAL_SRC_FILES += native/imageproc/brightness.c \
- native/imageproc/contrast.c \
- native/imageproc/invert.c \
- native/imageproc/to_rgba.c
-
-LOCAL_SHARED_LIBRARIES := libutils libfilterfw
-
-LOCAL_PRELINK_MODULE := false
-
-include $(BUILD_SHARED_LIBRARY)
-
-
+++ /dev/null
-/*
- * 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.filterpacks.base;
-
-import android.filterfw.core.Filter;
-import android.filterfw.core.FilterContext;
-import android.filterfw.core.Frame;
-import android.filterfw.core.FrameFormat;
-import android.filterfw.core.GenerateFieldPort;
-import android.filterfw.core.GenerateFinalPort;
-import android.filterfw.core.KeyValueMap;
-import android.filterfw.core.NativeProgram;
-import android.filterfw.core.NativeFrame;
-import android.filterfw.core.Program;
-import android.os.Handler;
-import android.os.Looper;
-
-import java.lang.Runnable;
-
-/**
- * @hide
- */
-public class CallbackFilter extends Filter {
-
- @GenerateFieldPort(name = "listener", hasDefault = true)
- private FilterContext.OnFrameReceivedListener mListener;
-
- @GenerateFieldPort(name = "userData", hasDefault = true)
- private Object mUserData;
-
- @GenerateFinalPort(name = "callUiThread", hasDefault = true)
- private boolean mCallbacksOnUiThread = true;
-
- private Handler mUiThreadHandler;
-
- private class CallbackRunnable implements Runnable {
- private Filter mFilter;
- private Frame mFrame;
- private Object mUserData;
- private FilterContext.OnFrameReceivedListener mListener;
-
- public CallbackRunnable(FilterContext.OnFrameReceivedListener listener, Filter filter, Frame frame, Object userData) {
- mListener = listener;
- mFilter = filter;
- mFrame = frame;
- mUserData = userData;
- }
-
- public void run() {
- mListener.onFrameReceived(mFilter, mFrame, mUserData);
- mFrame.release();
- }
- }
-
- public CallbackFilter(String name) {
- super(name);
- }
-
- @Override
- public void setupPorts() {
- addInputPort("frame");
- }
-
- public void prepare(FilterContext context) {
- if (mCallbacksOnUiThread) {
- mUiThreadHandler = new Handler(Looper.getMainLooper());
- }
- }
-
- public void process(FilterContext context) {
- // Get frame and forward to listener
- final Frame input = pullInput("frame");
- if (mListener != null) {
- if (mCallbacksOnUiThread) {
- input.retain();
- CallbackRunnable uiRunnable = new CallbackRunnable(mListener, this, input, mUserData);
- if (!mUiThreadHandler.post(uiRunnable)) {
- throw new RuntimeException("Unable to send callback to UI thread!");
- }
- } else {
- mListener.onFrameReceived(this, input, mUserData);
- }
- } else {
- throw new RuntimeException("CallbackFilter received frame, but no listener set!");
- }
- }
-
-}
+++ /dev/null
-/*
- * 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.filterpacks.base;
-
-import android.filterfw.core.Filter;
-import android.filterfw.core.FilterContext;
-import android.filterfw.core.Frame;
-import android.filterfw.core.FrameFormat;
-import android.filterfw.core.GenerateFinalPort;
-import android.filterfw.core.KeyValueMap;
-
-/**
- * @hide
- */
-public class FrameBranch extends Filter {
-
- @GenerateFinalPort(name = "outputs", hasDefault = true)
- private int mNumberOfOutputs = 2;
-
- public FrameBranch(String name) {
- super(name);
- }
-
- @Override
- public void setupPorts() {
- addInputPort("in");
- for (int i = 0; i < mNumberOfOutputs; ++i) {
- addOutputBasedOnInput("out" + i, "in");
- }
- }
-
- @Override
- public FrameFormat getOutputFormat(String portName, FrameFormat inputFormat) {
- return inputFormat;
- }
-
- public void process(FilterContext context) {
- // Get input frame
- Frame input = pullInput("in");
-
- // Push output
- for (int i = 0; i < mNumberOfOutputs; ++i) {
- pushOutput("out" + i, input);
- }
- }
-
-}
+++ /dev/null
-/*
- * 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.filterpacks.base;
-
-import android.filterfw.core.Filter;
-import android.filterfw.core.FilterContext;
-import android.filterfw.core.Frame;
-import android.filterfw.core.FrameFormat;
-import android.filterfw.core.GenerateFieldPort;
-import android.filterfw.core.GenerateFinalPort;
-
-import android.util.Log;
-
-/**
- * @hide
- */
-public class FrameFetch extends Filter {
-
- @GenerateFinalPort(name = "format", hasDefault = true)
- private FrameFormat mFormat;
-
- @GenerateFieldPort(name = "key")
- private String mKey;
-
- @GenerateFieldPort(name = "repeatFrame", hasDefault = true)
- private boolean mRepeatFrame = false;
-
- public FrameFetch(String name) {
- super(name);
- }
-
- @Override
- public void setupPorts() {
- addOutputPort("frame", mFormat == null ? FrameFormat.unspecified() : mFormat);
- }
-
- public void process(FilterContext context) {
- Frame output = context.fetchFrame(mKey);
- if (output != null) {
- pushOutput("frame", output);
- if (!mRepeatFrame) {
- closeOutputPort("frame");
- }
- } else {
- delayNextProcess(250);
- }
- }
-
-}
+++ /dev/null
-/*
- * 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.filterpacks.base;
-
-import android.filterfw.core.Filter;
-import android.filterfw.core.FilterContext;
-import android.filterfw.core.Frame;
-import android.filterfw.core.FrameFormat;
-import android.filterfw.core.GenerateFieldPort;
-import android.filterfw.core.GenerateFinalPort;
-
-/**
- * @hide
- */
-public class FrameSource extends Filter {
-
- @GenerateFinalPort(name = "format")
- private FrameFormat mFormat;
-
- @GenerateFieldPort(name = "frame", hasDefault = true)
- private Frame mFrame = null;
-
- @GenerateFieldPort(name = "repeatFrame", hasDefault = true)
- private boolean mRepeatFrame = false;
-
- public FrameSource(String name) {
- super(name);
- }
-
- @Override
- public void setupPorts() {
- addOutputPort("frame", mFormat);
- }
-
- @Override
- public void process(FilterContext context) {
- if (mFrame != null) {
- // Push output
- pushOutput("frame", mFrame);
- }
-
- if (!mRepeatFrame) {
- // Close output port as we are done here
- closeOutputPort("frame");
- }
- }
-
-}
+++ /dev/null
-/*
- * 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.filterpacks.base;
-
-import android.filterfw.core.Filter;
-import android.filterfw.core.FilterContext;
-import android.filterfw.core.Frame;
-import android.filterfw.core.FrameFormat;
-import android.filterfw.core.GenerateFieldPort;
-
-/**
- * @hide
- */
-public class FrameStore extends Filter {
-
- @GenerateFieldPort(name = "key")
- private String mKey;
-
- public FrameStore(String name) {
- super(name);
- }
-
- @Override
- public void setupPorts() {
- addInputPort("frame");
- }
-
- public void process(FilterContext context) {
- // Get input frame
- Frame input = pullInput("frame");
-
- // Store frame
- context.storeFrame(mKey, input);
- }
-
-}
+++ /dev/null
-/*
- * 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.filterpacks.base;
-
-import android.filterfw.core.Filter;
-import android.filterfw.core.FilterContext;
-import android.filterfw.core.Frame;
-import android.filterfw.core.FrameFormat;
-import android.filterfw.core.GenerateFieldPort;
-import android.filterfw.core.GLFrame;
-import android.filterfw.core.MutableFrameFormat;
-import android.filterfw.format.ImageFormat;
-
-import java.util.Set;
-
-/**
- * @hide
- */
-public class GLTextureSource extends Filter {
-
- @GenerateFieldPort(name = "texId")
- private int mTexId;
-
- @GenerateFieldPort(name = "width")
- private int mWidth;
-
- @GenerateFieldPort(name = "height")
- private int mHeight;
-
- @GenerateFieldPort(name = "repeatFrame", hasDefault = true)
- private boolean mRepeatFrame = false;
-
- /* This timestamp will be used for all output frames from this source. They
- * represent nanoseconds, and should be positive and monotonically
- * increasing. Set to Frame.TIMESTAMP_UNKNOWN if timestamps are not
- * meaningful for these textures.
- */
- @GenerateFieldPort(name = "timestamp", hasDefault = true)
- private long mTimestamp = Frame.TIMESTAMP_UNKNOWN;
-
- private Frame mFrame;
-
- public GLTextureSource(String name) {
- super(name);
- }
-
- @Override
- public void setupPorts() {
- addOutputPort("frame", ImageFormat.create(ImageFormat.COLORSPACE_RGBA,
- FrameFormat.TARGET_GPU));
- }
-
- @Override
- public void fieldPortValueUpdated(String name, FilterContext context) {
- // Release frame, so that it is recreated during the next process call
- if (mFrame != null) {
- mFrame.release();
- mFrame = null;
- }
- }
-
- @Override
- public void process(FilterContext context) {
- // Generate frame if not generated already
- if (mFrame == null) {
- FrameFormat outputFormat = ImageFormat.create(mWidth, mHeight,
- ImageFormat.COLORSPACE_RGBA,
- FrameFormat.TARGET_GPU);
- mFrame = context.getFrameManager().newBoundFrame(outputFormat,
- GLFrame.EXISTING_TEXTURE_BINDING,
- mTexId);
- mFrame.setTimestamp(mTimestamp);
- }
-
- // Push output
- pushOutput("frame", mFrame);
-
- if (!mRepeatFrame) {
- // Close output port as we are done here
- closeOutputPort("frame");
- }
- }
-
- @Override
- public void tearDown(FilterContext context) {
- if (mFrame != null) {
- mFrame.release();
- }
- }
-
-}
+++ /dev/null
-/*
- * 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.filterpacks.base;
-
-import android.filterfw.core.Filter;
-import android.filterfw.core.FilterContext;
-import android.filterfw.core.Frame;
-import android.filterfw.core.FrameFormat;
-import android.filterfw.core.GenerateFieldPort;
-import android.filterfw.core.GLFrame;
-import android.filterfw.core.MutableFrameFormat;
-import android.filterfw.format.ImageFormat;
-
-import java.util.Set;
-
-/**
- * @hide
- */
-public class GLTextureTarget extends Filter {
-
- @GenerateFieldPort(name = "texId")
- private int mTexId;
-
- public GLTextureTarget(String name) {
- super(name);
- }
-
- @Override
- public void setupPorts() {
- addMaskedInputPort("frame", ImageFormat.create(ImageFormat.COLORSPACE_RGBA));
- }
-
- @Override
- public void process(FilterContext context) {
- // Get input frame
- Frame input = pullInput("frame");
-
- FrameFormat format = ImageFormat.create(input.getFormat().getWidth(),
- input.getFormat().getHeight(),
- ImageFormat.COLORSPACE_RGBA,
- FrameFormat.TARGET_GPU);
-
- Frame frame = context.getFrameManager().newBoundFrame(format, GLFrame.EXISTING_TEXTURE_BINDING, mTexId);
-
- // Copy to our texture frame
- frame.setDataFromFrame(input);
- frame.release();
- }
-}
+++ /dev/null
-/*
- * 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.filterpacks.base;
-
-import android.filterfw.core.Filter;
-import android.filterfw.core.FilterContext;
-import android.filterfw.core.Frame;
-import android.filterfw.core.FrameFormat;
-import android.filterfw.core.GenerateFieldPort;
-import android.filterfw.core.GenerateFinalPort;
-import android.filterfw.core.KeyValueMap;
-import android.filterfw.core.MutableFrameFormat;
-import android.filterfw.format.PrimitiveFormat;
-
-import java.io.ByteArrayOutputStream;
-import java.io.InputStream;
-import java.io.IOException;
-import java.nio.ByteBuffer;
-
-/**
- * @hide
- */
-public class InputStreamSource extends Filter {
-
- @GenerateFinalPort(name = "target")
- private String mTarget;
-
- @GenerateFieldPort(name = "stream")
- private InputStream mInputStream;
-
- @GenerateFinalPort(name = "format", hasDefault = true)
- private MutableFrameFormat mOutputFormat = null;
-
- public InputStreamSource(String name) {
- super(name);
- }
-
- @Override
- public void setupPorts() {
- int target = FrameFormat.readTargetString(mTarget);
- if (mOutputFormat == null) {
- mOutputFormat = PrimitiveFormat.createByteFormat(target);
- }
- addOutputPort("data", mOutputFormat);
- }
-
- @Override
- public void process(FilterContext context) {
- int fileSize = 0;
- ByteBuffer byteBuffer = null;
-
- // Read the file
- try {
- ByteArrayOutputStream byteStream = new ByteArrayOutputStream();
- byte[] buffer = new byte[1024];
- int bytesRead;
- while ((bytesRead = mInputStream.read(buffer)) > 0) {
- byteStream.write(buffer, 0, bytesRead);
- fileSize += bytesRead;
- }
- byteBuffer = ByteBuffer.wrap(byteStream.toByteArray());
- } catch (IOException exception) {
- throw new RuntimeException(
- "InputStreamSource: Could not read stream: " + exception.getMessage() + "!");
- }
-
- // Put it into a frame
- mOutputFormat.setDimensions(fileSize);
- Frame output = context.getFrameManager().newFrame(mOutputFormat);
- output.setData(byteBuffer);
-
- // Push output
- pushOutput("data", output);
-
- // Release pushed frame
- output.release();
-
- // Close output port as we are done here
- closeOutputPort("data");
- }
-}
+++ /dev/null
-/*
- * 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.filterpacks.base;
-
-import android.filterfw.core.Filter;
-import android.filterfw.core.FilterContext;
-import android.filterfw.core.Frame;
-import android.filterfw.core.FrameFormat;
-
-/**
- * @hide
- */
-public class NullFilter extends Filter {
-
- public NullFilter(String name) {
- super(name);
- }
-
- @Override
- public void setupPorts() {
- addInputPort("frame");
- }
-
- @Override
- public void process(FilterContext context) {
- pullInput("frame");
- }
-
-}
+++ /dev/null
-/*
- * 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.filterpacks.base;
-
-import java.util.Set;
-
-import android.filterfw.core.Filter;
-import android.filterfw.core.FilterContext;
-import android.filterfw.core.Frame;
-import android.filterfw.core.FrameFormat;
-import android.filterfw.core.GenerateFieldPort;
-import android.filterfw.core.GenerateFinalPort;
-import android.filterfw.core.MutableFrameFormat;
-import android.filterfw.format.ObjectFormat;
-
-/**
- * @hide
- */
-public class ObjectSource extends Filter {
-
- @GenerateFieldPort(name = "object")
- private Object mObject;
-
- @GenerateFinalPort(name = "format", hasDefault = true)
- private FrameFormat mOutputFormat = FrameFormat.unspecified();
-
- @GenerateFieldPort(name = "repeatFrame", hasDefault = true)
- boolean mRepeatFrame = false;
-
- private Frame mFrame;
-
- public ObjectSource(String name) {
- super(name);
- }
-
- @Override
- public void setupPorts() {
- addOutputPort("frame", mOutputFormat);
- }
-
- @Override
- public void process(FilterContext context) {
- // If no frame has been created, create one now.
- if (mFrame == null) {
- if (mObject == null) {
- throw new NullPointerException("ObjectSource producing frame with no object set!");
- }
- FrameFormat outputFormat = ObjectFormat.fromObject(mObject, FrameFormat.TARGET_SIMPLE);
- mFrame = context.getFrameManager().newFrame(outputFormat);
- mFrame.setObjectValue(mObject);
- mFrame.setTimestamp(Frame.TIMESTAMP_UNKNOWN);
- }
-
- // Push output
- pushOutput("frame", mFrame);
-
- // Wait for free output
- if (!mRepeatFrame) {
- closeOutputPort("frame");
- }
- }
-
- @Override
- public void tearDown(FilterContext context) {
- mFrame.release();
- }
-
- @Override
- public void fieldPortValueUpdated(String name, FilterContext context) {
- // Release our internal frame, so that it is regenerated on the next call to process().
- if (name.equals("object")) {
- if (mFrame != null) {
- mFrame.release();
- mFrame = null;
- }
- }
- }
-}
+++ /dev/null
-/*
- * 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.filterpacks.base;
-
-import android.filterfw.core.Filter;
-import android.filterfw.core.FilterContext;
-import android.filterfw.core.Frame;
-import android.filterfw.core.FrameFormat;
-import android.filterfw.core.GenerateFieldPort;
-
-import java.io.OutputStream;
-import java.io.IOException;
-import java.nio.ByteBuffer;
-
-/**
- * @hide
- */
-public class OutputStreamTarget extends Filter {
-
- @GenerateFieldPort(name = "stream")
- private OutputStream mOutputStream;
-
- public OutputStreamTarget(String name) {
- super(name);
- }
-
- @Override
- public void setupPorts() {
- addInputPort("data");
- }
-
- @Override
- public void process(FilterContext context) {
- Frame input = pullInput("data");
- ByteBuffer data;
-
- if (input.getFormat().getObjectClass() == String.class) {
- String stringVal = (String)input.getObjectValue();
- data = ByteBuffer.wrap(stringVal.getBytes());
- } else {
- data = input.getData();
- }
- try {
- mOutputStream.write(data.array(), 0, data.limit());
- mOutputStream.flush();
- } catch (IOException exception) {
- throw new RuntimeException(
- "OutputStreamTarget: Could not write to stream: " + exception.getMessage() + "!");
- }
- }
-}
+++ /dev/null
-/*
- * 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.filterpacks.base;
-
-import android.filterfw.core.Filter;
-import android.filterfw.core.FilterContext;
-import android.filterfw.core.Frame;
-import android.filterfw.core.FrameFormat;
-import android.filterfw.core.GenerateFieldPort;
-import android.filterfw.core.GenerateFinalPort;
-import android.filterfw.core.KeyValueMap;
-import android.filterfw.core.MutableFrameFormat;
-
-/**
- * @hide
- */
-public class RetargetFilter extends Filter {
-
- @GenerateFinalPort(name = "target", hasDefault = false)
- private String mTargetString;
-
- private MutableFrameFormat mOutputFormat;
- private int mTarget = -1;
-
- public RetargetFilter(String name) {
- super(name);
- }
-
- @Override
- public void setupPorts() {
- // Setup target
- mTarget = FrameFormat.readTargetString(mTargetString);
-
- // Add ports
- addInputPort("frame");
- addOutputBasedOnInput("frame", "frame");
- }
-
- @Override
- public FrameFormat getOutputFormat(String portName, FrameFormat inputFormat) {
- MutableFrameFormat retargeted = inputFormat.mutableCopy();
- retargeted.setTarget(mTarget);
- return retargeted;
- }
-
- @Override
- public void process(FilterContext context) {
- // Get input frame
- Frame input = pullInput("frame");
-
- // Create output frame
- Frame output = context.getFrameManager().duplicateFrameToTarget(input, mTarget);
-
- // Push output
- pushOutput("frame", output);
-
- // Release pushed frame
- output.release();
- }
-
-}
+++ /dev/null
-/*
- * 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.filterpacks.imageproc;
-
-import android.filterfw.core.Filter;
-import android.filterfw.core.FilterContext;
-import android.filterfw.core.Frame;
-import android.filterfw.core.FrameFormat;
-import android.filterfw.core.KeyValueMap;
-import android.filterfw.core.NativeProgram;
-import android.filterfw.core.NativeFrame;
-import android.filterfw.core.Program;
-import android.filterfw.core.ShaderProgram;
-import android.filterfw.format.ImageFormat;
-
-import java.util.Set;
-
-/**
- * @hide
- */
-public class AlphaBlendFilter extends ImageCombineFilter {
-
- private final String mAlphaBlendShader =
- "precision mediump float;\n" +
- "uniform sampler2D tex_sampler_0;\n" +
- "uniform sampler2D tex_sampler_1;\n" +
- "uniform sampler2D tex_sampler_2;\n" +
- "uniform float weight;\n" +
- "varying vec2 v_texcoord;\n" +
- "void main() {\n" +
- " vec4 colorL = texture2D(tex_sampler_0, v_texcoord);\n" +
- " vec4 colorR = texture2D(tex_sampler_1, v_texcoord);\n" +
- " float blend = texture2D(tex_sampler_2, v_texcoord).r * weight;\n" +
- " gl_FragColor = colorL * (1.0 - blend) + colorR * blend;\n" +
- "}\n";
-
- public AlphaBlendFilter(String name) {
- super(name, new String[] { "source", "overlay", "mask" }, "blended", "weight");
- }
-
- @Override
- protected Program getNativeProgram(FilterContext context) {
- throw new RuntimeException("TODO: Write native implementation for AlphaBlend!");
- }
-
- @Override
- protected Program getShaderProgram(FilterContext context) {
- return new ShaderProgram(context, mAlphaBlendShader);
- }
-
-}
+++ /dev/null
-/*
- * 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.filterpacks.imageproc;
-
-import android.filterfw.core.Filter;
-import android.filterfw.core.FilterContext;
-import android.filterfw.core.Frame;
-import android.filterfw.core.FrameFormat;
-import android.filterfw.core.GenerateFieldPort;
-import android.filterfw.core.NativeProgram;
-import android.filterfw.core.Program;
-import android.filterfw.core.ShaderProgram;
-import android.filterfw.format.ImageFormat;
-
-import android.util.Log;
-
-public class AutoFixFilter extends Filter {
-
- @GenerateFieldPort(name = "tile_size", hasDefault = true)
- private int mTileSize = 640;
-
- @GenerateFieldPort(name = "scale")
- private float mScale;
-
- private static final int normal_cdf[] = {
- 9, 33, 50, 64, 75, 84, 92, 99, 106, 112, 117, 122, 126, 130, 134, 138, 142,
- 145, 148, 150, 154, 157, 159, 162, 164, 166, 169, 170, 173, 175, 177, 179,
- 180, 182, 184, 186, 188, 189, 190, 192, 194, 195, 197, 198, 199, 200, 202,
- 203, 205, 206, 207, 208, 209, 210, 212, 213, 214, 215, 216, 217, 218, 219,
- 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 229, 230, 231, 232, 233,
- 234, 235, 236, 236, 237, 238, 239, 239, 240, 240, 242, 242, 243, 244, 245,
- 245, 246, 247, 247, 248, 249, 249, 250, 250, 251, 252, 253, 253, 254, 255,
- 255, 256, 256, 257, 258, 258, 259, 259, 259, 260, 261, 262, 262, 263, 263,
- 264, 264, 265, 265, 266, 267, 267, 268, 268, 269, 269, 269, 270, 270, 271,
- 272, 272, 273, 273, 274, 274, 275, 275, 276, 276, 277, 277, 277, 278, 278,
- 279, 279, 279, 280, 280, 281, 282, 282, 282, 283, 283, 284, 284, 285, 285,
- 285, 286, 286, 287, 287, 288, 288, 288, 289, 289, 289, 290, 290, 290, 291,
- 292, 292, 292, 293, 293, 294, 294, 294, 295, 295, 296, 296, 296, 297, 297,
- 297, 298, 298, 298, 299, 299, 299, 299, 300, 300, 301, 301, 302, 302, 302,
- 303, 303, 304, 304, 304, 305, 305, 305, 306, 306, 306, 307, 307, 307, 308,
- 308, 308, 309, 309, 309, 309, 310, 310, 310, 310, 311, 312, 312, 312, 313,
- 313, 313, 314, 314, 314, 315, 315, 315, 315, 316, 316, 316, 317, 317, 317,
- 318, 318, 318, 319, 319, 319, 319, 319, 320, 320, 320, 321, 321, 322, 322,
- 322, 323, 323, 323, 323, 324, 324, 324, 325, 325, 325, 325, 326, 326, 326,
- 327, 327, 327, 327, 328, 328, 328, 329, 329, 329, 329, 329, 330, 330, 330,
- 330, 331, 331, 332, 332, 332, 333, 333, 333, 333, 334, 334, 334, 334, 335,
- 335, 335, 336, 336, 336, 336, 337, 337, 337, 337, 338, 338, 338, 339, 339,
- 339, 339, 339, 339, 340, 340, 340, 340, 341, 341, 342, 342, 342, 342, 343,
- 343, 343, 344, 344, 344, 344, 345, 345, 345, 345, 346, 346, 346, 346, 347,
- 347, 347, 347, 348, 348, 348, 348, 349, 349, 349, 349, 349, 349, 350, 350,
- 350, 350, 351, 351, 352, 352, 352, 352, 353, 353, 353, 353, 354, 354, 354,
- 354, 355, 355, 355, 355, 356, 356, 356, 356, 357, 357, 357, 357, 358, 358,
- 358, 358, 359, 359, 359, 359, 359, 359, 359, 360, 360, 360, 360, 361, 361,
- 362, 362, 362, 362, 363, 363, 363, 363, 364, 364, 364, 364, 365, 365, 365,
- 365, 366, 366, 366, 366, 366, 367, 367, 367, 367, 368, 368, 368, 368, 369,
- 369, 369, 369, 369, 369, 370, 370, 370, 370, 370, 371, 371, 372, 372, 372,
- 372, 373, 373, 373, 373, 374, 374, 374, 374, 374, 375, 375, 375, 375, 376,
- 376, 376, 376, 377, 377, 377, 377, 378, 378, 378, 378, 378, 379, 379, 379,
- 379, 379, 379, 380, 380, 380, 380, 381, 381, 381, 382, 382, 382, 382, 383,
- 383, 383, 383, 384, 384, 384, 384, 385, 385, 385, 385, 385, 386, 386, 386,
- 386, 387, 387, 387, 387, 388, 388, 388, 388, 388, 389, 389, 389, 389, 389,
- 389, 390, 390, 390, 390, 391, 391, 392, 392, 392, 392, 392, 393, 393, 393,
- 393, 394, 394, 394, 394, 395, 395, 395, 395, 396, 396, 396, 396, 396, 397,
- 397, 397, 397, 398, 398, 398, 398, 399, 399, 399, 399, 399, 399, 400, 400,
- 400, 400, 400, 401, 401, 402, 402, 402, 402, 403, 403, 403, 403, 404, 404,
- 404, 404, 405, 405, 405, 405, 406, 406, 406, 406, 406, 407, 407, 407, 407,
- 408, 408, 408, 408, 409, 409, 409, 409, 409, 409, 410, 410, 410, 410, 411,
- 411, 412, 412, 412, 412, 413, 413, 413, 413, 414, 414, 414, 414, 415, 415,
- 415, 415, 416, 416, 416, 416, 417, 417, 417, 417, 418, 418, 418, 418, 419,
- 419, 419, 419, 419, 419, 420, 420, 420, 420, 421, 421, 422, 422, 422, 422,
- 423, 423, 423, 423, 424, 424, 424, 425, 425, 425, 425, 426, 426, 426, 426,
- 427, 427, 427, 427, 428, 428, 428, 429, 429, 429, 429, 429, 429, 430, 430,
- 430, 430, 431, 431, 432, 432, 432, 433, 433, 433, 433, 434, 434, 434, 435,
- 435, 435, 435, 436, 436, 436, 436, 437, 437, 437, 438, 438, 438, 438, 439,
- 439, 439, 439, 439, 440, 440, 440, 441, 441, 442, 442, 442, 443, 443, 443,
- 443, 444, 444, 444, 445, 445, 445, 446, 446, 446, 446, 447, 447, 447, 448,
- 448, 448, 449, 449, 449, 449, 449, 450, 450, 450, 451, 451, 452, 452, 452,
- 453, 453, 453, 454, 454, 454, 455, 455, 455, 456, 456, 456, 457, 457, 457,
- 458, 458, 458, 459, 459, 459, 459, 460, 460, 460, 461, 461, 462, 462, 462,
- 463, 463, 463, 464, 464, 465, 465, 465, 466, 466, 466, 467, 467, 467, 468,
- 468, 469, 469, 469, 469, 470, 470, 470, 471, 472, 472, 472, 473, 473, 474,
- 474, 474, 475, 475, 476, 476, 476, 477, 477, 478, 478, 478, 479, 479, 479,
- 480, 480, 480, 481, 482, 482, 483, 483, 484, 484, 484, 485, 485, 486, 486,
- 487, 487, 488, 488, 488, 489, 489, 489, 490, 490, 491, 492, 492, 493, 493,
- 494, 494, 495, 495, 496, 496, 497, 497, 498, 498, 499, 499, 499, 500, 501,
- 502, 502, 503, 503, 504, 504, 505, 505, 506, 507, 507, 508, 508, 509, 509,
- 510, 510, 511, 512, 513, 513, 514, 515, 515, 516, 517, 517, 518, 519, 519,
- 519, 520, 521, 522, 523, 524, 524, 525, 526, 526, 527, 528, 529, 529, 530,
- 531, 532, 533, 534, 535, 535, 536, 537, 538, 539, 539, 540, 542, 543, 544,
- 545, 546, 547, 548, 549, 549, 550, 552, 553, 554, 555, 556, 558, 559, 559,
- 561, 562, 564, 565, 566, 568, 569, 570, 572, 574, 575, 577, 578, 579, 582,
- 583, 585, 587, 589, 590, 593, 595, 597, 599, 602, 604, 607, 609, 612, 615,
- 618, 620, 624, 628, 631, 635, 639, 644, 649, 654, 659, 666, 673, 680, 690,
- 700, 714 };
-
- private final String mAutoFixShader =
- "precision mediump float;\n" +
- "uniform sampler2D tex_sampler_0;\n" +
- "uniform sampler2D tex_sampler_1;\n" +
- "uniform sampler2D tex_sampler_2;\n" +
- "uniform float scale;\n" +
- "uniform float shift_scale;\n" +
- "uniform float hist_offset;\n" +
- "uniform float hist_scale;\n" +
- "uniform float density_offset;\n" +
- "uniform float density_scale;\n" +
- "varying vec2 v_texcoord;\n" +
- "void main() {\n" +
- " const vec3 weights = vec3(0.33333, 0.33333, 0.33333);\n" +
- " vec4 color = texture2D(tex_sampler_0, v_texcoord);\n" +
- " float energy = dot(color.rgb, weights);\n" +
- " float mask_value = energy - 0.5;\n" +
- " float alpha;\n" +
- " if (mask_value > 0.0) {\n" +
- " alpha = (pow(2.0 * mask_value, 1.5) - 1.0) * scale + 1.0;\n" +
- " } else { \n" +
- " alpha = (pow(2.0 * mask_value, 2.0) - 1.0) * scale + 1.0;\n" +
- " }\n" +
- " float index = energy * hist_scale + hist_offset;\n" +
- " vec4 temp = texture2D(tex_sampler_1, vec2(index, 0.5));\n" +
- " float value = temp.g + temp.r * shift_scale;\n" +
- " index = value * density_scale + density_offset;\n" +
- " temp = texture2D(tex_sampler_2, vec2(index, 0.5));\n" +
- " value = temp.g + temp.r * shift_scale;\n" +
- " float dst_energy = energy * alpha + value * (1.0 - alpha);\n" +
- " float max_energy = energy / max(color.r, max(color.g, color.b));\n" +
- " if (dst_energy > max_energy) {\n" +
- " dst_energy = max_energy;\n" +
- " }\n" +
- " if (energy == 0.0) {\n" +
- " gl_FragColor = color;\n" +
- " } else {\n" +
- " gl_FragColor = vec4(color.rgb * dst_energy / energy, color.a);\n" +
- " }\n" +
- "}\n";
-
- private Program mShaderProgram;
- private Program mNativeProgram;
-
- private int mWidth = 0;
- private int mHeight = 0;
- private int mTarget = FrameFormat.TARGET_UNSPECIFIED;
-
- private Frame mHistFrame;
- private Frame mDensityFrame;
-
- public AutoFixFilter(String name) {
- super(name);
- }
-
- @Override
- public void setupPorts() {
- addMaskedInputPort("image", ImageFormat.create(ImageFormat.COLORSPACE_RGBA));
- addOutputBasedOnInput("image", "image");
- }
-
- @Override
- public FrameFormat getOutputFormat(String portName, FrameFormat inputFormat) {
- return inputFormat;
- }
-
- public void initProgram(FilterContext context, int target) {
- switch (target) {
- case FrameFormat.TARGET_GPU:
- ShaderProgram shaderProgram = new ShaderProgram(context, mAutoFixShader);
- shaderProgram.setMaximumTileSize(mTileSize);
- mShaderProgram = shaderProgram;
- break;
-
- default:
- throw new RuntimeException("Filter Sharpen does not support frames of " +
- "target " + target + "!");
- }
- mTarget = target;
- }
-
- private void initParameters() {
- mShaderProgram.setHostValue("shift_scale", 1.0f / 256f);
- mShaderProgram.setHostValue("hist_offset", 0.5f / 766f);
- mShaderProgram.setHostValue("hist_scale", 765f / 766f);
- mShaderProgram.setHostValue("density_offset", 0.5f / 1024f);
- mShaderProgram.setHostValue("density_scale", 1023f / 1024f);
- mShaderProgram.setHostValue("scale", mScale);
- }
-
- @Override
- protected void prepare(FilterContext context) {
- int densityDim = 1024;
- int histDim = 255 * 3 + 1;
- long precision = (256l * 256l - 1l);
-
- int[] densityTable = new int[densityDim];
- for (int i = 0; i < densityDim; ++i) {
- long temp = normal_cdf[i] * precision / histDim;
- densityTable[i] = (int) temp;
- }
-
- FrameFormat densityFormat = ImageFormat.create(densityDim, 1,
- ImageFormat.COLORSPACE_RGBA,
- FrameFormat.TARGET_GPU);
- mDensityFrame = context.getFrameManager().newFrame(densityFormat);
- mDensityFrame.setInts(densityTable);
- }
-
- @Override
- public void tearDown(FilterContext context) {
- if (mDensityFrame != null) {
- mDensityFrame.release();
- mDensityFrame = null;
- }
-
- if (mHistFrame != null) {
- mHistFrame.release();
- mHistFrame = null;
- }
- }
-
- @Override
- public void fieldPortValueUpdated(String name, FilterContext context) {
- if (mShaderProgram != null) {
- mShaderProgram.setHostValue("scale", mScale);
- }
- }
-
- @Override
- public void process(FilterContext context) {
- // Get input frame
- Frame input = pullInput("image");
- FrameFormat inputFormat = input.getFormat();
-
- // Create program if not created already
- if (mShaderProgram == null || inputFormat.getTarget() != mTarget) {
- initProgram(context, inputFormat.getTarget());
- initParameters();
- }
-
- // Check if the frame size has changed
- if (inputFormat.getWidth() != mWidth || inputFormat.getHeight() != mHeight) {
- mWidth = inputFormat.getWidth();
- mHeight = inputFormat.getHeight();
- createHistogramFrame(context, mWidth, mHeight, input.getInts());
- }
-
- // Create output frame
- Frame output = context.getFrameManager().newFrame(inputFormat);
-
- // Process
- Frame[] inputs = {input, mHistFrame, mDensityFrame};
- mShaderProgram.process(inputs, output);
-
- // Push output
- pushOutput("image", output);
-
- // Release pushed frame
- output.release();
- }
-
- private void createHistogramFrame(FilterContext context, int width, int height, int[] data) {
- int histDims = 255 * 3 + 1;
- int[] histArray = new int[histDims];
-
- float border_thickness_ratio = 0.05f;
- int y_border_thickness = (int) (height * border_thickness_ratio);
- int x_border_thickness = (int) (width * border_thickness_ratio);
- int pixels = (width - 2 * x_border_thickness) * (height - 2 * y_border_thickness);
-
- float count = 0f;
- for (int y = y_border_thickness; y < height - y_border_thickness; ++y) {
- for (int x = x_border_thickness; x < width - x_border_thickness; ++x) {
- int index = y * width + x;
- int energy = (data[index] & 0xFF) + ((data[index] >> 8) & 0xFF) +
- ((data[index] >> 16) & 0xFF);
- histArray[energy] ++;
- }
- }
-
- for (int i = 1; i < histDims; i++) {
- histArray[i] += histArray[i-1];
- }
-
- for (int i = 0; i < histDims; i++) {
- long temp = (256 * 256 - 1l) * histArray[i] / pixels;
- histArray[i] = (int) temp;
- }
-
- FrameFormat shaderHistFormat = ImageFormat.create(histDims, 1,
- ImageFormat.COLORSPACE_RGBA,
- FrameFormat.TARGET_GPU);
- if (mHistFrame != null)
- mHistFrame.release();
-
- mHistFrame = context.getFrameManager().newFrame(shaderHistFormat);
- mHistFrame.setInts(histArray);
- }
-}
+++ /dev/null
-/*
- * 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.filterpacks.imageproc;
-
-import android.filterfw.core.Filter;
-import android.filterfw.core.FilterContext;
-import android.filterfw.core.Frame;
-import android.filterfw.core.FrameFormat;
-import android.filterfw.core.GenerateFieldPort;
-import android.filterfw.core.KeyValueMap;
-import android.filterfw.core.NativeProgram;
-import android.filterfw.core.NativeFrame;
-import android.filterfw.core.Program;
-import android.filterfw.core.ShaderProgram;
-import android.filterfw.format.ImageFormat;
-import android.filterpacks.imageproc.ImageCombineFilter;
-import android.graphics.Bitmap;
-
-import android.util.Log;
-
-/**
- * @hide
- */
-public class BitmapOverlayFilter extends Filter {
-
- @GenerateFieldPort(name = "bitmap")
- private Bitmap mBitmap;
-
- @GenerateFieldPort(name = "tile_size", hasDefault = true)
- private int mTileSize = 640;
-
- private Program mProgram;
- private Frame mFrame;
-
- private int mWidth = 0;
- private int mHeight = 0;
- private int mTarget = FrameFormat.TARGET_UNSPECIFIED;
-
- private final String mOverlayShader =
- "precision mediump float;\n" +
- "uniform sampler2D tex_sampler_0;\n" +
- "uniform sampler2D tex_sampler_1;\n" +
- "varying vec2 v_texcoord;\n" +
- "void main() {\n" +
- " vec4 original = texture2D(tex_sampler_0, v_texcoord);\n" +
- " vec4 mask = texture2D(tex_sampler_1, v_texcoord);\n" +
- " gl_FragColor = vec4(original.rgb * (1.0 - mask.a) + mask.rgb, 1.0);\n" +
- "}\n";
-
- public BitmapOverlayFilter(String name) {
- super(name);
- }
-
- @Override
- public void setupPorts() {
- addMaskedInputPort("image", ImageFormat.create(ImageFormat.COLORSPACE_RGBA));
- addOutputBasedOnInput("image", "image");
- }
-
- @Override
- public FrameFormat getOutputFormat(String portName, FrameFormat inputFormat) {
- return inputFormat;
- }
-
- public void initProgram(FilterContext context, int target) {
- switch (target) {
- case FrameFormat.TARGET_GPU:
- ShaderProgram shaderProgram = new ShaderProgram(context, mOverlayShader);
- shaderProgram.setMaximumTileSize(mTileSize);
- mProgram = shaderProgram;
- break;
-
- default:
- throw new RuntimeException("Filter FisheyeFilter does not support frames of " +
- "target " + target + "!");
- }
- mTarget = target;
- }
-
- @Override
- public void tearDown(FilterContext context) {
- if (mFrame != null) {
- mFrame.release();
- mFrame = null;
- }
- }
-
- @Override
- public void process(FilterContext context) {
- // Get input frame
- Frame input = pullInput("image");
- FrameFormat inputFormat = input.getFormat();
-
- // Create output frame
- Frame output = context.getFrameManager().newFrame(inputFormat);
-
- // Create program if not created already
- if (mProgram == null || inputFormat.getTarget() != mTarget) {
- initProgram(context, inputFormat.getTarget());
- }
-
- // Check if the frame size has changed
- if (inputFormat.getWidth() != mWidth || inputFormat.getHeight() != mHeight) {
- mWidth = inputFormat.getWidth();
- mHeight = inputFormat.getHeight();
-
- createBitmapFrame(context);
- }
-
- // Process
- Frame[] inputs = {input, mFrame};
- mProgram.process(inputs, output);
-
- // Push output
- pushOutput("image", output);
-
- // Release pushed frame
- output.release();
- }
-
- private void createBitmapFrame(FilterContext context) {
- if (mBitmap != null) {
- FrameFormat format = ImageFormat.create(mBitmap.getWidth(),
- mBitmap.getHeight(),
- ImageFormat.COLORSPACE_RGBA,
- FrameFormat.TARGET_GPU);
-
- if (mFrame != null) {
- mFrame.release();
- }
-
- mFrame = context.getFrameManager().newFrame(format);
- mFrame.setBitmap(mBitmap);
-
- mBitmap.recycle();
- mBitmap = null;
- }
- }
-}
+++ /dev/null
-/*
- * 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.filterpacks.imageproc;
-
-import android.content.Context;
-import android.filterfw.core.Filter;
-import android.filterfw.core.FilterContext;
-import android.filterfw.core.Frame;
-import android.filterfw.core.FrameFormat;
-import android.filterfw.core.FrameManager;
-import android.filterfw.core.GenerateFinalPort;
-import android.filterfw.core.GenerateFieldPort;
-import android.filterfw.core.KeyValueMap;
-import android.filterfw.core.MutableFrameFormat;
-import android.filterfw.core.NativeFrame;
-import android.filterfw.format.ImageFormat;
-import android.graphics.Bitmap;
-
-/**
- * @hide
- */
-public class BitmapSource extends Filter {
-
- @GenerateFieldPort(name = "target")
- String mTargetString;
-
- @GenerateFieldPort(name = "bitmap")
- private Bitmap mBitmap;
-
- @GenerateFieldPort(name = "recycleBitmap", hasDefault = true)
- private boolean mRecycleBitmap = true;
-
- @GenerateFieldPort(name = "repeatFrame", hasDefault = true)
- boolean mRepeatFrame = false;
-
- private int mTarget;
- private Frame mImageFrame;
-
- public BitmapSource(String name) {
- super(name);
- }
-
-
- @Override
- public void setupPorts() {
- // Setup output format
- FrameFormat outputFormat = ImageFormat.create(ImageFormat.COLORSPACE_RGBA,
- FrameFormat.TARGET_UNSPECIFIED);
-
- // Add output port
- addOutputPort("image", outputFormat);
- }
-
- public void loadImage(FilterContext filterContext) {
- // Create frame with bitmap
- mTarget = FrameFormat.readTargetString(mTargetString);
- FrameFormat outputFormat = ImageFormat.create(mBitmap.getWidth(),
- mBitmap.getHeight(),
- ImageFormat.COLORSPACE_RGBA,
- mTarget);
- mImageFrame = filterContext.getFrameManager().newFrame(outputFormat);
- mImageFrame.setBitmap(mBitmap);
- mImageFrame.setTimestamp(Frame.TIMESTAMP_UNKNOWN);
-
- // Free up space used by bitmap
- if (mRecycleBitmap) {
- mBitmap.recycle();
- }
- mBitmap = null;
- }
-
- @Override
- public void fieldPortValueUpdated(String name, FilterContext context) {
- // Clear image (to trigger reload) in case parameters have been changed
- if (name.equals("bitmap") || name.equals("target")) {
- if (mImageFrame != null) {
- mImageFrame.release();
- mImageFrame = null;
- }
- }
- }
-
- @Override
- public void process(FilterContext context) {
- if (mImageFrame == null) {
- loadImage(context);
- }
-
- pushOutput("image", mImageFrame);
-
- if (!mRepeatFrame) {
- closeOutputPort("image");
- }
- }
-
- @Override
- public void tearDown(FilterContext env) {
- if (mImageFrame != null) {
- mImageFrame.release();
- mImageFrame = null;
- }
- }
-}
+++ /dev/null
-/*
- * 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.filterpacks.imageproc;
-
-import android.filterfw.core.Filter;
-import android.filterfw.core.FilterContext;
-import android.filterfw.core.Frame;
-import android.filterfw.core.FrameFormat;
-import android.filterfw.core.GenerateFieldPort;
-import android.filterfw.core.KeyValueMap;
-import android.filterfw.core.NativeProgram;
-import android.filterfw.core.NativeFrame;
-import android.filterfw.core.Program;
-import android.filterfw.core.ShaderProgram;
-import android.filterfw.format.ImageFormat;
-
-import java.util.Random;
-
-public class BlackWhiteFilter extends Filter {
-
- @GenerateFieldPort(name = "black", hasDefault = true)
- private float mBlack = 0f;
-
- @GenerateFieldPort(name = "white", hasDefault = true)
- private float mWhite = 1f;
-
- @GenerateFieldPort(name = "tile_size", hasDefault = true)
- private int mTileSize = 640;
-
- private Program mProgram;
-
- private int mWidth = 0;
- private int mHeight = 0;
- private int mTarget = FrameFormat.TARGET_UNSPECIFIED;
-
- private Frame mNoiseFrame = null;
- private Random mRandom;
-
- private final String mBlackWhiteShader =
- "precision mediump float;\n" +
- "uniform sampler2D tex_sampler_0;\n" +
- "uniform sampler2D tex_sampler_1;\n" +
- "uniform float black;\n" +
- "uniform float scale;\n" +
- "uniform float stepsize;\n" +
- "varying vec2 v_texcoord;\n" +
- "void main() {\n" +
- " vec4 color = texture2D(tex_sampler_0, v_texcoord);\n" +
- " float dither = texture2D(tex_sampler_1, v_texcoord).r;\n" +
- " vec3 xform = clamp((color.rgb - black) * scale, 0.0, 1.0);\n" +
- " vec3 temp = clamp((color.rgb + stepsize - black) * scale, 0.0, 1.0);\n" +
- " vec3 new_color = clamp(xform + (temp - xform) * (dither - 0.5), 0.0, 1.0);\n" +
- " gl_FragColor = vec4(new_color, color.a);\n" +
- "}\n";
-
- public BlackWhiteFilter(String name) {
- super(name);
-
- mRandom = new Random();
- }
-
- @Override
- public void setupPorts() {
- addMaskedInputPort("image", ImageFormat.create(ImageFormat.COLORSPACE_RGBA));
- addOutputBasedOnInput("image", "image");
- }
-
- @Override
- public FrameFormat getOutputFormat(String portName, FrameFormat inputFormat) {
- return inputFormat;
- }
-
- @Override
- public void tearDown(FilterContext context) {
- if (mNoiseFrame != null) {
- mNoiseFrame.release();
- mNoiseFrame = null;
- }
- }
-
- public void initProgram(FilterContext context, int target) {
- switch (target) {
- case FrameFormat.TARGET_GPU:
- ShaderProgram shaderProgram = new ShaderProgram(context, mBlackWhiteShader);
- shaderProgram.setMaximumTileSize(mTileSize);
- mProgram = shaderProgram;
- updateParameters();
- break;
-
- default:
- throw new RuntimeException("Filter Sharpen does not support frames of " +
- "target " + target + "!");
- }
- mTarget = target;
- }
-
- private void updateParameters() {
- float scale = (mBlack != mWhite) ? 1.0f / (mWhite - mBlack) : 2000f;
- float stepsize = 1.0f / 255.0f;
-
- mProgram.setHostValue("black", mBlack);
- mProgram.setHostValue("scale", scale);
- mProgram.setHostValue("stepsize", stepsize);
- }
-
- @Override
- public void fieldPortValueUpdated(String name, FilterContext context) {
- if (mProgram != null) {
- updateParameters();
- }
- }
-
- @Override
- public void process(FilterContext context) {
- // Get input frame
- Frame input = pullInput("image");
- FrameFormat inputFormat = input.getFormat();
-
- // Create program if not created already
- if (mProgram == null || inputFormat.getTarget() != mTarget) {
- initProgram(context, inputFormat.getTarget());
- }
-
- // Check if the frame size has changed
- if (inputFormat.getWidth() != mWidth || inputFormat.getHeight() != mHeight) {
- mWidth = inputFormat.getWidth();
- mHeight = inputFormat.getHeight();
-
- if (mNoiseFrame != null) {
- mNoiseFrame.release();
- }
-
- int[] buffer = new int[mWidth * mHeight];
- for (int i = 0; i < mWidth * mHeight; ++i) {
- buffer[i] = mRandom.nextInt(255);
- }
- FrameFormat format = ImageFormat.create(mWidth, mHeight,
- ImageFormat.COLORSPACE_RGBA,
- FrameFormat.TARGET_GPU);
- mNoiseFrame = context.getFrameManager().newFrame(format);
- mNoiseFrame.setInts(buffer);
- }
-
- if (mNoiseFrame != null && (mNoiseFrame.getFormat().getWidth() != mWidth ||
- mNoiseFrame.getFormat().getHeight() != mHeight)) {
- throw new RuntimeException("Random map and imput image size mismatch!");
- }
-
- // Create output frame
- Frame output = context.getFrameManager().newFrame(inputFormat);
-
- // Process
- Frame[] inputs = {input, mNoiseFrame};
- mProgram.process(inputs, output);
-
- // Push output
- pushOutput("image", output);
-
- // Release pushed frame
- output.release();
- }
-}
+++ /dev/null
-/*
- * 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.filterpacks.imageproc;
-
-import android.filterfw.core.Filter;
-import android.filterfw.core.FilterContext;
-import android.filterfw.core.Frame;
-import android.filterfw.core.FrameFormat;
-import android.filterfw.core.KeyValueMap;
-import android.filterfw.core.NativeProgram;
-import android.filterfw.core.NativeFrame;
-import android.filterfw.core.Program;
-import android.filterfw.core.ShaderProgram;
-import android.filterfw.format.ImageFormat;
-
-import java.util.Set;
-
-/**
- * The filter linearly blends "left" and "right" frames. The blending weight is
- * the multiplication of parameter "blend" and the alpha value in "right" frame.
- * @hide
- */
-public class BlendFilter extends ImageCombineFilter {
-
- private final String mBlendShader =
- "precision mediump float;\n" +
- "uniform sampler2D tex_sampler_0;\n" +
- "uniform sampler2D tex_sampler_1;\n" +
- "uniform float blend;\n" +
- "varying vec2 v_texcoord;\n" +
- "void main() {\n" +
- " vec4 colorL = texture2D(tex_sampler_0, v_texcoord);\n" +
- " vec4 colorR = texture2D(tex_sampler_1, v_texcoord);\n" +
- " float weight = colorR.a * blend;\n" +
- " gl_FragColor = mix(colorL, colorR, weight);\n" +
- "}\n";
-
- public BlendFilter(String name) {
- super(name, new String[] { "left", "right" }, "blended", "blend");
- }
-
- @Override
- protected Program getNativeProgram(FilterContext context) {
- throw new RuntimeException("TODO: Write native implementation for Blend!");
- }
-
- @Override
- protected Program getShaderProgram(FilterContext context) {
- return new ShaderProgram(context, mBlendShader);
- }
-}
+++ /dev/null
-/*
- * 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.filterpacks.imageproc;
-
-import android.filterfw.core.Filter;
-import android.filterfw.core.FilterContext;
-import android.filterfw.core.Frame;
-import android.filterfw.core.FrameFormat;
-import android.filterfw.core.KeyValueMap;
-import android.filterfw.core.NativeProgram;
-import android.filterfw.core.NativeFrame;
-import android.filterfw.core.Program;
-import android.filterfw.core.ShaderProgram;
-
-/**
- * @hide
- */
-public class BrightnessFilter extends SimpleImageFilter {
-
- private static final String mBrightnessShader =
- "precision mediump float;\n" +
- "uniform sampler2D tex_sampler_0;\n" +
- "uniform float brightness;\n" +
- "varying vec2 v_texcoord;\n" +
- "void main() {\n" +
- " vec4 color = texture2D(tex_sampler_0, v_texcoord);\n" +
- " gl_FragColor = brightness * color;\n" +
- "}\n";
-
- public BrightnessFilter(String name) {
- super(name, "brightness");
- }
-
- @Override
- protected Program getNativeProgram(FilterContext context) {
- return new NativeProgram("filterpack_imageproc", "brightness");
- }
-
- @Override
- protected Program getShaderProgram(FilterContext context) {
- return new ShaderProgram(context, mBrightnessShader);
- }
-
-}
+++ /dev/null
-/*
- * 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.filterpacks.imageproc;
-
-import android.filterfw.core.Filter;
-import android.filterfw.core.FilterContext;
-import android.filterfw.core.Frame;
-import android.filterfw.core.FrameFormat;
-import android.filterfw.core.GenerateFieldPort;
-import android.filterfw.core.KeyValueMap;
-import android.filterfw.core.NativeProgram;
-import android.filterfw.core.NativeFrame;
-import android.filterfw.core.Program;
-import android.filterfw.core.ShaderProgram;
-import android.filterfw.format.ImageFormat;
-import android.util.Log;
-
-public class ColorTemperatureFilter extends Filter {
-
- @GenerateFieldPort(name = "scale", hasDefault = true)
- private float mScale = 0.5f;
-
- @GenerateFieldPort(name = "tile_size", hasDefault = true)
- private int mTileSize = 640;
-
- private Program mProgram;
- private int mTarget = FrameFormat.TARGET_UNSPECIFIED;
-
- private final String mColorTemperatureShader =
- "precision mediump float;\n" +
- "uniform sampler2D tex_sampler_0;\n" +
- "uniform float scale;\n" +
- "varying vec2 v_texcoord;\n" +
- "void main() {\n" +
- " vec4 color = texture2D(tex_sampler_0, v_texcoord);\n" +
- " vec3 new_color = color.rgb;\n" +
- " new_color.r = color.r + color.r * ( 1.0 - color.r) * scale;\n" +
- " new_color.b = color.b - color.b * ( 1.0 - color.b) * scale;\n" +
- " if (scale > 0.0) { \n" +
- " color.g = color.g + color.g * ( 1.0 - color.g) * scale * 0.25;\n" +
- " }\n" +
- " float max_value = max(new_color.r, max(new_color.g, new_color.b));\n" +
- " if (max_value > 1.0) { \n" +
- " new_color /= max_value;\n" +
- " } \n" +
- " gl_FragColor = vec4(new_color, color.a);\n" +
- "}\n";
-
- public ColorTemperatureFilter(String name) {
- super(name);
- }
-
- @Override
- public void setupPorts() {
- addMaskedInputPort("image", ImageFormat.create(ImageFormat.COLORSPACE_RGBA));
- addOutputBasedOnInput("image", "image");
- }
-
- @Override
- public FrameFormat getOutputFormat(String portName, FrameFormat inputFormat) {
- return inputFormat;
- }
-
- public void initProgram(FilterContext context, int target) {
- switch (target) {
- case FrameFormat.TARGET_GPU:
- ShaderProgram shaderProgram = new ShaderProgram(context, mColorTemperatureShader);
- shaderProgram.setMaximumTileSize(mTileSize);
- mProgram = shaderProgram;
- break;
-
- default:
- throw new RuntimeException("Filter Sharpen does not support frames of " +
- "target " + target + "!");
- }
- mTarget = target;
- }
-
- @Override
- public void process(FilterContext context) {
- // Get input frame
- Frame input = pullInput("image");
- FrameFormat inputFormat = input.getFormat();
-
- // Create program if not created already
- if (mProgram == null || inputFormat.getTarget() != mTarget) {
- initProgram(context, inputFormat.getTarget());
- updateParameters();
- }
-
- // Create output frame
- Frame output = context.getFrameManager().newFrame(inputFormat);
-
- // Process
- mProgram.process(input, output);
-
- // Push output
- pushOutput("image", output);
-
- // Release pushed frame
- output.release();
- }
-
- private void updateParameters() {
- mProgram.setHostValue("scale", 2.0f * mScale - 1.0f);
- }
-
- @Override
- public void fieldPortValueUpdated(String name, FilterContext context) {
- if (mProgram != null) {
- updateParameters();
- }
- }
-}
+++ /dev/null
-/*
- * 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.filterpacks.imageproc;
-
-import android.filterfw.core.Filter;
-import android.filterfw.core.FilterContext;
-import android.filterfw.core.Frame;
-import android.filterfw.core.FrameFormat;
-import android.filterfw.core.KeyValueMap;
-import android.filterfw.core.NativeProgram;
-import android.filterfw.core.NativeFrame;
-import android.filterfw.core.Program;
-import android.filterfw.core.ShaderProgram;
-
-import java.util.Set;
-
-/**
- * @hide
- */
-public class ContrastFilter extends SimpleImageFilter {
-
- private static final String mContrastShader =
- "precision mediump float;\n" +
- "uniform sampler2D tex_sampler_0;\n" +
- "uniform float contrast;\n" +
- "varying vec2 v_texcoord;\n" +
- "void main() {\n" +
- " vec4 color = texture2D(tex_sampler_0, v_texcoord);\n" +
- " color -= 0.5;\n" +
- " color *= contrast;\n" +
- " color += 0.5;\n" +
- " gl_FragColor = color;\n" + // this will clamp
- "}\n";
-
- public ContrastFilter(String name) {
- super(name, "contrast");
- }
-
- @Override
- protected Program getNativeProgram(FilterContext context) {
- return new NativeProgram("filterpack_imageproc", "contrast");
- }
-
- @Override
- protected Program getShaderProgram(FilterContext context) {
- return new ShaderProgram(context, mContrastShader);
- }
-
-}
+++ /dev/null
-/*
- * 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.filterpacks.imageproc;
-
-import android.filterfw.core.Filter;
-import android.filterfw.core.FilterContext;
-import android.filterfw.core.Frame;
-import android.filterfw.core.FrameFormat;
-import android.filterfw.core.GenerateFieldPort;
-import android.filterfw.core.KeyValueMap;
-import android.filterfw.core.MutableFrameFormat;
-import android.filterfw.core.NativeProgram;
-import android.filterfw.core.NativeFrame;
-import android.filterfw.core.Program;
-import android.filterfw.core.ShaderProgram;
-import android.filterfw.geometry.Point;
-import android.filterfw.geometry.Quad;
-import android.filterfw.format.ImageFormat;
-import android.filterfw.format.ObjectFormat;
-
-import android.util.Log;
-
-/**
- * @hide
- */
-public class CropFilter extends Filter {
-
- private Program mProgram;
- private FrameFormat mLastFormat = null;
-
- @GenerateFieldPort(name = "owidth")
- private int mOutputWidth = -1;
-
- @GenerateFieldPort(name = "oheight")
- private int mOutputHeight = -1;
-
- @GenerateFieldPort(name = "fillblack")
- private boolean mFillBlack = false;
-
- public CropFilter(String name) {
- super(name);
- }
-
- private final String mFragShader =
- "precision mediump float;\n" +
- "uniform sampler2D tex_sampler_0;\n" +
- "varying vec2 v_texcoord;\n" +
- "void main() {\n" +
- " const vec2 lo = vec2(0.0, 0.0);\n" +
- " const vec2 hi = vec2(1.0, 1.0);\n" +
- " const vec4 black = vec4(0.0, 0.0, 0.0, 1.0);\n" +
- " bool out_of_bounds =\n" +
- " any(lessThan(v_texcoord, lo)) ||\n" +
- " any(greaterThan(v_texcoord, hi));\n" +
- " if (out_of_bounds) {\n" +
- " gl_FragColor = black;\n" +
- " } else {\n" +
- " gl_FragColor = texture2D(tex_sampler_0, v_texcoord);\n" +
- " }\n" +
- "}\n";
-
- @Override
- public void setupPorts() {
- addMaskedInputPort("image", ImageFormat.create(ImageFormat.COLORSPACE_RGBA));
- addMaskedInputPort("box", ObjectFormat.fromClass(Quad.class, FrameFormat.TARGET_SIMPLE));
- addOutputBasedOnInput("image", "image");
- }
-
- @Override
- public FrameFormat getOutputFormat(String portName, FrameFormat inputFormat) {
- // Make sure output size is set to unspecified, as we do not know what we will be resizing
- // to.
- MutableFrameFormat outputFormat = inputFormat.mutableCopy();
- outputFormat.setDimensions(FrameFormat.SIZE_UNSPECIFIED, FrameFormat.SIZE_UNSPECIFIED);
- return outputFormat;
- }
-
- protected void createProgram(FilterContext context, FrameFormat format) {
- // TODO: Add CPU version
- if (mLastFormat != null && mLastFormat.getTarget() == format.getTarget()) return;
- mLastFormat = format;
- mProgram = null;
- switch (format.getTarget()) {
- case FrameFormat.TARGET_GPU:
- if(mFillBlack)
- mProgram = new ShaderProgram(context, mFragShader);
- else
- mProgram = ShaderProgram.createIdentity(context);
-
- break;
- }
- if (mProgram == null) {
- throw new RuntimeException("Could not create a program for crop filter " + this + "!");
- }
- }
-
- @Override
- public void process(FilterContext env) {
- // Get input frame
- Frame imageFrame = pullInput("image");
- Frame boxFrame = pullInput("box");
-
- createProgram(env, imageFrame.getFormat());
-
- // Get the box
- Quad box = (Quad)boxFrame.getObjectValue();
-
- // Create output format
- MutableFrameFormat outputFormat = imageFrame.getFormat().mutableCopy();
- outputFormat.setDimensions(mOutputWidth == -1 ? outputFormat.getWidth() : mOutputWidth,
- mOutputHeight == -1 ? outputFormat.getHeight() : mOutputHeight);
-
- // Create output frame
- Frame output = env.getFrameManager().newFrame(outputFormat);
-
- // Set the program parameters
- if (mProgram instanceof ShaderProgram) {
- ShaderProgram shaderProgram = (ShaderProgram)mProgram;
- shaderProgram.setSourceRegion(box);
- }
-
- mProgram.process(imageFrame, output);
-
- // Push output
- pushOutput("image", output);
-
- // Release pushed frame
- output.release();
- }
-
-
-}
+++ /dev/null
-/*
- * 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.filterpacks.imageproc;
-
-import android.filterfw.core.Filter;
-import android.filterfw.core.FilterContext;
-import android.filterfw.core.Frame;
-import android.filterfw.core.FrameFormat;
-import android.filterfw.core.GenerateFieldPort;
-import android.filterfw.core.KeyValueMap;
-import android.filterfw.core.MutableFrameFormat;
-import android.filterfw.core.NativeProgram;
-import android.filterfw.core.NativeFrame;
-import android.filterfw.core.Program;
-import android.filterfw.core.ShaderProgram;
-import android.filterfw.format.ImageFormat;
-import android.util.Log;
-
-/**
- * @hide
- */
-public class CropRectFilter extends Filter {
-
- @GenerateFieldPort(name = "xorigin")
- private int mXorigin;
-
- @GenerateFieldPort(name = "yorigin")
- private int mYorigin;
-
- @GenerateFieldPort(name = "width")
- private int mOutputWidth;
-
- @GenerateFieldPort(name = "height")
- private int mOutputHeight;
-
- @GenerateFieldPort(name = "tile_size", hasDefault = true)
- private int mTileSize = 640;
-
- private Program mProgram;
-
- private int mWidth = 0;
- private int mHeight = 0;
-
- private int mTarget = FrameFormat.TARGET_UNSPECIFIED;
-
- public CropRectFilter(String name) {
- super(name);
- }
-
- @Override
- public void setupPorts() {
- addMaskedInputPort("image", ImageFormat.create(ImageFormat.COLORSPACE_RGBA));
- addOutputBasedOnInput("image", "image");
- }
-
- public void initProgram(FilterContext context, int target) {
- switch (target) {
- case FrameFormat.TARGET_GPU:
- ShaderProgram shaderProgram = ShaderProgram.createIdentity(context);
- shaderProgram.setMaximumTileSize(mTileSize);
- mProgram = shaderProgram;
- break;
-
- default:
- throw new RuntimeException("Filter Sharpen does not support frames of " +
- "target " + target + "!");
- }
- mTarget = target;
- }
-
- @Override
- public void fieldPortValueUpdated(String name, FilterContext context) {
- if (mProgram != null) {
- updateSourceRect(mWidth, mHeight);
- }
- }
-
- @Override
- public void process(FilterContext context) {
- // Get input frame
- Frame input = pullInput("image");
- FrameFormat inputFormat = input.getFormat();
-
- // Create output frame
- FrameFormat outputFormat = ImageFormat.create(mOutputWidth, mOutputHeight,
- ImageFormat.COLORSPACE_RGBA,
- FrameFormat.TARGET_GPU);
- Frame output = context.getFrameManager().newFrame(outputFormat);
-
- // Create program if not created already
- if (mProgram == null || inputFormat.getTarget() != mTarget) {
- initProgram(context, inputFormat.getTarget());
- }
-
- // Check if the frame size has changed
- if (inputFormat.getWidth() != mWidth || inputFormat.getHeight() != mHeight) {
- updateSourceRect(inputFormat.getWidth(), inputFormat.getHeight());
- }
-
- // Process
- mProgram.process(input, output);
-
- // Push output
- pushOutput("image", output);
-
- // Release pushed frame
- output.release();
- }
-
- void updateSourceRect(int width, int height) {
- mWidth = width;
- mHeight = height;
-
- /*
- Log.e("CropFilter", mWidth + ", " + mHeight + ", " +
- (float) mXorigin / mWidth + ", " +
- (float) mYorigin / mHeight + ", " +
- (float) mOutputWidth / mWidth + ", " +
- (float) mOutputHeight / mHeight);
- */
-
- ((ShaderProgram) mProgram).setSourceRect((float) mXorigin / mWidth,
- (float) mYorigin / mHeight,
- (float) mOutputWidth / mWidth,
- (float) mOutputHeight / mHeight);
- }
-}
+++ /dev/null
-/*
- * 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.filterpacks.imageproc;
-
-import android.filterfw.core.Filter;
-import android.filterfw.core.FilterContext;
-import android.filterfw.core.Frame;
-import android.filterfw.core.FrameFormat;
-import android.filterfw.core.GenerateFieldPort;
-import android.filterfw.core.KeyValueMap;
-import android.filterfw.core.NativeProgram;
-import android.filterfw.core.NativeFrame;
-import android.filterfw.core.Program;
-import android.filterfw.core.ShaderProgram;
-import android.filterfw.format.ImageFormat;
-
-import android.util.Log;
-
-public class CrossProcessFilter extends Filter {
-
- @GenerateFieldPort(name = "tile_size", hasDefault = true)
- private int mTileSize = 640;
-
- private Program mProgram;
-
- private int mTarget = FrameFormat.TARGET_UNSPECIFIED;
-
- private final String mCrossProcessShader =
- "precision mediump float;\n" +
- "uniform sampler2D tex_sampler_0;\n" +
- "varying vec2 v_texcoord;\n" +
- "void main() {\n" +
- " vec4 color = texture2D(tex_sampler_0, v_texcoord);\n" +
- " vec3 ncolor = vec3(0.0, 0.0, 0.0);\n" +
- " float value;\n" +
- " if (color.r < 0.5) {\n" +
- " value = color.r;\n" +
- " } else {\n" +
- " value = 1.0 - color.r;\n" +
- " }\n" +
- " float red = 4.0 * value * value * value;\n" +
- " if (color.r < 0.5) {\n" +
- " ncolor.r = red;\n" +
- " } else {\n" +
- " ncolor.r = 1.0 - red;\n" +
- " }\n" +
- " if (color.g < 0.5) {\n" +
- " value = color.g;\n" +
- " } else {\n" +
- " value = 1.0 - color.g;\n" +
- " }\n" +
- " float green = 2.0 * value * value;\n" +
- " if (color.g < 0.5) {\n" +
- " ncolor.g = green;\n" +
- " } else {\n" +
- " ncolor.g = 1.0 - green;\n" +
- " }\n" +
- " ncolor.b = color.b * 0.5 + 0.25;\n" +
- " gl_FragColor = vec4(ncolor.rgb, color.a);\n" +
- "}\n";
-
- public CrossProcessFilter(String name) {
- super(name);
- }
-
- @Override
- public void setupPorts() {
- addMaskedInputPort("image", ImageFormat.create(ImageFormat.COLORSPACE_RGBA));
- addOutputBasedOnInput("image", "image");
- }
-
- @Override
- public FrameFormat getOutputFormat(String portName, FrameFormat inputFormat) {
- return inputFormat;
- }
-
- public void initProgram(FilterContext context, int target) {
- switch (target) {
- case FrameFormat.TARGET_GPU:
- ShaderProgram shaderProgram = new ShaderProgram(context, mCrossProcessShader);
- shaderProgram.setMaximumTileSize(mTileSize);
- mProgram = shaderProgram;
- break;
-
- default:
- throw new RuntimeException("Filter CrossProcess does not support frames of " +
- "target " + target + "!");
- }
- mTarget = target;
- }
-
- @Override
- public void process(FilterContext context) {
- // Get input frame
- Frame input = pullInput("image");
- FrameFormat inputFormat = input.getFormat();
-
- // Create program if not created already
- if (mProgram == null || inputFormat.getTarget() != mTarget) {
- initProgram(context, inputFormat.getTarget());
- }
-
- // Create output frame
- Frame output = context.getFrameManager().newFrame(inputFormat);
-
- // Process
- mProgram.process(input, output);
-
- // Push output
- pushOutput("image", output);
-
- // Release pushed frame
- output.release();
- }
-}
+++ /dev/null
-/*
- * 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.filterpacks.imageproc;
-
-import android.filterfw.core.Filter;
-import android.filterfw.core.FilterContext;
-import android.filterfw.core.Frame;
-import android.filterfw.core.FrameFormat;
-import android.filterfw.core.GenerateFieldPort;
-import android.filterfw.core.KeyValueMap;
-import android.filterfw.core.NativeProgram;
-import android.filterfw.core.NativeFrame;
-import android.filterfw.core.Program;
-import android.filterfw.core.ShaderProgram;
-import android.filterfw.format.ImageFormat;
-
-import java.util.Random;
-
-public class DocumentaryFilter extends Filter {
-
- @GenerateFieldPort(name = "tile_size", hasDefault = true)
- private int mTileSize = 640;
-
- private Program mProgram;
-
- private int mWidth = 0;
- private int mHeight = 0;
- private int mTarget = FrameFormat.TARGET_UNSPECIFIED;
-
- private Frame mNoiseFrame;
- private Random mRandom;
-
- private final String mDocumentaryShader =
- "precision mediump float;\n" +
- "uniform sampler2D tex_sampler_0;\n" +
- "uniform sampler2D tex_sampler_1;\n" +
- "uniform float stepsize;\n" +
- "uniform float inv_max_dist;\n" +
- "uniform vec2 center;\n" +
- "varying vec2 v_texcoord;\n" +
- "void main() {\n" +
- // black white
- " vec4 color = texture2D(tex_sampler_0, v_texcoord);\n" +
- " float dither = texture2D(tex_sampler_1, v_texcoord).r;\n" +
- " vec3 xform = clamp(2.0 * color.rgb, 0.0, 1.0);\n" +
- " vec3 temp = clamp(2.0 * (color.rgb + stepsize), 0.0, 1.0);\n" +
- " vec3 new_color = clamp(xform + (temp - xform) * (dither - 0.5), 0.0, 1.0);\n" +
- // grayscale
- " float gray = dot(new_color, vec3(0.299, 0.587, 0.114));\n" +
- " new_color = vec3(gray, gray, gray);\n" +
- // vignette
- " float dist = distance(gl_FragCoord.xy, center);\n" +
- " float lumen = 0.85 / (1.0 + exp((dist * inv_max_dist - 0.83) * 20.0)) + 0.15;\n" +
- " gl_FragColor = vec4(new_color * lumen, color.a);\n" +
- "}\n";
-
- public DocumentaryFilter(String name) {
- super(name);
-
- mRandom = new Random();
- }
-
- @Override
- public void setupPorts() {
- addMaskedInputPort("image", ImageFormat.create(ImageFormat.COLORSPACE_RGBA));
- addOutputBasedOnInput("image", "image");
- }
-
- @Override
- public FrameFormat getOutputFormat(String portName, FrameFormat inputFormat) {
- return inputFormat;
- }
-
- @Override
- public void tearDown(FilterContext context) {
- if (mNoiseFrame != null) {
- mNoiseFrame.release();
- mNoiseFrame = null;
- }
- }
-
- public void initProgram(FilterContext context, int target) {
- switch (target) {
- case FrameFormat.TARGET_GPU:
- ShaderProgram shaderProgram = new ShaderProgram(context, mDocumentaryShader);
- shaderProgram.setMaximumTileSize(mTileSize);
- mProgram = shaderProgram;
- break;
-
- default:
- throw new RuntimeException("Filter Sharpen does not support frames of " +
- "target " + target + "!");
- }
- mTarget = target;
- }
-
- @Override
- public void process(FilterContext context) {
- // Get input frame
- Frame input = pullInput("image");
- FrameFormat inputFormat = input.getFormat();
-
- // Create program if not created already
- if (mProgram == null || inputFormat.getTarget() != mTarget) {
- initProgram(context, inputFormat.getTarget());
- }
-
- // Check if the frame size has changed
- if (inputFormat.getWidth() != mWidth || inputFormat.getHeight() != mHeight) {
- mWidth = inputFormat.getWidth();
- mHeight = inputFormat.getHeight();
-
- int[] buffer = new int[mWidth * mHeight];
- for (int i = 0; i < mWidth * mHeight; ++i) {
- buffer[i] = mRandom.nextInt(255);
- }
- FrameFormat format = ImageFormat.create(mWidth, mHeight,
- ImageFormat.COLORSPACE_RGBA,
- FrameFormat.TARGET_GPU);
- if (mNoiseFrame != null) {
- mNoiseFrame.release();
- }
- mNoiseFrame = context.getFrameManager().newFrame(format);
- mNoiseFrame.setInts(buffer);
-
- initParameters();
- }
-
- if (mNoiseFrame != null && (mNoiseFrame.getFormat().getWidth() != mWidth ||
- mNoiseFrame.getFormat().getHeight() != mHeight)) {
- throw new RuntimeException("Random map and imput image size mismatch!");
- }
-
- // Create output frame
- Frame output = context.getFrameManager().newFrame(inputFormat);
-
- // Process
- Frame[] inputs = {input, mNoiseFrame};
- mProgram.process(inputs, output);
-
- // Push output
- pushOutput("image", output);
-
- // Release pushed frame
- output.release();
- }
-
- private void initParameters() {
- if (mProgram != null) {
- float centerX = (float) (0.5 * mWidth);
- float centerY = (float) (0.5 * mHeight);
- float center[] = {centerX, centerY};
- float max_dist = (float) Math.sqrt(centerX * centerX + centerY * centerY);
-
- mProgram.setHostValue("center", center);
- mProgram.setHostValue("inv_max_dist", 1.0f / max_dist);
- mProgram.setHostValue("stepsize", 1.0f / 255.0f);
- }
- }
-
-}
+++ /dev/null
-/*
- * 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.filterpacks.imageproc;
-
-import android.filterfw.core.Filter;
-import android.filterfw.core.FilterContext;
-import android.filterfw.core.Frame;
-import android.filterfw.core.FrameFormat;
-import android.filterfw.core.GLFrame;
-import android.filterfw.core.NativeProgram;
-import android.filterfw.core.NativeFrame;
-import android.filterfw.core.Program;
-import android.filterfw.core.ShaderProgram;
-import android.filterfw.geometry.Quad;
-import android.filterfw.format.ImageFormat;
-import android.filterfw.format.ObjectFormat;
-
-import android.opengl.GLES20;
-
-/**
- * @hide
- */
-public class DrawOverlayFilter extends Filter {
-
- private ShaderProgram mProgram;
-
- public DrawOverlayFilter(String name) {
- super(name);
- }
-
- @Override
- public void setupPorts() {
- FrameFormat imageFormatMask = ImageFormat.create(ImageFormat.COLORSPACE_RGBA,
- FrameFormat.TARGET_GPU);
- addMaskedInputPort("source", imageFormatMask);
- addMaskedInputPort("overlay", imageFormatMask);
- addMaskedInputPort("box", ObjectFormat.fromClass(Quad.class, FrameFormat.TARGET_SIMPLE));
- addOutputBasedOnInput("image", "source");
- }
-
- @Override
- public FrameFormat getOutputFormat(String portName, FrameFormat inputFormat) {
- return inputFormat;
- }
-
- @Override
- public void prepare(FilterContext context) {
- mProgram = ShaderProgram.createIdentity(context);
- }
-
- @Override
- public void process(FilterContext env) {
- // Get input frame
- Frame sourceFrame = pullInput("source");
- Frame overlayFrame = pullInput("overlay");
- Frame boxFrame = pullInput("box");
-
- // Get the box
- Quad box = (Quad)boxFrame.getObjectValue();
- box = box.translated(1.0f, 1.0f).scaled(2.0f);
-
- mProgram.setTargetRegion(box);
-
- // Create output frame with copy of input
- Frame output = env.getFrameManager().newFrame(sourceFrame.getFormat());
- output.setDataFromFrame(sourceFrame);
-
- // Draw onto output
- mProgram.process(overlayFrame, output);
-
- // Push output
- pushOutput("image", output);
-
- // Release pushed frame
- output.release();
- }
-}
+++ /dev/null
-/*
- * 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.filterpacks.imageproc;
-
-import android.filterfw.core.Filter;
-import android.filterfw.core.FilterContext;
-import android.filterfw.core.Frame;
-import android.filterfw.core.FrameFormat;
-import android.filterfw.core.GenerateFieldPort;
-import android.filterfw.core.GLFrame;
-import android.filterfw.core.NativeProgram;
-import android.filterfw.core.NativeFrame;
-import android.filterfw.core.Program;
-import android.filterfw.core.ShaderProgram;
-import android.filterfw.geometry.Quad;
-import android.filterfw.format.ImageFormat;
-import android.filterfw.format.ObjectFormat;
-
-import android.opengl.GLES20;
-
-/**
- * @hide
- */
-public class DrawRectFilter extends Filter {
-
- @GenerateFieldPort(name = "colorRed", hasDefault = true)
- private float mColorRed = 0.8f;
-
- @GenerateFieldPort(name = "colorGreen", hasDefault = true)
- private float mColorGreen = 0.8f;
-
- @GenerateFieldPort(name = "colorBlue", hasDefault = true)
- private float mColorBlue = 0.0f;
-
- private final String mVertexShader =
- "attribute vec4 aPosition;\n" +
- "void main() {\n" +
- " gl_Position = aPosition;\n" +
- "}\n";
-
- private final String mFixedColorFragmentShader =
- "precision mediump float;\n" +
- "uniform vec4 color;\n" +
- "void main() {\n" +
- " gl_FragColor = color;\n" +
- "}\n";
-
- private ShaderProgram mProgram;
-
-
- public DrawRectFilter(String name) {
- super(name);
- }
-
- @Override
- public void setupPorts() {
- addMaskedInputPort("image", ImageFormat.create(ImageFormat.COLORSPACE_RGBA,
- FrameFormat.TARGET_GPU));
- addMaskedInputPort("box", ObjectFormat.fromClass(Quad.class, FrameFormat.TARGET_SIMPLE));
- addOutputBasedOnInput("image", "image");
- }
-
- @Override
- public FrameFormat getOutputFormat(String portName, FrameFormat inputFormat) {
- return inputFormat;
- }
-
- @Override
- public void prepare(FilterContext context) {
- mProgram = new ShaderProgram(context, mVertexShader, mFixedColorFragmentShader);
- }
-
- @Override
- public void process(FilterContext env) {
- // Get input frame
- Frame imageFrame = pullInput("image");
- Frame boxFrame = pullInput("box");
-
- // Get the box
- Quad box = (Quad)boxFrame.getObjectValue();
- box = box.scaled(2.0f).translated(-1.0f, -1.0f);
-
- // Create output frame with copy of input
- GLFrame output = (GLFrame)env.getFrameManager().duplicateFrame(imageFrame);
-
- // Draw onto output
- output.focus();
- renderBox(box);
-
- // Push output
- pushOutput("image", output);
-
- // Release pushed frame
- output.release();
- }
-
- private void renderBox(Quad box) {
- final int FLOAT_SIZE = 4;
-
- // Get current values
- float[] color = {mColorRed, mColorGreen, mColorBlue, 1f};
- float[] vertexValues = { box.p0.x, box.p0.y,
- box.p1.x, box.p1.y,
- box.p3.x, box.p3.y,
- box.p2.x, box.p2.y };
-
- // Set the program variables
- mProgram.setHostValue("color", color);
- mProgram.setAttributeValues("aPosition", vertexValues, 2);
- mProgram.setVertexCount(4);
-
- // Draw
- mProgram.beginDrawing();
- GLES20.glLineWidth(1.0f);
- GLES20.glDrawArrays(GLES20.GL_LINE_LOOP, 0, 4);
- }
-}
+++ /dev/null
-/*
- * 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.filterpacks.imageproc;
-
-import android.filterfw.core.Filter;
-import android.filterfw.core.FilterContext;
-import android.filterfw.core.Frame;
-import android.filterfw.core.FrameFormat;
-import android.filterfw.core.GenerateFieldPort;
-import android.filterfw.core.KeyValueMap;
-import android.filterfw.core.NativeProgram;
-import android.filterfw.core.NativeFrame;
-import android.filterfw.core.Program;
-import android.filterfw.core.ShaderProgram;
-import android.filterfw.format.ImageFormat;
-import android.graphics.Color;
-
-public class DuotoneFilter extends Filter {
-
- @GenerateFieldPort(name = "first_color", hasDefault = true)
- private int mFirstColor = 0xFFFF0000;
-
- @GenerateFieldPort(name = "second_color", hasDefault = true)
- private int mSecondColor = 0xFFFFFF00;
-
- @GenerateFieldPort(name = "tile_size", hasDefault = true)
- private int mTileSize = 640;
-
- private Program mProgram;
- private int mTarget = FrameFormat.TARGET_UNSPECIFIED;
-
- private final String mDuotoneShader =
- "precision mediump float;\n" +
- "uniform sampler2D tex_sampler_0;\n" +
- "uniform vec3 first;\n" +
- "uniform vec3 second;\n" +
- "varying vec2 v_texcoord;\n" +
- "void main() {\n" +
- " vec4 color = texture2D(tex_sampler_0, v_texcoord);\n" +
- " float energy = (color.r + color.g + color.b) * 0.3333;\n" +
- " vec3 new_color = (1.0 - energy) * first + energy * second;\n" +
- " gl_FragColor = vec4(new_color.rgb, color.a);\n" +
- "}\n";
-
- public DuotoneFilter(String name) {
- super(name);
- }
-
- @Override
- public void setupPorts() {
- addMaskedInputPort("image", ImageFormat.create(ImageFormat.COLORSPACE_RGBA));
- addOutputBasedOnInput("image", "image");
- }
-
- @Override
- public FrameFormat getOutputFormat(String portName, FrameFormat inputFormat) {
- return inputFormat;
- }
-
- public void initProgram(FilterContext context, int target) {
- switch (target) {
- case FrameFormat.TARGET_GPU:
- ShaderProgram shaderProgram = new ShaderProgram(context, mDuotoneShader);
- shaderProgram.setMaximumTileSize(mTileSize);
- mProgram = shaderProgram;
- break;
-
- default:
- throw new RuntimeException("Filter Duotone does not support frames of " +
- "target " + target + "!");
- }
- mTarget = target;
- }
-
- @Override
- public void process(FilterContext context) {
- // Get input frame
- Frame input = pullInput("image");
- FrameFormat inputFormat = input.getFormat();
-
- // Create output frame
- Frame output = context.getFrameManager().newFrame(inputFormat);
-
- // Create program if not created already
- if (mProgram == null || inputFormat.getTarget() != mTarget) {
- initProgram(context, inputFormat.getTarget());
- }
- updateParameters();
-
- // Process
- mProgram.process(input, output);
-
- // Push output
- pushOutput("image", output);
-
- // Release pushed frame
- output.release();
- }
-
- private void updateParameters() {
- float first[] = { Color.red(mFirstColor)/255f,
- Color.green(mFirstColor)/255f,
- Color.blue(mFirstColor)/255f };
- float second[] = { Color.red(mSecondColor)/255f,
- Color.green(mSecondColor)/255f,
- Color.blue(mSecondColor)/255f };
-
- mProgram.setHostValue("first", first);
- mProgram.setHostValue("second", second);
- }
-}
+++ /dev/null
-/*
- * 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.filterpacks.imageproc;
-
-import android.filterfw.core.Filter;
-import android.filterfw.core.FilterContext;
-import android.filterfw.core.Frame;
-import android.filterfw.core.FrameFormat;
-import android.filterfw.core.GenerateFieldPort;
-import android.filterfw.core.GenerateFinalPort;
-import android.filterfw.core.KeyValueMap;
-import android.filterfw.core.NativeProgram;
-import android.filterfw.core.NativeFrame;
-import android.filterfw.core.Program;
-import android.filterfw.core.ShaderProgram;
-import android.filterfw.format.ImageFormat;
-
-import android.util.Log;
-
-public class FillLightFilter extends Filter {
-
- @GenerateFieldPort(name = "tile_size", hasDefault = true)
- private int mTileSize = 640;
-
- @GenerateFieldPort(name = "strength", hasDefault = true)
- private float mBacklight = 0f;
-
- private Program mProgram;
-
- private int mTarget = FrameFormat.TARGET_UNSPECIFIED;
-
- private final String mFillLightShader =
- "precision mediump float;\n" +
- "uniform sampler2D tex_sampler_0;\n" +
- "uniform float mult;\n" +
- "uniform float igamma;\n" +
- "varying vec2 v_texcoord;\n" +
- "void main()\n" +
- "{\n" +
- " const vec3 color_weights = vec3(0.25, 0.5, 0.25);\n" +
- " vec4 color = texture2D(tex_sampler_0, v_texcoord);\n" +
- " float lightmask = dot(color.rgb, color_weights);\n" +
- " float backmask = (1.0 - lightmask);\n" +
- " vec3 ones = vec3(1.0, 1.0, 1.0);\n" +
- " vec3 diff = pow(mult * color.rgb, igamma * ones) - color.rgb;\n" +
- " diff = min(diff, 1.0);\n" +
- " vec3 new_color = min(color.rgb + diff * backmask, 1.0);\n" +
- " gl_FragColor = vec4(new_color, color.a);\n" +
- "}\n";
-
- public FillLightFilter(String name) {
- super(name);
- }
-
- @Override
- public void setupPorts() {
- addMaskedInputPort("image", ImageFormat.create(ImageFormat.COLORSPACE_RGBA));
- addOutputBasedOnInput("image", "image");
- }
-
- @Override
- public FrameFormat getOutputFormat(String portName, FrameFormat inputFormat) {
- return inputFormat;
- }
-
- public void initProgram(FilterContext context, int target) {
- switch (target) {
- case FrameFormat.TARGET_GPU:
- ShaderProgram shaderProgram = new ShaderProgram(context, mFillLightShader);
- Log.e("FillLight", "tile size: " + mTileSize);
- shaderProgram.setMaximumTileSize(mTileSize);
- mProgram = shaderProgram;
- break;
-
- default:
- throw new RuntimeException("Filter FillLight does not support frames of " +
- "target " + target + "!");
- }
- mTarget = target;
- }
-
-
- @Override
- public void process(FilterContext context) {
- // Get input frame
- Frame input = pullInput("image");
- FrameFormat inputFormat = input.getFormat();
-
- // Create output frame
- Frame output = context.getFrameManager().newFrame(inputFormat);
-
- // Create program if not created already
- if (mProgram == null || inputFormat.getTarget() != mTarget) {
- initProgram(context, inputFormat.getTarget());
- updateParameters();
- }
-
- // Process
- mProgram.process(input, output);
-
- // Push output
- pushOutput("image", output);
-
- // Release pushed frame
- output.release();
- }
-
-
- @Override
- public void fieldPortValueUpdated(String name, FilterContext context) {
- if (mProgram != null) {
- updateParameters();
- }
- }
-
- private void updateParameters() {
- float fade_gamma = 0.3f;
- float amt = 1.0f - mBacklight;
- float mult = 1.0f / (amt * 0.7f + 0.3f);
- float faded = fade_gamma + (1.0f -fade_gamma) *mult;
- float igamma = 1.0f / faded;
-
- mProgram.setHostValue("mult", mult);
- mProgram.setHostValue("igamma", igamma);
- }
-}
+++ /dev/null
-/*
- * 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.filterpacks.imageproc;
-
-import android.filterfw.core.Filter;
-import android.filterfw.core.FilterContext;
-import android.filterfw.core.Frame;
-import android.filterfw.core.FrameFormat;
-import android.filterfw.core.GenerateFieldPort;
-import android.filterfw.core.KeyValueMap;
-import android.filterfw.core.NativeProgram;
-import android.filterfw.core.NativeFrame;
-import android.filterfw.core.Program;
-import android.filterfw.core.ShaderProgram;
-import android.filterfw.format.ImageFormat;
-
-import android.util.Log;
-
-import java.lang.Math;
-import java.util.Set;
-
-/**
- * @hide
- */
-public class FisheyeFilter extends Filter {
- private static final String TAG = "FisheyeFilter";
-
- // This parameter has range between 0 and 1. It controls the effect of radial distortion.
- // The larger the value, the more prominent the distortion effect becomes (a straight line
- // becomes a curve).
- @GenerateFieldPort(name = "scale", hasDefault = true)
- private float mScale = 0f;
-
- @GenerateFieldPort(name = "tile_size", hasDefault = true)
- private int mTileSize = 640;
-
- private Program mProgram;
-
- private int mWidth = 0;
- private int mHeight = 0;
- private int mTarget = FrameFormat.TARGET_UNSPECIFIED;
-
- private static final String mFisheyeShader =
- "precision mediump float;\n" +
- "uniform sampler2D tex_sampler_0;\n" +
- "uniform vec2 center;\n" +
- "uniform float alpha;\n" +
- "uniform float bound;\n" +
- "uniform float radius2;\n" +
- "uniform float factor;\n" +
- "uniform float inv_height;\n" +
- "uniform float inv_width;\n" +
- "varying vec2 v_texcoord;\n" +
- "void main() {\n" +
- " const float m_pi_2 = 1.570963;\n" +
- " float dist = distance(gl_FragCoord.xy, center);\n" +
- " float radian = m_pi_2 - atan(alpha * sqrt(radius2 - dist * dist), dist);\n" +
- " float scale = radian * factor / dist;\n" +
- " vec2 new_coord = gl_FragCoord.xy * scale + (1.0 - scale) * center;\n" +
- " new_coord.x *= inv_width;\n" +
- " new_coord.y *= inv_height;\n" +
- " vec4 color = texture2D(tex_sampler_0, new_coord);\n" +
- " gl_FragColor = color;\n" +
- "}\n";
-
- public FisheyeFilter(String name) {
- super(name);
- }
-
- @Override
- public void setupPorts() {
- addMaskedInputPort("image", ImageFormat.create(ImageFormat.COLORSPACE_RGBA));
- addOutputBasedOnInput("image", "image");
- }
-
- @Override
- public FrameFormat getOutputFormat(String portName, FrameFormat inputFormat) {
- return inputFormat;
- }
-
- public void initProgram(FilterContext context, int target) {
- switch (target) {
- case FrameFormat.TARGET_GPU:
- ShaderProgram shaderProgram = new ShaderProgram(context, mFisheyeShader);
- shaderProgram.setMaximumTileSize(mTileSize);
- mProgram = shaderProgram;
- break;
-
- default:
- throw new RuntimeException("Filter FisheyeFilter does not support frames of " +
- "target " + target + "!");
- }
- mTarget = target;
- }
-
- @Override
- public void process(FilterContext context) {
- // Get input frame
- Frame input = pullInput("image");
- FrameFormat inputFormat = input.getFormat();
-
- // Create output frame
- Frame output = context.getFrameManager().newFrame(inputFormat);
-
- // Create program if not created already
- if (mProgram == null || inputFormat.getTarget() != mTarget) {
- initProgram(context, inputFormat.getTarget());
- }
-
- // Check if the frame size has changed
- if (inputFormat.getWidth() != mWidth || inputFormat.getHeight() != mHeight) {
- updateFrameSize(inputFormat.getWidth(), inputFormat.getHeight());
- }
-
- // Process
- mProgram.process(input, output);
-
- // Push output
- pushOutput("image", output);
-
- // Release pushed frame
- output.release();
- }
-
- @Override
- public void fieldPortValueUpdated(String name, FilterContext context) {
- if (mProgram != null) {
- updateProgramParams();
- }
- }
-
- private void updateFrameSize(int width, int height) {
- float center[] = {0.5f * width, 0.5f * height};
-
- mProgram.setHostValue("center", center);
- mProgram.setHostValue("inv_width", 1.0f / width);
- mProgram.setHostValue("inv_height", 1.0f / height);
-
- mWidth = width;
- mHeight = height;
-
- updateProgramParams();
- }
-
- private void updateProgramParams() {
- final float pi = 3.14159265f;
-
- float alpha = mScale * 2.0f + 0.75f;
- float bound2 = 0.25f * (mWidth * mWidth + mHeight * mHeight);
- float bound = (float) Math.sqrt(bound2);
- float radius = 1.15f * bound;
- float radius2 = radius * radius;
- float max_radian = 0.5f * pi -
- (float) Math.atan(alpha / bound * (float) Math.sqrt(radius2 - bound2));
- float factor = bound / max_radian;
-
- mProgram.setHostValue("radius2",radius2);
- mProgram.setHostValue("factor", factor);
- mProgram.setHostValue("alpha", (float) (mScale * 2.0 + 0.75));
- }
-
-
-}
+++ /dev/null
-/*
- * 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.filterpacks.imageproc;
-
-import android.filterfw.core.Filter;
-import android.filterfw.core.FilterContext;
-import android.filterfw.core.Frame;
-import android.filterfw.core.FrameFormat;
-import android.filterfw.core.GenerateFieldPort;
-import android.filterfw.core.MutableFrameFormat;
-import android.filterfw.core.Program;
-import android.filterfw.core.ShaderProgram;
-import android.filterfw.format.ImageFormat;
-import android.filterfw.geometry.Point;
-import android.filterfw.geometry.Quad;
-
-/**
- * The FixedRotationFilter rotates the input image clockwise, it only accepts
- * 4 rotation angles: 0, 90, 180, 270
- * @hide
- */
-public class FixedRotationFilter extends Filter {
-
- @GenerateFieldPort(name = "rotation", hasDefault = true)
- private int mRotation = 0;
-
- private ShaderProgram mProgram = null;
-
- public FixedRotationFilter(String name) {
- super(name);
- }
-
- @Override
- public void setupPorts() {
- addMaskedInputPort("image", ImageFormat.create(ImageFormat.COLORSPACE_RGBA,
- FrameFormat.TARGET_GPU));
- addOutputBasedOnInput("image", "image");
- }
-
- @Override
- public FrameFormat getOutputFormat(String portName, FrameFormat inputFormat) {
- return inputFormat;
- }
-
- @Override
- public void process(FilterContext context) {
- Frame input = pullInput("image");
- if (mRotation == 0) {
- pushOutput("image", input);
- return;
- }
- FrameFormat inputFormat = input.getFormat();
-
- // Create program if not created already
- if (mProgram == null) {
- mProgram = ShaderProgram.createIdentity(context);
- }
- MutableFrameFormat outputFormat = inputFormat.mutableCopy();
- int width = inputFormat.getWidth();
- int height = inputFormat.getHeight();
- Point p1 = new Point(0.0f, 0.0f);
- Point p2 = new Point(1.0f, 0.0f);
- Point p3 = new Point(0.0f, 1.0f);
- Point p4 = new Point(1.0f, 1.0f);
- Quad sourceRegion;
- switch (((int)Math.round(mRotation / 90f)) % 4) {
- case 1:
- sourceRegion = new Quad(p3,p1,p4,p2);
- outputFormat.setDimensions(height, width);
- break;
- case 2:
- sourceRegion = new Quad(p4,p3,p2,p1);
- break;
- case 3:
- sourceRegion = new Quad(p2,p4,p1,p3);
- outputFormat.setDimensions(height, width);
- break;
- case 0:
- default:
- sourceRegion = new Quad(p1,p2,p3,p4);
- break;
- }
- // Create output frame
- Frame output = context.getFrameManager().newFrame(outputFormat);
-
- // Set the source region
- mProgram.setSourceRegion(sourceRegion);
-
- // Process
- mProgram.process(input, output);
-
- // Push output
- pushOutput("image", output);
-
- // Release pushed frame
- output.release();
- }
-}
+++ /dev/null
-/*
- * 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.filterpacks.imageproc;
-
-import android.filterfw.core.Filter;
-import android.filterfw.core.FilterContext;
-import android.filterfw.core.Frame;
-import android.filterfw.core.FrameFormat;
-import android.filterfw.core.GenerateFieldPort;
-import android.filterfw.core.KeyValueMap;
-import android.filterfw.core.MutableFrameFormat;
-import android.filterfw.core.NativeProgram;
-import android.filterfw.core.NativeFrame;
-import android.filterfw.core.Program;
-import android.filterfw.core.ShaderProgram;
-import android.filterfw.format.ImageFormat;
-
-/**
- * @hide
- */
-public class FlipFilter extends Filter {
-
- @GenerateFieldPort(name = "vertical", hasDefault = true)
- private boolean mVertical = false;
-
- @GenerateFieldPort(name = "horizontal", hasDefault = true)
- private boolean mHorizontal = false;
-
- @GenerateFieldPort(name = "tile_size", hasDefault = true)
- private int mTileSize = 640;
-
- private Program mProgram;
- private int mTarget = FrameFormat.TARGET_UNSPECIFIED;
-
- public FlipFilter(String name) {
- super(name);
- }
-
- @Override
- public void setupPorts() {
- addMaskedInputPort("image", ImageFormat.create(ImageFormat.COLORSPACE_RGBA));
- addOutputBasedOnInput("image", "image");
- }
-
- @Override
- public FrameFormat getOutputFormat(String portName, FrameFormat inputFormat) {
- return inputFormat;
- }
-
- public void initProgram(FilterContext context, int target) {
- switch (target) {
- case FrameFormat.TARGET_GPU:
- ShaderProgram shaderProgram = ShaderProgram.createIdentity(context);
- shaderProgram.setMaximumTileSize(mTileSize);
- mProgram = shaderProgram;
- break;
-
- default:
- throw new RuntimeException("Filter Sharpen does not support frames of " +
- "target " + target + "!");
- }
- mTarget = target;
- updateParameters();
- }
-
- @Override
- public void fieldPortValueUpdated(String name, FilterContext context) {
- if (mProgram != null) {
- updateParameters();
- }
- }
-
- @Override
- public void process(FilterContext context) {
- // Get input frame
- Frame input = pullInput("image");
- FrameFormat inputFormat = input.getFormat();
-
- // Create program if not created already
- if (mProgram == null || inputFormat.getTarget() != mTarget) {
- initProgram(context, inputFormat.getTarget());
- }
-
- // Create output frame
- Frame output = context.getFrameManager().newFrame(inputFormat);
-
- // Process
- mProgram.process(input, output);
-
- // Push output
- pushOutput("image", output);
-
- // Release pushed frame
- output.release();
- }
-
- private void updateParameters() {
- float x_origin = (mHorizontal) ? 1.0f : 0.0f;
- float y_origin = (mVertical) ? 1.0f : 0.0f;
-
- float width = (mHorizontal) ? -1.0f : 1.0f;
- float height = (mVertical) ? -1.0f : 1.0f;
-
- ((ShaderProgram) mProgram).setSourceRect(x_origin, y_origin, width, height);
- }
-}
+++ /dev/null
-/*
- * 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.filterpacks.imageproc;
-
-import android.filterfw.core.Filter;
-import android.filterfw.core.FilterContext;
-import android.filterfw.core.Frame;
-import android.filterfw.core.FrameFormat;
-import android.filterfw.core.GenerateFieldPort;
-import android.filterfw.core.KeyValueMap;
-import android.filterfw.core.NativeProgram;
-import android.filterfw.core.NativeFrame;
-import android.filterfw.core.Program;
-import android.filterfw.core.ShaderProgram;
-import android.filterfw.format.ImageFormat;
-import android.filterfw.geometry.Quad;
-import android.filterfw.geometry.Point;
-
-import java.util.Random;
-
-public class GrainFilter extends Filter {
-
- private static final int RAND_THRESHOLD = 128;
-
- @GenerateFieldPort(name = "strength", hasDefault = true)
- private float mScale = 0f;
-
- @GenerateFieldPort(name = "tile_size", hasDefault = true)
- private int mTileSize = 640;
-
- private Program mProgram;
-
- private int mWidth = 0;
- private int mHeight = 0;
- private int mTarget = FrameFormat.TARGET_UNSPECIFIED;
-
- private Frame mNoiseFrame = null;
- private Random mRandom;
-
- private final String mGrainShader =
- "precision mediump float;\n" +
- "uniform sampler2D tex_sampler_0;\n" +
- "uniform sampler2D tex_sampler_1;\n" +
- "uniform float scale;\n" +
- "uniform float stepX;\n" +
- "uniform float stepY;\n" +
- "varying vec2 v_texcoord;\n" +
- "void main() {\n" +
- " float noise = texture2D(tex_sampler_1, v_texcoord + vec2(-stepX, -stepY)).r * 0.224;\n" +
- " noise += texture2D(tex_sampler_1, v_texcoord + vec2(-stepX, stepY)).r * 0.224;\n" +
- " noise += texture2D(tex_sampler_1, v_texcoord + vec2(stepX, -stepY)).r * 0.224;\n" +
- " noise += texture2D(tex_sampler_1, v_texcoord + vec2(stepX, stepY)).r * 0.224;\n" +
- " noise += 0.4448;\n" +
- " noise *= scale;\n" +
- " vec4 color = texture2D(tex_sampler_0, v_texcoord);\n" +
- " float energy = 0.33333 * color.r + 0.33333 * color.g + 0.33333 * color.b;\n" +
- " float mask = (1.0 - sqrt(energy));\n" +
- " float weight = 1.0 - 1.333 * mask * noise;\n" +
- " gl_FragColor = vec4(color.rgb * weight, color.a);\n" +
- "}\n";
-
- public GrainFilter(String name) {
- super(name);
-
- mRandom = new Random();
- }
-
- @Override
- public void setupPorts() {
- addMaskedInputPort("image", ImageFormat.create(ImageFormat.COLORSPACE_RGBA));
- addOutputBasedOnInput("image", "image");
- }
-
- @Override
- public FrameFormat getOutputFormat(String portName, FrameFormat inputFormat) {
- return inputFormat;
- }
-
- public void initProgram(FilterContext context, int target) {
- switch (target) {
- case FrameFormat.TARGET_GPU:
- ShaderProgram shaderProgram = new ShaderProgram(context, mGrainShader);
- shaderProgram.setMaximumTileSize(mTileSize);
- mProgram = shaderProgram;
- break;
-
- default:
- throw new RuntimeException("Filter Sharpen does not support frames of " +
- "target " + target + "!");
- }
- mTarget = target;
- }
-
- private void updateParameters() {
- mProgram.setHostValue("scale", mScale);
- }
-
- private void updateFrameSize(int width, int height) {
- mWidth = width;
- mHeight = height;
-
- if (mProgram != null) {
- mProgram.setHostValue("stepX", 0.5f / mWidth);
- mProgram.setHostValue("stepY", 0.5f / mHeight);
- updateParameters();
- }
- }
-
- @Override
- public void fieldPortValueUpdated(String name, FilterContext context) {
- if (mProgram != null) {
- updateParameters();
- }
- }
-
- @Override
- public void tearDown(FilterContext context) {
- if (mNoiseFrame != null) {
- mNoiseFrame.release();
- mNoiseFrame = null;
- }
- }
-
- @Override
- public void process(FilterContext context) {
- // Get input frame
- Frame input = pullInput("image");
- FrameFormat inputFormat = input.getFormat();
-
- // Create output frame
- Frame output = context.getFrameManager().newFrame(inputFormat);
-
- // Create program if not created already
- if (mProgram == null || inputFormat.getTarget() != mTarget) {
- initProgram(context, inputFormat.getTarget());
- updateParameters();
- }
-
- // Check if the frame size has changed
- if (inputFormat.getWidth() != mWidth || inputFormat.getHeight() != mHeight) {
- updateFrameSize(inputFormat.getWidth(), inputFormat.getHeight());
-
- int[] buffer = new int[mWidth * mHeight];
- for (int i = 0; i < mWidth * mHeight; ++i) {
- buffer[i] = (mRandom.nextInt(256) < RAND_THRESHOLD) ?
- mRandom.nextInt(256) : 0;
- }
- FrameFormat format = ImageFormat.create(mWidth, mHeight,
- ImageFormat.COLORSPACE_RGBA,
- FrameFormat.TARGET_GPU);
- if (mNoiseFrame != null) {
- mNoiseFrame.release();
- }
- mNoiseFrame = context.getFrameManager().newFrame(format);
- mNoiseFrame.setInts(buffer);
- }
-
- if (mNoiseFrame.getFormat().getWidth() != mWidth ||
- mNoiseFrame.getFormat().getHeight() != mHeight) {
- throw new RuntimeException("Random map and imput image size mismatch!");
- }
-
- // Process
- Frame[] inputs = {input, mNoiseFrame};
- mProgram.process(inputs, output);
-
- // Push output
- pushOutput("image", output);
-
- // Release pushed frame
- output.release();
- }
-}
+++ /dev/null
-/*
- * 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.filterpacks.imageproc;
-
-import android.filterfw.core.Filter;
-import android.filterfw.core.FilterContext;
-import android.filterfw.core.Frame;
-import android.filterfw.core.FrameFormat;
-import android.filterfw.core.KeyValueMap;
-import android.filterfw.core.NativeProgram;
-import android.filterfw.core.NativeFrame;
-import android.filterfw.core.Program;
-import android.filterfw.core.ShaderProgram;
-import android.filterfw.format.ImageFormat;
-
-import java.lang.reflect.Field;
-import java.util.HashSet;
-import java.util.Set;
-
-/**
- * @hide
- */
-public abstract class ImageCombineFilter extends Filter {
-
- protected Program mProgram;
- protected String[] mInputNames;
- protected String mOutputName;
- protected String mParameterName;
- protected int mCurrentTarget = FrameFormat.TARGET_UNSPECIFIED;
-
- public ImageCombineFilter(String name,
- String[] inputNames,
- String outputName,
- String parameterName) {
- super(name);
- mInputNames = inputNames;
- mOutputName = outputName;
- mParameterName = parameterName;
- }
-
- @Override
- public void setupPorts() {
- if (mParameterName != null) {
- try {
- Field programField = ImageCombineFilter.class.getDeclaredField("mProgram");
- addProgramPort(mParameterName, mParameterName, programField, float.class, false);
- } catch (NoSuchFieldException e) {
- throw new RuntimeException("Internal Error: mProgram field not found!");
- }
- }
- for (String inputName : mInputNames) {
- addMaskedInputPort(inputName, ImageFormat.create(ImageFormat.COLORSPACE_RGBA));
- }
- addOutputBasedOnInput(mOutputName, mInputNames[0]);
- }
-
- @Override
- public FrameFormat getOutputFormat(String portName, FrameFormat inputFormat) {
- return inputFormat;
- }
-
- private void assertAllInputTargetsMatch() {
- int target = getInputFormat(mInputNames[0]).getTarget();
- for (String inputName : mInputNames) {
- if (target != getInputFormat(inputName).getTarget()) {
- throw new RuntimeException("Type mismatch of input formats in filter " + this
- + ". All input frames must have the same target!");
- }
- }
- }
-
- @Override
- public void process(FilterContext context) {
- // Pull input frames
- int i = 0;
- Frame[] inputs = new Frame[mInputNames.length];
- for (String inputName : mInputNames) {
- inputs[i++] = pullInput(inputName);
- }
-
- // Create output frame
- Frame output = context.getFrameManager().newFrame(inputs[0].getFormat());
-
- // Make sure we have a program
- updateProgramWithTarget(inputs[0].getFormat().getTarget(), context);
-
- // Process
- mProgram.process(inputs, output);
-
- // Push output
- pushOutput(mOutputName, output);
-
- // Release pushed frame
- output.release();
- }
-
- protected void updateProgramWithTarget(int target, FilterContext context) {
- if (target != mCurrentTarget) {
- switch (target) {
- case FrameFormat.TARGET_NATIVE:
- mProgram = getNativeProgram(context);
- break;
-
- case FrameFormat.TARGET_GPU:
- mProgram = getShaderProgram(context);
- break;
-
- default:
- mProgram = null;
- break;
- }
- if (mProgram == null) {
- throw new RuntimeException("Could not create a program for image filter "
- + this + "!");
- }
- initProgramInputs(mProgram, context);
- mCurrentTarget = target;
- }
- }
-
- protected abstract Program getNativeProgram(FilterContext context);
-
- protected abstract Program getShaderProgram(FilterContext context);
-}
+++ /dev/null
-/*
- * 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.filterpacks.imageproc;
-
-import android.content.Context;
-import android.filterfw.core.Filter;
-import android.filterfw.core.FilterContext;
-import android.filterfw.core.Frame;
-import android.filterfw.core.FrameFormat;
-import android.filterfw.core.GenerateFieldPort;
-import android.filterfw.core.KeyValueMap;
-import android.filterfw.format.ImageFormat;
-import android.graphics.Bitmap;
-import android.graphics.Bitmap.CompressFormat;
-
-import android.util.Log;
-
-import java.io.OutputStream;
-import java.io.IOException;
-
-/**
- * @hide
- */
-public class ImageEncoder extends Filter {
-
- @GenerateFieldPort(name = "stream")
- private OutputStream mOutputStream;
-
- @GenerateFieldPort(name = "quality", hasDefault = true)
- private int mQuality = 80;
-
- public ImageEncoder(String name) {
- super(name);
- }
-
- @Override
- public void setupPorts() {
- addMaskedInputPort("image", ImageFormat.create(ImageFormat.COLORSPACE_RGBA,
- FrameFormat.TARGET_UNSPECIFIED));
- }
-
- @Override
- public void process(FilterContext env) {
- Frame input = pullInput("image");
- Bitmap bitmap = input.getBitmap();
- bitmap.compress(CompressFormat.JPEG, mQuality, mOutputStream);
- }
-
-}
+++ /dev/null
-/*
- * 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.filterpacks.imageproc;
-
-import android.filterfw.core.Filter;
-import android.filterfw.core.FilterContext;
-import android.filterfw.core.Frame;
-import android.filterfw.core.FrameFormat;
-import android.filterfw.core.FrameManager;
-import android.filterfw.core.GenerateFieldPort;
-import android.filterfw.core.KeyValueMap;
-import android.filterfw.core.MutableFrameFormat;
-import android.filterfw.core.Program;
-import android.filterfw.core.ShaderProgram;
-import android.filterfw.format.ImageFormat;
-
-public class ImageSlicer extends Filter {
-
- @GenerateFieldPort(name = "xSlices")
- private int mXSlices;
-
- @GenerateFieldPort(name = "ySlices")
- private int mYSlices;
-
- @GenerateFieldPort(name = "padSize")
- private int mPadSize;
-
- // The current slice index from 0 to xSlices * ySlices
- private int mSliceIndex;
-
- private Frame mOriginalFrame;
-
- private Program mProgram;
-
- private int mInputWidth;
- private int mInputHeight;
-
- private int mSliceWidth;
- private int mSliceHeight;
-
- private int mOutputWidth;
- private int mOutputHeight;
-
- public ImageSlicer(String name) {
- super(name);
- mSliceIndex = 0;
- }
-
- @Override
- public void setupPorts() {
- addMaskedInputPort("image", ImageFormat.create(ImageFormat.COLORSPACE_RGBA,
- FrameFormat.TARGET_GPU));
- addOutputBasedOnInput("image", "image");
- }
-
- @Override
- public FrameFormat getOutputFormat(String portName, FrameFormat inputFormat) {
- return inputFormat;
- }
-
- private void calcOutputFormatForInput(Frame frame) {
-
- // calculate the output size based on input size, xSlices, and ySlices
- mInputWidth = frame.getFormat().getWidth();
- mInputHeight = frame.getFormat().getHeight();
-
- mSliceWidth = (mInputWidth + mXSlices - 1) / mXSlices;
- mSliceHeight = (mInputHeight + mYSlices - 1)/ mYSlices;
-
- mOutputWidth = mSliceWidth + mPadSize * 2;
- mOutputHeight = mSliceHeight + mPadSize * 2;
- }
-
-
- @Override
- public void process(FilterContext context) {
-
- // Get input frame
- if (mSliceIndex == 0) {
- mOriginalFrame = pullInput("image");
- calcOutputFormatForInput(mOriginalFrame);
- }
-
- FrameFormat inputFormat = mOriginalFrame.getFormat();
- MutableFrameFormat outputFormat = inputFormat.mutableCopy();
- outputFormat.setDimensions(mOutputWidth, mOutputHeight);
-
- // Create output frame
- Frame output = context.getFrameManager().newFrame(outputFormat);
-
- // Create the program if not created already
- if (mProgram == null) {
- mProgram = ShaderProgram.createIdentity(context);
- }
-
- // Calculate the four corner of the source region
- int xSliceIndex = mSliceIndex % mXSlices;
- int ySliceIndex = mSliceIndex / mXSlices;
-
- // TODO(rslin) : not sure shifting by 0.5 is needed.
- float x0 = (xSliceIndex * mSliceWidth - mPadSize) / ((float) mInputWidth);
- float y0 = (ySliceIndex * mSliceHeight - mPadSize) / ((float) mInputHeight);
-
- ((ShaderProgram) mProgram).setSourceRect(x0, y0,
- ((float) mOutputWidth) / mInputWidth,
- ((float) mOutputHeight) / mInputHeight);
-
- // Process
- mProgram.process(mOriginalFrame, output);
- mSliceIndex++;
-
- if (mSliceIndex == mXSlices * mYSlices) {
- mSliceIndex = 0;
- mOriginalFrame.release();
- setWaitsOnInputPort("image", true);
- } else {
- // Retain the original frame so it can be used next time.
- mOriginalFrame.retain();
- setWaitsOnInputPort("image", false);
- }
-
- // Push output
- pushOutput("image", output);
-
- // Release pushed frame
- output.release();
- }
-}
+++ /dev/null
-/*
- * 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.filterpacks.imageproc;
-
-import android.filterfw.core.Filter;
-import android.filterfw.core.FilterContext;
-import android.filterfw.core.Frame;
-import android.filterfw.core.FrameFormat;
-import android.filterfw.core.FrameManager;
-import android.filterfw.core.GenerateFieldPort;
-import android.filterfw.core.KeyValueMap;
-import android.filterfw.core.MutableFrameFormat;
-import android.filterfw.core.Program;
-import android.filterfw.core.ShaderProgram;
-import android.filterfw.format.ImageFormat;
-
-import android.util.Log;
-
-public class ImageStitcher extends Filter {
-
- @GenerateFieldPort(name = "xSlices")
- private int mXSlices;
-
- @GenerateFieldPort(name = "ySlices")
- private int mYSlices;
-
- @GenerateFieldPort(name = "padSize")
- private int mPadSize;
-
- private Program mProgram;
- private Frame mOutputFrame;
-
- private int mInputWidth;
- private int mInputHeight;
-
- private int mImageWidth;
- private int mImageHeight;
-
- private int mSliceWidth;
- private int mSliceHeight;
-
- private int mSliceIndex;
-
- public ImageStitcher(String name) {
- super(name);
- mSliceIndex = 0;
- }
-
- @Override
- public void setupPorts() {
- addMaskedInputPort("image", ImageFormat.create(ImageFormat.COLORSPACE_RGBA,
- FrameFormat.TARGET_GPU));
- addOutputBasedOnInput("image", "image");
- }
-
- @Override
- public FrameFormat getOutputFormat(String portName, FrameFormat inputFormat) {
- return inputFormat;
- }
-
- private FrameFormat calcOutputFormatForInput(FrameFormat format) {
- MutableFrameFormat outputFormat = format.mutableCopy();
-
- mInputWidth = format.getWidth();
- mInputHeight = format.getHeight();
-
- mSliceWidth = mInputWidth - 2 * mPadSize;
- mSliceHeight = mInputHeight - 2 * mPadSize;
-
- mImageWidth = mSliceWidth * mXSlices;
- mImageHeight = mSliceHeight * mYSlices;
-
- outputFormat.setDimensions(mImageWidth, mImageHeight);
- return outputFormat;
- }
-
- @Override
- public void process(FilterContext context) {
- // Get input frame
- Frame input = pullInput("image");
- FrameFormat format = input.getFormat();
-
- // Create output frame
- if (mSliceIndex == 0) {
- mOutputFrame = context.getFrameManager().newFrame(calcOutputFormatForInput(format));
- } else {
- if ((format.getWidth() != mInputWidth) ||
- (format.getHeight() != mInputHeight)) {
- // CHECK input format here
- throw new RuntimeException("Image size should not change.");
- }
- }
-
- // Create the program if not created already
- if (mProgram == null) {
- mProgram = ShaderProgram.createIdentity(context);
- }
-
- // TODO(rslin) : not sure shifting by 0.5 is needed.
- float x0 = ((float) mPadSize) / mInputWidth;
- float y0 = ((float) mPadSize) / mInputHeight;
-
- int outputOffsetX = (mSliceIndex % mXSlices) * mSliceWidth;
- int outputOffsetY = (mSliceIndex / mXSlices) * mSliceHeight;
-
- float outputWidth = (float) Math.min(mSliceWidth, mImageWidth - outputOffsetX);
- float outputHeight = (float) Math.min(mSliceHeight, mImageHeight - outputOffsetY);
-
- // We need to set the source rect as well because the input are padded images.
- ((ShaderProgram) mProgram).setSourceRect(x0, y0,
- outputWidth / mInputWidth,
- outputHeight / mInputHeight);
-
- ((ShaderProgram) mProgram).setTargetRect(((float) outputOffsetX)/ mImageWidth,
- ((float) outputOffsetY) / mImageHeight,
- outputWidth / mImageWidth,
- outputHeight / mImageHeight);
-
- // Process this tile
- mProgram.process(input, mOutputFrame);
- mSliceIndex++;
-
- // Push output
- if (mSliceIndex == mXSlices * mYSlices) {
- pushOutput("image", mOutputFrame);
- mOutputFrame.release();
- mSliceIndex = 0;
- }
- }
-}
+++ /dev/null
-/*
- * 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.filterpacks.imageproc;
-
-import android.filterfw.core.Filter;
-import android.filterfw.core.FilterContext;
-import android.filterfw.core.Frame;
-import android.filterfw.core.FrameFormat;
-import android.filterfw.core.NativeProgram;
-import android.filterfw.core.NativeFrame;
-import android.filterfw.core.Program;
-import android.filterfw.core.ShaderProgram;
-
-/**
- * @hide
- */
-public class Invert extends SimpleImageFilter {
-
- private static final String mInvertShader =
- "precision mediump float;\n" +
- "uniform sampler2D tex_sampler_0;\n" +
- "varying vec2 v_texcoord;\n" +
- "void main() {\n" +
- " vec4 color = texture2D(tex_sampler_0, v_texcoord);\n" +
- " gl_FragColor.r = 1.0 - color.r;\n" +
- " gl_FragColor.g = 1.0 - color.g;\n" +
- " gl_FragColor.b = 1.0 - color.b;\n" +
- " gl_FragColor.a = color.a;\n" +
- "}\n";
-
- public Invert(String name) {
- super(name, null);
- }
-
- @Override
- protected Program getNativeProgram(FilterContext context) {
- return new NativeProgram("filterpack_imageproc", "invert");
- }
-
- @Override
- protected Program getShaderProgram(FilterContext context) {
- return new ShaderProgram(context, mInvertShader);
- }
-
-}
+++ /dev/null
-/*
- * 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.filterpacks.imageproc;
-
-import android.filterfw.core.Filter;
-import android.filterfw.core.FilterContext;
-import android.filterfw.core.Frame;
-import android.filterfw.core.FrameFormat;
-import android.filterfw.core.GenerateFieldPort;
-import android.filterfw.core.KeyValueMap;
-import android.filterfw.core.NativeProgram;
-import android.filterfw.core.NativeFrame;
-import android.filterfw.core.Program;
-import android.filterfw.core.ShaderProgram;
-import android.filterfw.format.ImageFormat;
-
-import java.util.Random;
-
-public class LomoishFilter extends Filter {
-
- @GenerateFieldPort(name = "tile_size", hasDefault = true)
- private int mTileSize = 640;
-
- private Program mProgram;
-
- private int mWidth = 0;
- private int mHeight = 0;
- private int mTarget = FrameFormat.TARGET_UNSPECIFIED;
-
- private Frame mNoiseFrame;
- private Random mRandom;
-
- private final String mLomoishShader =
- "precision mediump float;\n" +
- "uniform sampler2D tex_sampler_0;\n" +
- "uniform sampler2D tex_sampler_1;\n" +
- "uniform float stepsizeX;\n" +
- "uniform float stepsizeY;\n" +
- "uniform float stepsize;\n" +
- "uniform vec2 center;\n" +
- "uniform float inv_max_dist;\n" +
- "varying vec2 v_texcoord;\n" +
- "void main() {\n" +
- // sharpen
- " vec3 nbr_color = vec3(0.0, 0.0, 0.0);\n" +
- " vec2 coord;\n" +
- " vec4 color = texture2D(tex_sampler_0, v_texcoord);\n" +
- " coord.x = v_texcoord.x - 0.5 * stepsizeX;\n" +
- " coord.y = v_texcoord.y - stepsizeY;\n" +
- " nbr_color += texture2D(tex_sampler_0, coord).rgb - color.rgb;\n" +
- " coord.x = v_texcoord.x - stepsizeX;\n" +
- " coord.y = v_texcoord.y + 0.5 * stepsizeY;\n" +
- " nbr_color += texture2D(tex_sampler_0, coord).rgb - color.rgb;\n" +
- " coord.x = v_texcoord.x + stepsizeX;\n" +
- " coord.y = v_texcoord.y - 0.5 * stepsizeY;\n" +
- " nbr_color += texture2D(tex_sampler_0, coord).rgb - color.rgb;\n" +
- " coord.x = v_texcoord.x + stepsizeX;\n" +
- " coord.y = v_texcoord.y + 0.5 * stepsizeY;\n" +
- " nbr_color += texture2D(tex_sampler_0, coord).rgb - color.rgb;\n" +
- " vec3 s_color = vec3(color.rgb + 0.3 * nbr_color);\n" +
- // cross process
- " vec3 c_color = vec3(0.0, 0.0, 0.0);\n" +
- " float value;\n" +
- " if (s_color.r < 0.5) {\n" +
- " value = s_color.r;\n" +
- " } else {\n" +
- " value = 1.0 - s_color.r;\n" +
- " }\n" +
- " float red = 4.0 * value * value * value;\n" +
- " if (s_color.r < 0.5) {\n" +
- " c_color.r = red;\n" +
- " } else {\n" +
- " c_color.r = 1.0 - red;\n" +
- " }\n" +
- " if (s_color.g < 0.5) {\n" +
- " value = s_color.g;\n" +
- " } else {\n" +
- " value = 1.0 - s_color.g;\n" +
- " }\n" +
- " float green = 2.0 * value * value;\n" +
- " if (s_color.g < 0.5) {\n" +
- " c_color.g = green;\n" +
- " } else {\n" +
- " c_color.g = 1.0 - green;\n" +
- " }\n" +
- " c_color.b = s_color.b * 0.5 + 0.25;\n" +
- // blackwhite
- " float dither = texture2D(tex_sampler_1, v_texcoord).r;\n" +
- " vec3 xform = clamp((c_color.rgb - 0.15) * 1.53846, 0.0, 1.0);\n" +
- " vec3 temp = clamp((color.rgb + stepsize - 0.15) * 1.53846, 0.0, 1.0);\n" +
- " vec3 bw_color = clamp(xform + (temp - xform) * (dither - 0.5), 0.0, 1.0);\n" +
- // vignette
- " float dist = distance(gl_FragCoord.xy, center);\n" +
- " float lumen = 0.85 / (1.0 + exp((dist * inv_max_dist - 0.73) * 20.0)) + 0.15;\n" +
- " gl_FragColor = vec4(bw_color * lumen, color.a);\n" +
- "}\n";
-
- public LomoishFilter(String name) {
- super(name);
-
- mRandom = new Random();
- }
-
- @Override
- public void setupPorts() {
- addMaskedInputPort("image", ImageFormat.create(ImageFormat.COLORSPACE_RGBA));
- addOutputBasedOnInput("image", "image");
- }
-
- @Override
- public FrameFormat getOutputFormat(String portName, FrameFormat inputFormat) {
- return inputFormat;
- }
-
- @Override
- public void tearDown(FilterContext context) {
- if (mNoiseFrame != null) {
- mNoiseFrame.release();
- mNoiseFrame = null;
- }
- }
-
- public void initProgram(FilterContext context, int target) {
- switch (target) {
- case FrameFormat.TARGET_GPU:
- ShaderProgram shaderProgram = new ShaderProgram(context, mLomoishShader);
- shaderProgram.setMaximumTileSize(mTileSize);
- mProgram = shaderProgram;
- break;
-
- default:
- throw new RuntimeException("Filter Sharpen does not support frames of " +
- "target " + target + "!");
- }
- mTarget = target;
- }
-
- private void initParameters() {
- if (mProgram !=null) {
- float centerX = (float) (0.5 * mWidth);
- float centerY = (float) (0.5 * mHeight);
- float center[] = {centerX, centerY};
- float max_dist = (float) Math.sqrt(centerX * centerX + centerY * centerY);
-
- mProgram.setHostValue("center", center);
- mProgram.setHostValue("inv_max_dist", 1.0f / max_dist);
-
- mProgram.setHostValue("stepsize", 1.0f / 255.0f);
- mProgram.setHostValue("stepsizeX", 1.0f / mWidth);
- mProgram.setHostValue("stepsizeY", 1.0f / mHeight);
- }
- }
-
- @Override
- public void process(FilterContext context) {
- // Get input frame
- Frame input = pullInput("image");
- FrameFormat inputFormat = input.getFormat();
-
- // Create program if not created already
- if (mProgram == null || inputFormat.getTarget() != mTarget) {
- initProgram(context, inputFormat.getTarget());
- }
-
- // Check if the frame size has changed
- if (inputFormat.getWidth() != mWidth || inputFormat.getHeight() != mHeight) {
- mWidth = inputFormat.getWidth();
- mHeight = inputFormat.getHeight();
-
- int[] buffer = new int[mWidth * mHeight];
- for (int i = 0; i < mWidth * mHeight; ++i) {
- buffer[i] = mRandom.nextInt(255);
- }
- FrameFormat format = ImageFormat.create(mWidth, mHeight,
- ImageFormat.COLORSPACE_RGBA,
- FrameFormat.TARGET_GPU);
- if (mNoiseFrame != null) {
- mNoiseFrame.release();
- }
- mNoiseFrame = context.getFrameManager().newFrame(format);
- mNoiseFrame.setInts(buffer);
-
- initParameters();
- }
-
- if (mNoiseFrame != null && (mNoiseFrame.getFormat().getWidth() != mWidth ||
- mNoiseFrame.getFormat().getHeight() != mHeight)) {
- throw new RuntimeException("Random map and imput image size mismatch!");
- }
-
- // Create output frame
- Frame output = context.getFrameManager().newFrame(inputFormat);
-
- // Process
- Frame[] inputs = {input, mNoiseFrame};
- mProgram.process(inputs, output);
-
- // Push output
- pushOutput("image", output);
-
- // Release pushed frame
- output.release();
- }
-}
+++ /dev/null
-/*
- * 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.filterpacks.imageproc;
-
-import android.filterfw.core.Filter;
-import android.filterfw.core.FilterContext;
-import android.filterfw.core.Frame;
-import android.filterfw.core.FrameFormat;
-import android.filterfw.core.GenerateFieldPort;
-import android.filterfw.core.KeyValueMap;
-import android.filterfw.core.NativeProgram;
-import android.filterfw.core.NativeFrame;
-import android.filterfw.core.Program;
-import android.filterfw.core.ShaderProgram;
-import android.filterfw.format.ImageFormat;
-
-
-public class NegativeFilter extends Filter {
-
- @GenerateFieldPort(name = "tile_size", hasDefault = true)
- private int mTileSize = 640;
-
- private Program mProgram;
- private int mTarget = FrameFormat.TARGET_UNSPECIFIED;
-
- private final String mNegativeShader =
- "precision mediump float;\n" +
- "uniform sampler2D tex_sampler_0;\n" +
- "varying vec2 v_texcoord;\n" +
- "void main() {\n" +
- " vec4 color = texture2D(tex_sampler_0, v_texcoord);\n" +
- " gl_FragColor = vec4(1.0 - color.rgb, color.a);\n" +
- "}\n";
-
- public NegativeFilter(String name) {
- super(name);
- }
-
- @Override
- public void setupPorts() {
- addMaskedInputPort("image", ImageFormat.create(ImageFormat.COLORSPACE_RGBA));
- addOutputBasedOnInput("image", "image");
- }
-
- @Override
- public FrameFormat getOutputFormat(String portName, FrameFormat inputFormat) {
- return inputFormat;
- }
-
- public void initProgram(FilterContext context, int target) {
- switch (target) {
- case FrameFormat.TARGET_GPU:
- ShaderProgram shaderProgram = new ShaderProgram(context, mNegativeShader);
- shaderProgram.setMaximumTileSize(mTileSize);
- mProgram = shaderProgram;
- break;
-
- default:
- throw new RuntimeException("Filter Sharpen does not support frames of " +
- "target " + target + "!");
- }
- mTarget = target;
- }
-
- @Override
- public void process(FilterContext context) {
- // Get input frame
- Frame input = pullInput("image");
- FrameFormat inputFormat = input.getFormat();
-
- // Create output frame
- Frame output = context.getFrameManager().newFrame(inputFormat);
-
- // Create program if not created already
- if (mProgram == null || inputFormat.getTarget() != mTarget) {
- initProgram(context, inputFormat.getTarget());
- }
-
- // Process
- mProgram.process(input, output);
-
- // Push output
- pushOutput("image", output);
-
- // Release pushed frame
- output.release();
- }
-
-}
+++ /dev/null
-/*
- * 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.filterpacks.imageproc;
-
-import android.filterfw.core.Filter;
-import android.filterfw.core.FilterContext;
-import android.filterfw.core.Frame;
-import android.filterfw.core.FrameFormat;
-import android.filterfw.core.GenerateFieldPort;
-import android.filterfw.core.KeyValueMap;
-import android.filterfw.core.NativeProgram;
-import android.filterfw.core.NativeFrame;
-import android.filterfw.core.Program;
-import android.filterfw.core.ShaderProgram;
-import android.filterfw.format.ImageFormat;
-
-public class PosterizeFilter extends Filter {
-
- @GenerateFieldPort(name = "tile_size", hasDefault = true)
- private int mTileSize = 640;
-
- private Program mProgram;
- private int mTarget = FrameFormat.TARGET_UNSPECIFIED;
-
- private final String mPosterizeShader =
- "precision mediump float;\n" +
- "uniform sampler2D tex_sampler_0;\n" +
- "varying vec2 v_texcoord;\n" +
- "void main() {\n" +
- " vec4 color = texture2D(tex_sampler_0, v_texcoord);\n" +
- " vec3 pcolor;\n" +
- " pcolor.r = (color.r >= 0.5) ? 0.75 : 0.25;\n" +
- " pcolor.g = (color.g >= 0.5) ? 0.75 : 0.25;\n" +
- " pcolor.b = (color.b >= 0.5) ? 0.75 : 0.25;\n" +
- " gl_FragColor = vec4(pcolor, color.a);\n" +
- "}\n";
-
- public PosterizeFilter(String name) {
- super(name);
- }
-
- @Override
- public void setupPorts() {
- addMaskedInputPort("image", ImageFormat.create(ImageFormat.COLORSPACE_RGBA));
- addOutputBasedOnInput("image", "image");
- }
-
- @Override
- public FrameFormat getOutputFormat(String portName, FrameFormat inputFormat) {
- return inputFormat;
- }
-
- public void initProgram(FilterContext context, int target) {
- switch (target) {
- case FrameFormat.TARGET_GPU:
- ShaderProgram shaderProgram = new ShaderProgram(context, mPosterizeShader);
- shaderProgram.setMaximumTileSize(mTileSize);
- mProgram = shaderProgram;
- break;
-
- default:
- throw new RuntimeException("Filter Sharpen does not support frames of " +
- "target " + target + "!");
- }
- mTarget = target;
- }
-
- @Override
- public void process(FilterContext context) {
- // Get input frame
- Frame input = pullInput("image");
- FrameFormat inputFormat = input.getFormat();
-
- // Create output frame
- Frame output = context.getFrameManager().newFrame(inputFormat);
-
- // Create program if not created already
- if (mProgram == null || inputFormat.getTarget() != mTarget) {
- initProgram(context, inputFormat.getTarget());
- }
-
- // Process
- mProgram.process(input, output);
-
- // Push output
- pushOutput("image", output);
-
- // Release pushed frame
- output.release();
- }
-
-}
+++ /dev/null
-/*
- * 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.filterpacks.imageproc;
-
-import android.filterfw.core.Filter;
-import android.filterfw.core.FilterContext;
-import android.filterfw.core.Frame;
-import android.filterfw.core.FrameFormat;
-import android.filterfw.core.GenerateFieldPort;
-import android.filterfw.core.KeyValueMap;
-import android.filterfw.core.NativeProgram;
-import android.filterfw.core.NativeFrame;
-import android.filterfw.core.Program;
-import android.filterfw.core.ShaderProgram;
-import android.filterfw.format.ImageFormat;
-import android.graphics.Bitmap;
-import android.graphics.Canvas;
-import android.graphics.Color;
-import android.graphics.Paint;
-import android.graphics.PointF;
-import android.util.Log;
-
-/**
- * @hide
- */
-public class RedEyeFilter extends Filter {
-
- private static final float RADIUS_RATIO = 0.06f;
- private static final float MIN_RADIUS = 10.0f;
- private static final float DEFAULT_RED_INTENSITY = 1.30f;
-
- @GenerateFieldPort(name = "centers")
- private float[] mCenters;
-
- @GenerateFieldPort(name = "tile_size", hasDefault = true)
- private int mTileSize = 640;
-
- private Frame mRedEyeFrame;
- private Bitmap mRedEyeBitmap;
-
- private final Canvas mCanvas = new Canvas();
- private final Paint mPaint = new Paint();
-
- private float mRadius;
-
- private int mWidth = 0;
- private int mHeight = 0;
-
- private Program mProgram;
- private int mTarget = FrameFormat.TARGET_UNSPECIFIED;
-
- private final String mRedEyeShader =
- "precision mediump float;\n" +
- "uniform sampler2D tex_sampler_0;\n" +
- "uniform sampler2D tex_sampler_1;\n" +
- "uniform float intensity;\n" +
- "varying vec2 v_texcoord;\n" +
- "void main() {\n" +
- " vec4 color = texture2D(tex_sampler_0, v_texcoord);\n" +
- " vec4 mask = texture2D(tex_sampler_1, v_texcoord);\n" +
- " gl_FragColor = vec4(mask.a, mask.a, mask.a, 1.0) * intensity + color * (1.0 - intensity);\n" +
- " if (mask.a > 0.0) {\n" +
- " gl_FragColor.r = 0.0;\n" +
- " float green_blue = color.g + color.b;\n" +
- " float red_intensity = color.r / green_blue;\n" +
- " if (red_intensity > intensity) {\n" +
- " color.r = 0.5 * green_blue;\n" +
- " }\n" +
- " }\n" +
- " gl_FragColor = color;\n" +
- "}\n";
-
- public RedEyeFilter(String name) {
- super(name);
- }
-
- @Override
- public void setupPorts() {
- addMaskedInputPort("image", ImageFormat.create(ImageFormat.COLORSPACE_RGBA));
- addOutputBasedOnInput("image", "image");
- }
-
- @Override
- public FrameFormat getOutputFormat(String portName, FrameFormat inputFormat) {
- return inputFormat;
- }
-
- public void initProgram(FilterContext context, int target) {
- switch (target) {
- case FrameFormat.TARGET_GPU:
- ShaderProgram shaderProgram = new ShaderProgram(context, mRedEyeShader);
- shaderProgram.setMaximumTileSize(mTileSize);
- mProgram = shaderProgram;
- break;
-
- default:
- throw new RuntimeException("Filter RedEye does not support frames of " +
- "target " + target + "!");
- }
- mTarget = target;
- }
-
- @Override
- public void tearDown(FilterContext context) {
- if (mRedEyeBitmap != null) {
- mRedEyeBitmap.recycle();
- mRedEyeBitmap = null;
- }
- }
-
- @Override
- public void process(FilterContext context) {
- // Get input frame
- Frame input = pullInput("image");
- FrameFormat inputFormat = input.getFormat();
-
- // Create output frame
- Frame output = context.getFrameManager().newFrame(inputFormat);
-
- // Create program if not created already
- if (mProgram == null || inputFormat.getTarget() != mTarget) {
- initProgram(context, inputFormat.getTarget());
- }
-
- // Check if the frame size has changed
- if (inputFormat.getWidth() != mWidth || inputFormat.getHeight() != mHeight) {
- mWidth = inputFormat.getWidth();
- mHeight = inputFormat.getHeight();
-
- createRedEyeBitmap();
- }
-
- createRedEyeFrame(context);
-
- // Process
- Frame[] inputs = {input, mRedEyeFrame};
- mProgram.process(inputs, output);
-
- // Push output
- pushOutput("image", output);
-
- // Release pushed frame
- output.release();
-
- // Release unused frame
- mRedEyeFrame.release();
- mRedEyeFrame = null;
- }
-
- @Override
- public void fieldPortValueUpdated(String name, FilterContext context) {
- if (mProgram != null) {
- updateProgramParams();
- }
- }
-
- private void createRedEyeBitmap() {
- if (mRedEyeBitmap != null) {
- mRedEyeBitmap.recycle();
- }
-
- int bitmapWidth = mWidth / 2;
- int bitmapHeight = mHeight / 2;
-
- mRedEyeBitmap = Bitmap.createBitmap(bitmapWidth, bitmapHeight, Bitmap.Config.ARGB_8888);
- mCanvas.setBitmap(mRedEyeBitmap);
- mPaint.setColor(Color.WHITE);
- mRadius = Math.max(MIN_RADIUS, RADIUS_RATIO * Math.min(bitmapWidth, bitmapHeight));
-
- updateProgramParams();
- }
-
- private void createRedEyeFrame(FilterContext context) {
- FrameFormat format = ImageFormat.create(mRedEyeBitmap.getWidth() ,
- mRedEyeBitmap.getHeight(),
- ImageFormat.COLORSPACE_RGBA,
- FrameFormat.TARGET_GPU);
- mRedEyeFrame = context.getFrameManager().newFrame(format);
- mRedEyeFrame.setBitmap(mRedEyeBitmap);
- }
-
- private void updateProgramParams() {
- mProgram.setHostValue("intensity", DEFAULT_RED_INTENSITY);
-
- if ( mCenters.length % 2 == 1) {
- throw new RuntimeException("The size of center array must be even.");
- }
-
- if (mRedEyeBitmap != null) {
- for (int i = 0; i < mCenters.length; i += 2) {
- mCanvas.drawCircle(mCenters[i] * mRedEyeBitmap.getWidth(),
- mCenters[i + 1] * mRedEyeBitmap.getHeight(),
- mRadius, mPaint);
- }
- }
- }
-}
+++ /dev/null
-/*
- * 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.filterpacks.imageproc;
-
-import android.filterfw.core.Filter;
-import android.filterfw.core.FilterContext;
-import android.filterfw.core.Frame;
-import android.filterfw.core.FrameFormat;
-import android.filterfw.core.GenerateFieldPort;
-import android.filterfw.core.GLFrame;
-import android.filterfw.core.KeyValueMap;
-import android.filterfw.core.MutableFrameFormat;
-import android.filterfw.core.NativeProgram;
-import android.filterfw.core.NativeFrame;
-import android.filterfw.core.Program;
-import android.filterfw.core.ShaderProgram;
-import android.filterfw.format.ImageFormat;
-
-import android.opengl.GLES20;
-
-/**
- * @hide
- */
-public class ResizeFilter extends Filter {
-
- @GenerateFieldPort(name = "owidth")
- private int mOWidth;
- @GenerateFieldPort(name = "oheight")
- private int mOHeight;
- @GenerateFieldPort(name = "keepAspectRatio", hasDefault = true)
- private boolean mKeepAspectRatio = false;
- @GenerateFieldPort(name = "generateMipMap", hasDefault = true)
- private boolean mGenerateMipMap = false;
-
- private Program mProgram;
- private FrameFormat mLastFormat = null;
-
- private MutableFrameFormat mOutputFormat;
- private int mInputChannels;
-
- public ResizeFilter(String name) {
- super(name);
- }
-
- @Override
- public void setupPorts() {
- addMaskedInputPort("image", ImageFormat.create(ImageFormat.COLORSPACE_RGBA));
- addOutputBasedOnInput("image", "image");
- }
-
- @Override
- public FrameFormat getOutputFormat(String portName, FrameFormat inputFormat) {
- return inputFormat;
- }
-
- protected void createProgram(FilterContext context, FrameFormat format) {
- if (mLastFormat != null && mLastFormat.getTarget() == format.getTarget()) return;
- mLastFormat = format;
- switch (format.getTarget()) {
- case FrameFormat.TARGET_NATIVE:
- throw new RuntimeException("Native ResizeFilter not implemented yet!");
-
-
- case FrameFormat.TARGET_GPU:
- ShaderProgram prog = ShaderProgram.createIdentity(context);
- mProgram = prog;
- break;
-
- default:
- throw new RuntimeException("ResizeFilter could not create suitable program!");
- }
- }
- @Override
- public void process(FilterContext env) {
- // Get input frame
- Frame input = pullInput("image");
- createProgram(env, input.getFormat());
-
- // Create output frame
- MutableFrameFormat outputFormat = input.getFormat().mutableCopy();
- if (mKeepAspectRatio) {
- FrameFormat inputFormat = input.getFormat();
- mOHeight = mOWidth * inputFormat.getHeight() / inputFormat.getWidth();
- }
- outputFormat.setDimensions(mOWidth, mOHeight);
- Frame output = env.getFrameManager().newFrame(outputFormat);
-
- // Process
- if (mGenerateMipMap) {
- GLFrame mipmapped = (GLFrame)env.getFrameManager().newFrame(input.getFormat());
- mipmapped.setTextureParameter(GLES20.GL_TEXTURE_MIN_FILTER,
- GLES20.GL_LINEAR_MIPMAP_NEAREST);
- mipmapped.setDataFromFrame(input);
- mipmapped.generateMipMap();
- mProgram.process(mipmapped, output);
- mipmapped.release();
- } else {
- mProgram.process(input, output);
- }
-
- // Push output
- pushOutput("image", output);
-
- // Release pushed frame
- output.release();
- }
-
-
-}
+++ /dev/null
-/*
- * 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.filterpacks.imageproc;
-
-import android.filterfw.core.Filter;
-import android.filterfw.core.FilterContext;
-import android.filterfw.core.Frame;
-import android.filterfw.core.FrameFormat;
-import android.filterfw.core.GenerateFieldPort;
-import android.filterfw.core.KeyValueMap;
-import android.filterfw.core.MutableFrameFormat;
-import android.filterfw.core.NativeProgram;
-import android.filterfw.core.NativeFrame;
-import android.filterfw.core.Program;
-import android.filterfw.core.ShaderProgram;
-import android.filterfw.format.ImageFormat;
-import android.filterfw.geometry.Quad;
-import android.filterfw.geometry.Point;
-import android.util.Log;
-
-/**
- * @hide
- */
-public class RotateFilter extends Filter {
-
- @GenerateFieldPort(name = "angle")
- private int mAngle;
-
- @GenerateFieldPort(name = "tile_size", hasDefault = true)
- private int mTileSize = 640;
-
- private Program mProgram;
-
- private int mWidth = 0;
- private int mHeight = 0;
- private int mTarget = FrameFormat.TARGET_UNSPECIFIED;
-
- private int mOutputWidth;
- private int mOutputHeight;
-
- public RotateFilter(String name) {
- super(name);
- }
-
- @Override
- public void setupPorts() {
- addMaskedInputPort("image", ImageFormat.create(ImageFormat.COLORSPACE_RGBA));
- addOutputBasedOnInput("image", "image");
- }
-
- public void initProgram(FilterContext context, int target) {
- switch (target) {
- case FrameFormat.TARGET_GPU:
- ShaderProgram shaderProgram = ShaderProgram.createIdentity(context);
- shaderProgram.setMaximumTileSize(mTileSize);
- shaderProgram.setClearsOutput(true);
- mProgram = shaderProgram;
- break;
-
- default:
- throw new RuntimeException("Filter Sharpen does not support frames of " +
- "target " + target + "!");
- }
- mTarget = target;
- }
-
- @Override
- public void fieldPortValueUpdated(String name, FilterContext context) {
- if (mProgram != null) {
- updateParameters();
- }
- }
-
- @Override
- public void process(FilterContext context) {
- // Get input frame
- Frame input = pullInput("image");
- FrameFormat inputFormat = input.getFormat();
-
- // Create program if not created already
- if (mProgram == null || inputFormat.getTarget() != mTarget) {
- initProgram(context, inputFormat.getTarget());
- }
-
- if (inputFormat.getWidth() != mWidth || inputFormat.getHeight() != mHeight) {
- mWidth = inputFormat.getWidth();
- mHeight = inputFormat.getHeight();
- mOutputWidth = mWidth;
- mOutputHeight = mHeight;
-
- updateParameters();
- }
-
- // Create output frame
- FrameFormat outputFormat = ImageFormat.create(mOutputWidth, mOutputHeight,
- ImageFormat.COLORSPACE_RGBA,
- FrameFormat.TARGET_GPU);
-
- Frame output = context.getFrameManager().newFrame(outputFormat);
-
- // Process
- mProgram.process(input, output);
-
- // Push output
- pushOutput("image", output);
-
- // Release pushed frame
- output.release();
- }
-
- private void updateParameters() {
- float sinTheta;
- float cosTheta;
-
- if (mAngle % 90 == 0) {
- if (mAngle % 180 == 0) {
- sinTheta = 0f;
- cosTheta = (mAngle % 360 == 0) ? 1f:-1f;
- } else {
- cosTheta = 0f;
- sinTheta = ((mAngle + 90) % 360 == 0) ? -1f:1f;
-
- mOutputWidth = mHeight;
- mOutputHeight = mWidth;
- }
- } else {
- throw new RuntimeException("degree has to be multiply of 90.");
- }
-
- Point x0 = new Point(0.5f * (-cosTheta + sinTheta + 1f),
- 0.5f * (-sinTheta - cosTheta + 1f));
- Point x1 = new Point(0.5f * (cosTheta + sinTheta + 1f),
- 0.5f * (sinTheta - cosTheta + 1f));
- Point x2 = new Point(0.5f * (-cosTheta - sinTheta + 1f),
- 0.5f * (-sinTheta + cosTheta + 1f));
- Point x3 = new Point(0.5f * (cosTheta - sinTheta + 1f),
- 0.5f * (sinTheta + cosTheta + 1f));
- Quad quad = new Quad(x0, x1, x2, x3);
- ((ShaderProgram) mProgram).setTargetRegion(quad);
- }
-}
+++ /dev/null
-/*
- * 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.filterpacks.imageproc;
-
-import android.filterfw.core.Filter;
-import android.filterfw.core.FilterContext;
-import android.filterfw.core.Frame;
-import android.filterfw.core.FrameFormat;
-import android.filterfw.core.GenerateFieldPort;
-import android.filterfw.core.KeyValueMap;
-import android.filterfw.core.NativeProgram;
-import android.filterfw.core.NativeFrame;
-import android.filterfw.core.Program;
-import android.filterfw.core.ShaderProgram;
-import android.filterfw.format.ImageFormat;
-
-public class SaturateFilter extends Filter {
-
- @GenerateFieldPort(name = "scale", hasDefault = true)
- private float mScale = 0f;
-
- @GenerateFieldPort(name = "tile_size", hasDefault = true)
- private int mTileSize = 640;
-
- private Program mBenProgram;
- private Program mHerfProgram;
- private int mTarget = FrameFormat.TARGET_UNSPECIFIED;
-
- private final String mBenSaturateShader =
- "precision mediump float;\n" +
- "uniform sampler2D tex_sampler_0;\n" +
- "uniform float scale;\n" +
- "uniform float shift;\n" +
- "uniform vec3 weights;\n" +
- "varying vec2 v_texcoord;\n" +
- "void main() {\n" +
- " vec4 color = texture2D(tex_sampler_0, v_texcoord);\n" +
- " float kv = dot(color.rgb, weights) + shift;\n" +
- " vec3 new_color = scale * color.rgb + (1.0 - scale) * kv;\n" +
- " gl_FragColor = vec4(new_color, color.a);\n" +
- "}\n";
-
- private final String mHerfSaturateShader =
- "precision mediump float;\n" +
- "uniform sampler2D tex_sampler_0;\n" +
- "uniform vec3 weights;\n" +
- "uniform vec3 exponents;\n" +
- "varying vec2 v_texcoord;\n" +
- "void main() {\n" +
- " vec4 color = texture2D(tex_sampler_0, v_texcoord);\n" +
- " float de = dot(color.rgb, weights);\n" +
- " float inv_de = 1.0 / de;\n" +
- " vec3 new_color = de * pow(color.rgb * inv_de, exponents);\n" +
- " float max_color = max(max(max(new_color.r, new_color.g), new_color.b), 1.0);\n" +
- " gl_FragColor = vec4(new_color / max_color, color.a);\n" +
- "}\n";
-
-
- public SaturateFilter(String name) {
- super(name);
- }
-
- @Override
- public void setupPorts() {
- addMaskedInputPort("image", ImageFormat.create(ImageFormat.COLORSPACE_RGBA));
- addOutputBasedOnInput("image", "image");
- }
-
- @Override
- public FrameFormat getOutputFormat(String portName, FrameFormat inputFormat) {
- return inputFormat;
- }
-
- public void initProgram(FilterContext context, int target) {
- switch (target) {
- case FrameFormat.TARGET_GPU:
- ShaderProgram shaderProgram = new ShaderProgram(context, mBenSaturateShader);
- shaderProgram.setMaximumTileSize(mTileSize);
- mBenProgram = shaderProgram;
-
- shaderProgram = new ShaderProgram(context, mHerfSaturateShader);
- shaderProgram.setMaximumTileSize(mTileSize);
- mHerfProgram = shaderProgram;
-
- break;
-
- default:
- throw new RuntimeException("Filter Sharpen does not support frames of " +
- "target " + target + "!");
- }
- mTarget = target;
- }
-
- @Override
- public void fieldPortValueUpdated(String name, FilterContext context) {
- if (mBenProgram != null && mHerfProgram != null) {
- updateParameters();
- }
- }
-
- @Override
- public void process(FilterContext context) {
- // Get input frame
- Frame input = pullInput("image");
- FrameFormat inputFormat = input.getFormat();
-
- // Create program if not created already
- if (mBenProgram == null || inputFormat.getTarget() != mTarget) {
- initProgram(context, inputFormat.getTarget());
- initParameters();
- }
-
- // Create output frame
- Frame output = context.getFrameManager().newFrame(inputFormat);
-
- // Process
- if (mScale > 0.0f) {
- mHerfProgram.process(input, output);
- } else {
- mBenProgram.process(input, output);
- }
- // Push output
- pushOutput("image", output);
-
- // Release pushed frame
- output.release();
- }
-
- private void initParameters() {
- float shift = 1.0f / 255.0f;
- float weights[] = { 2f/8f, 5f/8f, 1f/8f};
-
- mBenProgram.setHostValue("weights", weights);
- mBenProgram.setHostValue("shift", shift);
-
- mHerfProgram.setHostValue("weights", weights);
-
- updateParameters();
- }
-
- private void updateParameters() {
-
- if (mScale > 0.0f) {
- float exponents[] = new float[3];
-
- exponents[0] = (0.9f * mScale) + 1.0f;
- exponents[1] = (2.1f * mScale) + 1.0f;
- exponents[2] = (2.7f * mScale) + 1.0f;
-
- mHerfProgram.setHostValue("exponents", exponents);
- } else {
- mBenProgram.setHostValue("scale", 1.0f + mScale);
- }
- }
-
-}
+++ /dev/null
-/*
- * 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.filterpacks.imageproc;
-
-import android.filterfw.core.Filter;
-import android.filterfw.core.FilterContext;
-import android.filterfw.core.Frame;
-import android.filterfw.core.FrameFormat;
-import android.filterfw.core.GenerateFieldPort;
-import android.filterfw.core.KeyValueMap;
-import android.filterfw.core.NativeProgram;
-import android.filterfw.core.NativeFrame;
-import android.filterfw.core.Program;
-import android.filterfw.core.ShaderProgram;
-import android.filterfw.format.ImageFormat;
-
-public class SepiaFilter extends Filter {
-
- @GenerateFieldPort(name = "tile_size", hasDefault = true)
- private int mTileSize = 640;
-
- private Program mProgram;
- private int mTarget = FrameFormat.TARGET_UNSPECIFIED;
-
- private final String mSepiaShader =
- "precision mediump float;\n" +
- "uniform sampler2D tex_sampler_0;\n" +
- "uniform mat3 matrix;\n" +
- "varying vec2 v_texcoord;\n" +
- "void main() {\n" +
- " vec4 color = texture2D(tex_sampler_0, v_texcoord);\n" +
- " vec3 new_color = min(matrix * color.rgb, 1.0);\n" +
- " gl_FragColor = vec4(new_color.rgb, color.a);\n" +
- "}\n";
-
- public SepiaFilter(String name) {
- super(name);
- }
-
- @Override
- public void setupPorts() {
- addMaskedInputPort("image", ImageFormat.create(ImageFormat.COLORSPACE_RGBA));
- addOutputBasedOnInput("image", "image");
- }
-
- @Override
- public FrameFormat getOutputFormat(String portName, FrameFormat inputFormat) {
- return inputFormat;
- }
-
- public void initProgram(FilterContext context, int target) {
- switch (target) {
- case FrameFormat.TARGET_GPU:
- ShaderProgram shaderProgram = new ShaderProgram(context, mSepiaShader);
- shaderProgram.setMaximumTileSize(mTileSize);
- mProgram = shaderProgram;
- break;
-
- default:
- throw new RuntimeException("Filter Sharpen does not support frames of " +
- "target " + target + "!");
- }
- mTarget = target;
- }
-
- @Override
- public void process(FilterContext context) {
- // Get input frame
- Frame input = pullInput("image");
- FrameFormat inputFormat = input.getFormat();
-
- // Create output frame
- Frame output = context.getFrameManager().newFrame(inputFormat);
-
- // Create program if not created already
- if (mProgram == null || inputFormat.getTarget() != mTarget) {
- initProgram(context, inputFormat.getTarget());
- initParameters();
- }
-
- // Process
- mProgram.process(input, output);
-
- // Push output
- pushOutput("image", output);
-
- // Release pushed frame
- output.release();
- }
-
- private void initParameters() {
- float weights[] = { 805.0f / 2048.0f, 715.0f / 2048.0f, 557.0f / 2048.0f,
- 1575.0f / 2048.0f, 1405.0f / 2048.0f, 1097.0f / 2048.0f,
- 387.0f / 2048.0f, 344.0f / 2048.0f, 268.0f / 2048.0f };
- mProgram.setHostValue("matrix", weights);
- }
-}
+++ /dev/null
-/*
- * 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.filterpacks.imageproc;
-
-import android.filterfw.core.Filter;
-import android.filterfw.core.FilterContext;
-import android.filterfw.core.Frame;
-import android.filterfw.core.FrameFormat;
-import android.filterfw.core.GenerateFieldPort;
-import android.filterfw.core.KeyValueMap;
-import android.filterfw.core.NativeProgram;
-import android.filterfw.core.NativeFrame;
-import android.filterfw.core.Program;
-import android.filterfw.core.ShaderProgram;
-import android.filterfw.format.ImageFormat;
-
-import java.util.Set;
-
-public class SharpenFilter extends Filter {
-
- @GenerateFieldPort(name = "scale", hasDefault = true)
- private float mScale = 0f;
-
- @GenerateFieldPort(name = "tile_size", hasDefault = true)
- private int mTileSize = 640;
-
- private Program mProgram;
-
- private int mWidth = 0;
- private int mHeight = 0;
- private int mTarget = FrameFormat.TARGET_UNSPECIFIED;
-
- private final String mSharpenShader =
- "precision mediump float;\n" +
- "uniform sampler2D tex_sampler_0;\n" +
- "uniform float scale;\n" +
- "uniform float stepsizeX;\n" +
- "uniform float stepsizeY;\n" +
- "varying vec2 v_texcoord;\n" +
- "void main() {\n" +
- " vec3 nbr_color = vec3(0.0, 0.0, 0.0);\n" +
- " vec2 coord;\n" +
- " vec4 color = texture2D(tex_sampler_0, v_texcoord);\n" +
- " coord.x = v_texcoord.x - 0.5 * stepsizeX;\n" +
- " coord.y = v_texcoord.y - stepsizeY;\n" +
- " nbr_color += texture2D(tex_sampler_0, coord).rgb - color.rgb;\n" +
- " coord.x = v_texcoord.x - stepsizeX;\n" +
- " coord.y = v_texcoord.y + 0.5 * stepsizeY;\n" +
- " nbr_color += texture2D(tex_sampler_0, coord).rgb - color.rgb;\n" +
- " coord.x = v_texcoord.x + stepsizeX;\n" +
- " coord.y = v_texcoord.y - 0.5 * stepsizeY;\n" +
- " nbr_color += texture2D(tex_sampler_0, coord).rgb - color.rgb;\n" +
- " coord.x = v_texcoord.x + stepsizeX;\n" +
- " coord.y = v_texcoord.y + 0.5 * stepsizeY;\n" +
- " nbr_color += texture2D(tex_sampler_0, coord).rgb - color.rgb;\n" +
- " gl_FragColor = vec4(color.rgb - 2.0 * scale * nbr_color, color.a);\n" +
- "}\n";
-
- public SharpenFilter(String name) {
- super(name);
- }
-
- @Override
- public void setupPorts() {
- addMaskedInputPort("image", ImageFormat.create(ImageFormat.COLORSPACE_RGBA));
- addOutputBasedOnInput("image", "image");
- }
-
- @Override
- public FrameFormat getOutputFormat(String portName, FrameFormat inputFormat) {
- return inputFormat;
- }
-
- public void initProgram(FilterContext context, int target) {
- switch (target) {
- case FrameFormat.TARGET_GPU:
- ShaderProgram shaderProgram = new ShaderProgram(context, mSharpenShader);
- shaderProgram.setMaximumTileSize(mTileSize);
- mProgram = shaderProgram;
- break;
-
- default:
- throw new RuntimeException("Filter Sharpen does not support frames of " +
- "target " + target + "!");
- }
- mTarget = target;
- }
-
- @Override
- public void process(FilterContext context) {
- // Get input frame
- Frame input = pullInput("image");
- FrameFormat inputFormat = input.getFormat();
-
- // Create output frame
- Frame output = context.getFrameManager().newFrame(inputFormat);
-
- // Create program if not created already
- if (mProgram == null || inputFormat.getTarget() != mTarget) {
- initProgram(context, inputFormat.getTarget());
- }
-
- // Check if the frame size has changed
- if (inputFormat.getWidth() != mWidth || inputFormat.getHeight() != mHeight) {
- updateFrameSize(inputFormat.getWidth(), inputFormat.getHeight());
- }
-
- // Process
- mProgram.process(input, output);
-
- // Push output
- pushOutput("image", output);
-
- // Release pushed frame
- output.release();
- }
-
- private void updateFrameSize(int width, int height) {
- mWidth = width;
- mHeight = height;
-
- if (mProgram != null) {
- mProgram.setHostValue("stepsizeX", 1.0f / mWidth);
- mProgram.setHostValue("stepsizeY", 1.0f / mHeight);
- updateParameters();
- }
- }
-
- private void updateParameters() {
- mProgram.setHostValue("scale", mScale);
- }
-
- @Override
- public void fieldPortValueUpdated(String name, FilterContext context) {
- if (mProgram != null) {
- updateParameters();
- }
- }
-}
+++ /dev/null
-/*
- * 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.filterpacks.imageproc;
-
-import android.filterfw.core.Filter;
-import android.filterfw.core.FilterContext;
-import android.filterfw.core.Frame;
-import android.filterfw.core.FrameFormat;
-import android.filterfw.core.KeyValueMap;
-import android.filterfw.core.NativeProgram;
-import android.filterfw.core.NativeFrame;
-import android.filterfw.core.Program;
-import android.filterfw.core.ShaderProgram;
-import android.filterfw.format.ImageFormat;
-
-import java.lang.reflect.Field;
-import java.util.HashSet;
-import java.util.Set;
-
-/**
- * @hide
- */
-public abstract class SimpleImageFilter extends Filter {
-
- protected int mCurrentTarget = FrameFormat.TARGET_UNSPECIFIED;
- protected Program mProgram;
- protected String mParameterName;
-
- public SimpleImageFilter(String name, String parameterName) {
- super(name);
- mParameterName = parameterName;
- }
-
- @Override
- public void setupPorts() {
- if (mParameterName != null) {
- try {
- Field programField = SimpleImageFilter.class.getDeclaredField("mProgram");
- addProgramPort(mParameterName, mParameterName, programField, float.class, false);
- } catch (NoSuchFieldException e) {
- throw new RuntimeException("Internal Error: mProgram field not found!");
- }
- }
- addMaskedInputPort("image", ImageFormat.create(ImageFormat.COLORSPACE_RGBA));
- addOutputBasedOnInput("image", "image");
- }
-
- @Override
- public FrameFormat getOutputFormat(String portName, FrameFormat inputFormat) {
- return inputFormat;
- }
-
- @Override
- public void process(FilterContext context) {
- // Get input frame
- Frame input = pullInput("image");
- FrameFormat inputFormat = input.getFormat();
-
- // Create output frame
- Frame output = context.getFrameManager().newFrame(inputFormat);
-
- // Create program if not created already
- updateProgramWithTarget(inputFormat.getTarget(), context);
-
- // Process
- mProgram.process(input, output);
-
- // Push output
- pushOutput("image", output);
-
- // Release pushed frame
- output.release();
- }
-
- protected void updateProgramWithTarget(int target, FilterContext context) {
- if (target != mCurrentTarget) {
- switch (target) {
- case FrameFormat.TARGET_NATIVE:
- mProgram = getNativeProgram(context);
- break;
-
- case FrameFormat.TARGET_GPU:
- mProgram = getShaderProgram(context);
- break;
-
- default:
- mProgram = null;
- break;
- }
- if (mProgram == null) {
- throw new RuntimeException("Could not create a program for image filter " + this + "!");
- }
- initProgramInputs(mProgram, context);
- mCurrentTarget = target;
- }
- }
-
- protected abstract Program getNativeProgram(FilterContext context);
-
- protected abstract Program getShaderProgram(FilterContext context);
-}
+++ /dev/null
-/*
- * 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.filterpacks.imageproc;
-
-import android.filterfw.core.Filter;
-import android.filterfw.core.FilterContext;
-import android.filterfw.core.Frame;
-import android.filterfw.core.FrameFormat;
-import android.filterfw.core.GenerateFieldPort;
-import android.filterfw.core.KeyValueMap;
-import android.filterfw.core.MutableFrameFormat;
-import android.filterfw.core.NativeProgram;
-import android.filterfw.core.NativeFrame;
-import android.filterfw.core.Program;
-import android.filterfw.core.ShaderProgram;
-import android.filterfw.format.ImageFormat;
-import android.filterfw.geometry.Quad;
-import android.filterfw.geometry.Point;
-import android.util.Log;
-
-/**
- * @hide
- */
-public class StraightenFilter extends Filter {
-
- @GenerateFieldPort(name = "angle", hasDefault = true)
- private float mAngle = 0f;
-
- @GenerateFieldPort(name = "maxAngle", hasDefault = true)
- private float mMaxAngle = 45f;
-
- @GenerateFieldPort(name = "tile_size", hasDefault = true)
- private int mTileSize = 640;
-
- private Program mProgram;
-
- private int mWidth = 0;
- private int mHeight = 0;
- private int mTarget = FrameFormat.TARGET_UNSPECIFIED;
-
- private static final float DEGREE_TO_RADIAN = (float) Math.PI / 180.0f;
-
- public StraightenFilter(String name) {
- super(name);
- }
-
- @Override
- public void setupPorts() {
- addMaskedInputPort("image", ImageFormat.create(ImageFormat.COLORSPACE_RGBA));
- addOutputBasedOnInput("image", "image");
- }
-
- public void initProgram(FilterContext context, int target) {
- switch (target) {
- case FrameFormat.TARGET_GPU:
- ShaderProgram shaderProgram = ShaderProgram.createIdentity(context);
- shaderProgram.setMaximumTileSize(mTileSize);
- mProgram = shaderProgram;
- break;
-
- default:
- throw new RuntimeException("Filter Sharpen does not support frames of " +
- "target " + target + "!");
- }
- mTarget = target;
- }
-
- @Override
- public void fieldPortValueUpdated(String name, FilterContext context) {
- if (mProgram != null) {
- updateParameters();
- }
- }
-
- @Override
- public void process(FilterContext context) {
- // Get input frame
- Frame input = pullInput("image");
- FrameFormat inputFormat = input.getFormat();
-
- // Create program if not created already
- if (mProgram == null || inputFormat.getTarget() != mTarget) {
- initProgram(context, inputFormat.getTarget());
- }
-
- // Create output frame
- if (inputFormat.getWidth() != mWidth || inputFormat.getHeight() != mHeight) {
- mWidth = inputFormat.getWidth();
- mHeight = inputFormat.getHeight();
- updateParameters();
- }
-
- Frame output = context.getFrameManager().newFrame(inputFormat);
-
- // Process
- mProgram.process(input, output);
-
- // Push output
- pushOutput("image", output);
-
- // Release pushed frame
- output.release();
- }
-
- private void updateParameters() {
- float cosTheta = (float) Math.cos(mAngle * DEGREE_TO_RADIAN);
- float sinTheta = (float) Math.sin(mAngle * DEGREE_TO_RADIAN);
-
- if (mMaxAngle <= 0)
- throw new RuntimeException("Max angle is out of range (0-180).");
- mMaxAngle = (mMaxAngle > 90) ? 90 : mMaxAngle;
-
- Point p0 = new Point(-cosTheta * mWidth + sinTheta * mHeight,
- -sinTheta * mWidth - cosTheta * mHeight);
-
- Point p1 = new Point(cosTheta * mWidth + sinTheta * mHeight,
- sinTheta * mWidth - cosTheta * mHeight);
-
- Point p2 = new Point(-cosTheta * mWidth - sinTheta * mHeight,
- -sinTheta * mWidth + cosTheta * mHeight);
-
- Point p3 = new Point(cosTheta * mWidth - sinTheta * mHeight,
- sinTheta * mWidth + cosTheta * mHeight);
-
- float maxWidth = (float) Math.max(Math.abs(p0.x), Math.abs(p1.x));
- float maxHeight = (float) Math.max(Math.abs(p0.y), Math.abs(p1.y));
-
- float scale = 0.5f * Math.min( mWidth / maxWidth,
- mHeight / maxHeight);
-
- p0.set(scale * p0.x / mWidth + 0.5f, scale * p0.y / mHeight + 0.5f);
- p1.set(scale * p1.x / mWidth + 0.5f, scale * p1.y / mHeight + 0.5f);
- p2.set(scale * p2.x / mWidth + 0.5f, scale * p2.y / mHeight + 0.5f);
- p3.set(scale * p3.x / mWidth + 0.5f, scale * p3.y / mHeight + 0.5f);
-
- Quad quad = new Quad(p0, p1, p2, p3);
- ((ShaderProgram) mProgram).setSourceRegion(quad);
- }
-}
+++ /dev/null
-/*
- * 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.filterpacks.imageproc;
-
-import android.filterfw.core.Filter;
-import android.filterfw.core.FilterContext;
-import android.filterfw.core.Frame;
-import android.filterfw.core.FrameFormat;
-import android.filterfw.core.GenerateFieldPort;
-import android.filterfw.core.KeyValueMap;
-import android.filterfw.core.NativeProgram;
-import android.filterfw.core.NativeFrame;
-import android.filterfw.core.Program;
-import android.filterfw.core.ShaderProgram;
-import android.filterfw.format.ImageFormat;
-import android.graphics.Color;
-
-public class TintFilter extends Filter {
-
- @GenerateFieldPort(name = "tint", hasDefault = true)
- private int mTint = 0xFF0000FF;
-
- @GenerateFieldPort(name = "tile_size", hasDefault = true)
- private int mTileSize = 640;
-
- private Program mProgram;
- private int mTarget = FrameFormat.TARGET_UNSPECIFIED;
-
- private final String mTintShader =
- "precision mediump float;\n" +
- "uniform sampler2D tex_sampler_0;\n" +
- "uniform vec3 tint;\n" +
- "uniform vec3 color_ratio;\n" +
- "varying vec2 v_texcoord;\n" +
- "void main() {\n" +
- " vec4 color = texture2D(tex_sampler_0, v_texcoord);\n" +
- " float avg_color = dot(color_ratio, color.rgb);\n" +
- " vec3 new_color = min(0.8 * avg_color + 0.2 * tint, 1.0);\n" +
- " gl_FragColor = vec4(new_color.rgb, color.a);\n" +
- "}\n";
-
- public TintFilter(String name) {
- super(name);
- }
-
- @Override
- public void setupPorts() {
- addMaskedInputPort("image", ImageFormat.create(ImageFormat.COLORSPACE_RGBA));
- addOutputBasedOnInput("image", "image");
- }
-
- @Override
- public FrameFormat getOutputFormat(String portName, FrameFormat inputFormat) {
- return inputFormat;
- }
-
- public void initProgram(FilterContext context, int target) {
- switch (target) {
- case FrameFormat.TARGET_GPU:
- ShaderProgram shaderProgram = new ShaderProgram(context, mTintShader);
- shaderProgram.setMaximumTileSize(mTileSize);
- mProgram = shaderProgram;
- break;
-
- default:
- throw new RuntimeException("Filter Sharpen does not support frames of " +
- "target " + target + "!");
- }
- mTarget = target;
- }
-
- @Override
- public void fieldPortValueUpdated(String name, FilterContext context) {
- if (mProgram != null) {
- updateParameters();
- }
- }
-
- @Override
- public void process(FilterContext context) {
- // Get input frame
- Frame input = pullInput("image");
- FrameFormat inputFormat = input.getFormat();
-
- // Create program if not created already
- if (mProgram == null || inputFormat.getTarget() != mTarget) {
- initProgram(context, inputFormat.getTarget());
- initParameters();
- }
-
- // Create output frame
- Frame output = context.getFrameManager().newFrame(inputFormat);
-
- // Process
- mProgram.process(input, output);
-
- // Push output
- pushOutput("image", output);
-
- // Release pushed frame
- output.release();
- }
-
- private void initParameters() {
- float color_ratio[] = {0.21f, 0.71f, 0.07f};
- mProgram.setHostValue("color_ratio", color_ratio);
-
- updateParameters();
- }
-
- private void updateParameters() {
- float tint_color[] = {Color.red(mTint) / 255f,
- Color.green(mTint) / 255f,
- Color.blue(mTint) / 255f };
-
- mProgram.setHostValue("tint", tint_color);
- }
-
-}
+++ /dev/null
-/*
- * 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.filterpacks.imageproc;
-
-import android.filterfw.core.Filter;
-import android.filterfw.core.FilterContext;
-import android.filterfw.core.Frame;
-import android.filterfw.core.FrameFormat;
-import android.filterfw.core.GenerateFieldPort;
-import android.filterfw.core.KeyValueMap;
-import android.filterfw.core.MutableFrameFormat;
-import android.filterfw.core.NativeProgram;
-import android.filterfw.core.NativeFrame;
-import android.filterfw.core.Program;
-import android.filterfw.core.ShaderProgram;
-import android.filterfw.format.ImageFormat;
-
-import android.util.Log;
-
-import java.lang.reflect.Field;
-
-/**
- * @hide
- */
-public class ToGrayFilter extends SimpleImageFilter {
-
- @GenerateFieldPort(name = "invertSource", hasDefault = true)
- private boolean mInvertSource = false;
-
- @GenerateFieldPort(name = "tile_size", hasDefault = true)
- private int mTileSize = 640;
-
- private MutableFrameFormat mOutputFormat;
-
- private static final String mColorToGray4Shader =
- "precision mediump float;\n" +
- "uniform sampler2D tex_sampler_0;\n" +
- "varying vec2 v_texcoord;\n" +
- "void main() {\n" +
- " vec4 color = texture2D(tex_sampler_0, v_texcoord);\n" +
- " float y = dot(color, vec4(0.299, 0.587, 0.114, 0));\n" +
- " gl_FragColor = vec4(y, y, y, color.a);\n" +
- "}\n";
-
- public ToGrayFilter(String name) {
- super(name, null);
- }
-
- @Override
- public void setupPorts() {
- addMaskedInputPort("image", ImageFormat.create(ImageFormat.COLORSPACE_RGBA,
- FrameFormat.TARGET_GPU));
- addOutputBasedOnInput("image", "image");
- }
-
- @Override
- protected Program getNativeProgram(FilterContext context) {
- throw new RuntimeException("Native toGray not implemented yet!");
- }
-
- @Override
- protected Program getShaderProgram(FilterContext context) {
- int inputChannels = getInputFormat("image").getBytesPerSample();
- if (inputChannels != 4) {
- throw new RuntimeException("Unsupported GL input channels: " +
- inputChannels + "! Channels must be 4!");
- }
- ShaderProgram program = new ShaderProgram(context, mColorToGray4Shader);
- program.setMaximumTileSize(mTileSize);
- if (mInvertSource)
- program.setSourceRect(0.0f, 1.0f, 1.0f, -1.0f);
- return program;
- }
-
-}
+++ /dev/null
-/*
- * 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.filterpacks.imageproc;
-
-import android.filterfw.core.Filter;
-import android.filterfw.core.FilterContext;
-import android.filterfw.core.Frame;
-import android.filterfw.core.FrameFormat;
-import android.filterfw.core.GenerateFieldPort;
-import android.filterfw.core.MutableFrameFormat;
-import android.filterfw.core.Program;
-import android.filterfw.core.ShaderProgram;
-import android.filterfw.format.ImageFormat;
-
-import android.util.Log;
-
-import java.lang.Math;
-/**
- * @hide
- */
-public class ToPackedGrayFilter extends Filter {
-
- @GenerateFieldPort(name = "owidth", hasDefault = true)
- private int mOWidth = FrameFormat.SIZE_UNSPECIFIED;
- @GenerateFieldPort(name = "oheight", hasDefault = true)
- private int mOHeight = FrameFormat.SIZE_UNSPECIFIED;
- @GenerateFieldPort(name = "keepAspectRatio", hasDefault = true)
- private boolean mKeepAspectRatio = false;
-
- private Program mProgram;
-
- private final String mColorToPackedGrayShader =
- "precision mediump float;\n" +
- "const vec4 coeff_y = vec4(0.299, 0.587, 0.114, 0);\n" +
- "uniform sampler2D tex_sampler_0;\n" +
- "uniform float pix_stride;\n" +
- "varying vec2 v_texcoord;\n" +
- "void main() {\n" +
- " for (int i = 0; i < 4; ++i) {\n" +
- " vec4 p = texture2D(tex_sampler_0,\n" +
- " v_texcoord + vec2(pix_stride * float(i), 0.0));\n" +
- " gl_FragColor[i] = dot(p, coeff_y);\n" +
- " }\n" +
- "}\n";
-
- public ToPackedGrayFilter(String name) {
- super(name);
- }
-
- @Override
- public void setupPorts() {
- addMaskedInputPort("image", ImageFormat.create(ImageFormat.COLORSPACE_RGBA,
- FrameFormat.TARGET_GPU));
- addOutputBasedOnInput("image", "image");
- }
-
- @Override
- public FrameFormat getOutputFormat(String portName, FrameFormat inputFormat) {
- return convertInputFormat(inputFormat);
- }
-
- private void checkOutputDimensions(int outputWidth, int outputHeight) {
- if (outputWidth <= 0 || outputHeight <= 0) {
- throw new RuntimeException("Invalid output dimensions: " +
- outputWidth + " " + outputHeight);
- }
- }
-
- private FrameFormat convertInputFormat(FrameFormat inputFormat) {
- int ow = mOWidth;
- int oh = mOHeight;
- int w = inputFormat.getWidth();
- int h = inputFormat.getHeight();
- if (mOWidth == FrameFormat.SIZE_UNSPECIFIED) {
- ow = w;
- }
- if (mOHeight == FrameFormat.SIZE_UNSPECIFIED) {
- oh = h;
- }
- if (mKeepAspectRatio) {
- // if keep aspect ratio, use the bigger dimension to determine the
- // final output size
- if (w > h) {
- ow = Math.max(ow, oh);
- oh = ow * h / w;
- } else {
- oh = Math.max(ow, oh);
- ow = oh * w / h;
- }
- }
- ow = (ow > 0 && ow < 4) ? 4 : (ow / 4) * 4; // ensure width is multiple of 4
- return ImageFormat.create(ow, oh,
- ImageFormat.COLORSPACE_GRAY,
- FrameFormat.TARGET_NATIVE);
- }
-
- @Override
- public void prepare(FilterContext context) {
- mProgram = new ShaderProgram(context, mColorToPackedGrayShader);
- }
-
- @Override
- public void process(FilterContext context) {
- Frame input = pullInput("image");
- FrameFormat inputFormat = input.getFormat();
- FrameFormat outputFormat = convertInputFormat(inputFormat);
- int ow = outputFormat.getWidth();
- int oh = outputFormat.getHeight();
- checkOutputDimensions(ow, oh);
- mProgram.setHostValue("pix_stride", 1.0f / ow);
-
- // Do the RGBA to luminance conversion.
- MutableFrameFormat tempFrameFormat = inputFormat.mutableCopy();
- tempFrameFormat.setDimensions(ow / 4, oh);
- Frame temp = context.getFrameManager().newFrame(tempFrameFormat);
- mProgram.process(input, temp);
-
- // Read frame from GPU to CPU.
- Frame output = context.getFrameManager().newFrame(outputFormat);
- output.setDataFromFrame(temp);
- temp.release();
-
- // Push output and yield ownership.
- pushOutput("image", output);
- output.release();
- }
-
-}
+++ /dev/null
-/*
- * 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.filterpacks.imageproc;
-
-import android.filterfw.core.Filter;
-import android.filterfw.core.FilterContext;
-import android.filterfw.core.Frame;
-import android.filterfw.core.FrameFormat;
-import android.filterfw.core.KeyValueMap;
-import android.filterfw.core.MutableFrameFormat;
-import android.filterfw.core.NativeProgram;
-import android.filterfw.core.NativeFrame;
-import android.filterfw.core.Program;
-import android.filterfw.core.ShaderProgram;
-import android.filterfw.format.ImageFormat;
-
-import android.util.Log;
-
-/**
- * @hide
- */
-public class ToRGBAFilter extends Filter {
-
- private int mInputBPP;
- private Program mProgram;
- private FrameFormat mLastFormat = null;
-
- public ToRGBAFilter(String name) {
- super(name);
- }
-
- @Override
- public void setupPorts() {
- MutableFrameFormat mask = new MutableFrameFormat(FrameFormat.TYPE_BYTE,
- FrameFormat.TARGET_NATIVE);
- mask.setDimensionCount(2);
- addMaskedInputPort("image", mask);
- addOutputBasedOnInput("image", "image");
- }
-
- @Override
- public FrameFormat getOutputFormat(String portName, FrameFormat inputFormat) {
- return getConvertedFormat(inputFormat);
- }
-
- public FrameFormat getConvertedFormat(FrameFormat format) {
- MutableFrameFormat result = format.mutableCopy();
- result.setMetaValue(ImageFormat.COLORSPACE_KEY, ImageFormat.COLORSPACE_RGBA);
- result.setBytesPerSample(4);
- return result;
- }
-
- public void createProgram(FilterContext context, FrameFormat format) {
- mInputBPP = format.getBytesPerSample();
- if (mLastFormat != null && mLastFormat.getBytesPerSample() == mInputBPP) return;
- mLastFormat = format;
- switch (mInputBPP) {
- case 1:
- mProgram = new NativeProgram("filterpack_imageproc", "gray_to_rgba");
- break;
- case 3:
- mProgram = new NativeProgram("filterpack_imageproc", "rgb_to_rgba");
- break;
- default:
- throw new RuntimeException("Unsupported BytesPerPixel: " + mInputBPP + "!");
- }
- }
-
- @Override
- public void process(FilterContext context) {
- // Get input frame
- Frame input = pullInput("image");
- createProgram(context, input.getFormat());
-
- // Create output frame
- Frame output = context.getFrameManager().newFrame(getConvertedFormat(input.getFormat()));
-
- // Process
- mProgram.process(input, output);
-
- // Push output
- pushOutput("image", output);
-
- // Release pushed frame
- output.release();
- }
-
-}
+++ /dev/null
-/*
- * 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.filterpacks.imageproc;
-
-import android.filterfw.core.Filter;
-import android.filterfw.core.FilterContext;
-import android.filterfw.core.Frame;
-import android.filterfw.core.FrameFormat;
-import android.filterfw.core.KeyValueMap;
-import android.filterfw.core.MutableFrameFormat;
-import android.filterfw.core.NativeProgram;
-import android.filterfw.core.NativeFrame;
-import android.filterfw.core.Program;
-import android.filterfw.core.ShaderProgram;
-import android.filterfw.format.ImageFormat;
-
-import android.util.Log;
-
-/**
- * @hide
- */
-public class ToRGBFilter extends Filter {
-
- private int mInputBPP;
- private Program mProgram;
- private FrameFormat mLastFormat = null;
-
- public ToRGBFilter(String name) {
- super(name);
- }
-
- @Override
- public void setupPorts() {
- MutableFrameFormat mask = new MutableFrameFormat(FrameFormat.TYPE_BYTE,
- FrameFormat.TARGET_NATIVE);
- mask.setDimensionCount(2);
- addMaskedInputPort("image", mask);
- addOutputBasedOnInput("image", "image");
- }
-
- @Override
- public FrameFormat getOutputFormat(String portName, FrameFormat inputFormat) {
- return getConvertedFormat(inputFormat);
- }
-
- public FrameFormat getConvertedFormat(FrameFormat format) {
- MutableFrameFormat result = format.mutableCopy();
- result.setMetaValue(ImageFormat.COLORSPACE_KEY, ImageFormat.COLORSPACE_RGB);
- result.setBytesPerSample(3);
- return result;
- }
-
- public void createProgram(FilterContext context, FrameFormat format) {
- mInputBPP = format.getBytesPerSample();
- if (mLastFormat != null && mLastFormat.getBytesPerSample() == mInputBPP) return;
- mLastFormat = format;
- switch (mInputBPP) {
- case 1:
- mProgram = new NativeProgram("filterpack_imageproc", "gray_to_rgb");
- break;
- case 4:
- mProgram = new NativeProgram("filterpack_imageproc", "rgba_to_rgb");
- break;
- default:
- throw new RuntimeException("Unsupported BytesPerPixel: " + mInputBPP + "!");
- }
- }
-
- @Override
- public void process(FilterContext context) {
- // Get input frame
- Frame input = pullInput("image");
- createProgram(context, input.getFormat());
-
- // Create output frame
- Frame output = context.getFrameManager().newFrame(getConvertedFormat(input.getFormat()));
-
- // Process
- mProgram.process(input, output);
-
- // Push output
- pushOutput("image", output);
-
- // Release pushed frame
- output.release();
- }
-
-}
+++ /dev/null
-/*
- * 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.filterpacks.imageproc;
-
-import android.filterfw.core.Filter;
-import android.filterfw.core.FilterContext;
-import android.filterfw.core.Frame;
-import android.filterfw.core.FrameFormat;
-import android.filterfw.core.GenerateFieldPort;
-import android.filterfw.core.KeyValueMap;
-import android.filterfw.core.NativeProgram;
-import android.filterfw.core.NativeFrame;
-import android.filterfw.core.Program;
-import android.filterfw.core.ShaderProgram;
-import android.filterfw.format.ImageFormat;
-
-public class VignetteFilter extends Filter {
-
- @GenerateFieldPort(name = "scale", hasDefault = true)
- private float mScale = 0f;
-
- @GenerateFieldPort(name = "tile_size", hasDefault = true)
- private int mTileSize = 640;
-
- private Program mProgram;
-
- private int mWidth = 0;
- private int mHeight = 0;
- private int mTarget = FrameFormat.TARGET_UNSPECIFIED;
-
- private final float mSlope = 20.0f;
- private final float mShade = 0.85f;
-
- private final String mVignetteShader =
- "precision mediump float;\n" +
- "uniform sampler2D tex_sampler_0;\n" +
- "uniform float range;\n" +
- "uniform float inv_max_dist;\n" +
- "uniform float shade;\n" +
- "uniform vec2 center;\n" +
- "varying vec2 v_texcoord;\n" +
- "void main() {\n" +
- " const float slope = 20.0;\n" +
- " float dist = distance(gl_FragCoord.xy, center);\n" +
- " float lumen = shade / (1.0 + exp((dist * inv_max_dist - range) * slope)) + (1.0 - shade);\n" +
- " vec4 color = texture2D(tex_sampler_0, v_texcoord);\n" +
- " gl_FragColor = vec4(color.rgb * lumen, color.a);\n" +
- "}\n";
-
- public VignetteFilter(String name) {
- super(name);
- }
-
- @Override
- public void setupPorts() {
- addMaskedInputPort("image", ImageFormat.create(ImageFormat.COLORSPACE_RGBA));
- addOutputBasedOnInput("image", "image");
- }
-
- @Override
- public FrameFormat getOutputFormat(String portName, FrameFormat inputFormat) {
- return inputFormat;
- }
-
- public void initProgram(FilterContext context, int target) {
- switch (target) {
- case FrameFormat.TARGET_GPU:
- ShaderProgram shaderProgram = new ShaderProgram(context, mVignetteShader);
- shaderProgram.setMaximumTileSize(mTileSize);
- mProgram = shaderProgram;
- break;
-
- default:
- throw new RuntimeException("Filter Sharpen does not support frames of " +
- "target " + target + "!");
- }
- mTarget = target;
- }
-
- private void initParameters() {
- if (mProgram != null) {
- float centerX = (float) (0.5 * mWidth);
- float centerY = (float) (0.5 * mHeight);
- float center[] = {centerX, centerY};
- float max_dist = (float) Math.sqrt(centerX * centerX + centerY * centerY);
-
- mProgram.setHostValue("center", center);
- mProgram.setHostValue("inv_max_dist", 1.0f / max_dist);
- mProgram.setHostValue("shade", mShade);
-
- updateParameters();
- }
- }
-
- private void updateParameters() {
- // The 'range' is between 1.3 to 0.6. When scale is zero then range is 1.3
- // which means no vignette at all because the luminousity difference is
- // less than 1/256 and will cause nothing.
- mProgram.setHostValue("range", 1.30f - (float) Math.sqrt(mScale) * 0.7f);
- }
-
- @Override
- public void fieldPortValueUpdated(String name, FilterContext context) {
- if (mProgram != null) {
- updateParameters();
- }
- }
-
- @Override
- public void process(FilterContext context) {
- // Get input frame
- Frame input = pullInput("image");
- FrameFormat inputFormat = input.getFormat();
-
- // Create program if not created already
- if (mProgram == null || inputFormat.getTarget() != mTarget) {
- initProgram(context, inputFormat.getTarget());
- }
-
- // Check if the frame size has changed
- if (inputFormat.getWidth() != mWidth || inputFormat.getHeight() != mHeight) {
- mWidth = inputFormat.getWidth();
- mHeight = inputFormat.getHeight();
- initParameters();
- }
-
- // Create output frame
- Frame output = context.getFrameManager().newFrame(inputFormat);
-
- // Process
- mProgram.process(input, output);
-
- // Push output
- pushOutput("image", output);
-
- // Release pushed frame
- output.release();
- }
-}
+++ /dev/null
-/**
- * @hide
- */
-package android.filterpacks.imageproc;
+++ /dev/null
-/*
- * 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.filterpacks.numeric;
-
-import android.filterfw.core.Filter;
-import android.filterfw.core.FilterContext;
-import android.filterfw.core.Frame;
-import android.filterfw.core.FrameFormat;
-import android.filterfw.core.GenerateFieldPort;
-import android.filterfw.format.ObjectFormat;
-
-import java.lang.Math;
-
-/**
- * @hide
- */
-public class SinWaveFilter extends Filter {
-
- @GenerateFieldPort(name = "stepSize", hasDefault = true)
- private float mStepSize = 0.05f;
-
- private float mValue = 0.0f;
-
- private FrameFormat mOutputFormat;
-
- public SinWaveFilter(String name) {
- super(name);
- }
-
- @Override
- public void setupPorts() {
- mOutputFormat = ObjectFormat.fromClass(Float.class, FrameFormat.TARGET_SIMPLE);
- addOutputPort("value", mOutputFormat);
- }
-
- @Override
- public void open(FilterContext env) {
- mValue = 0.0f;
- }
-
- @Override
- public void process(FilterContext env) {
- Frame output = env.getFrameManager().newFrame(mOutputFormat);
- output.setObjectValue(((float)Math.sin(mValue) + 1.0f) / 2.0f);
- pushOutput("value", output);
- mValue += mStepSize;
- output.release();
- }
-
-
-}
+++ /dev/null
-/**
- * @hide
- */
-package android.filterpacks.numeric;
+++ /dev/null
-/*
- * 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.filterpacks.performance;
-
-/**
- * @hide
- */
-public class Throughput {
-
- private final int mTotalFrames;
- private final int mPeriodFrames;
- private final int mPeriodTime;
- private final int mPixels;
-
- public Throughput(int totalFrames, int periodFrames, int periodTime, int pixels) {
- mTotalFrames = totalFrames;
- mPeriodFrames = periodFrames;
- mPeriodTime = periodTime;
- mPixels = pixels;
- }
-
- public int getTotalFrameCount() {
- return mTotalFrames;
- }
-
- public int getPeriodFrameCount() {
- return mPeriodFrames;
- }
-
- public int getPeriodTime() {
- return mPeriodTime;
- }
-
- public float getFramesPerSecond() {
- return mPeriodFrames / (float)mPeriodTime;
- }
-
- public float getNanosPerPixel() {
- double frameTimeInNanos = (mPeriodTime / (double)mPeriodFrames) * 1000000.0;
- return (float)(frameTimeInNanos / mPixels);
- }
-
- public String toString() {
- return getFramesPerSecond() + " FPS";
- }
-}
+++ /dev/null
-/*
- * 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.filterpacks.performance;
-
-import android.filterfw.core.Filter;
-import android.filterfw.core.FilterContext;
-import android.filterfw.core.Frame;
-import android.filterfw.core.FrameFormat;
-import android.filterfw.core.GenerateFieldPort;
-import android.filterfw.format.ObjectFormat;
-import android.os.SystemClock;
-
-/**
- * @hide
- */
-public class ThroughputFilter extends Filter {
-
- @GenerateFieldPort(name = "period", hasDefault = true)
- private int mPeriod = 5;
-
- private long mLastTime = 0;
-
- private int mTotalFrameCount = 0;
- private int mPeriodFrameCount = 0;
-
- private FrameFormat mOutputFormat;
-
- public ThroughputFilter(String name) {
- super(name);
- }
-
- @Override
- public void setupPorts() {
- // Add input ports
- addInputPort("frame");
-
- // Add output ports
- mOutputFormat = ObjectFormat.fromClass(Throughput.class, FrameFormat.TARGET_SIMPLE);
- addOutputBasedOnInput("frame", "frame");
- addOutputPort("throughput", mOutputFormat);
- }
-
- @Override
- public FrameFormat getOutputFormat(String portName, FrameFormat inputFormat) {
- return inputFormat;
- }
-
- @Override
- public void open(FilterContext env) {
- mTotalFrameCount = 0;
- mPeriodFrameCount = 0;
- mLastTime = 0;
- }
-
- @Override
- public void process(FilterContext context) {
- // Pass through input frame
- Frame input = pullInput("frame");
- pushOutput("frame", input);
-
- // Update stats
- ++mTotalFrameCount;
- ++mPeriodFrameCount;
-
- // Check clock
- if (mLastTime == 0) {
- mLastTime = SystemClock.elapsedRealtime();
- }
- long curTime = SystemClock.elapsedRealtime();
-
- // Output throughput info if time period is up
- if ((curTime - mLastTime) >= (mPeriod * 1000)) {
- FrameFormat inputFormat = input.getFormat();
- int pixelCount = inputFormat.getWidth() * inputFormat.getHeight();
- Throughput throughput = new Throughput(mTotalFrameCount,
- mPeriodFrameCount,
- mPeriod,
- pixelCount);
- Frame throughputFrame = context.getFrameManager().newFrame(mOutputFormat);
- throughputFrame.setObjectValue(throughput);
- pushOutput("throughput", throughputFrame);
- mLastTime = curTime;
- mPeriodFrameCount = 0;
- }
- }
-
-
-}
+++ /dev/null
-/**
- * @hide
- */
-package android.filterpacks.performance;
+++ /dev/null
-/*
- * 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.filterpacks.text;
-
-import android.filterfw.core.Filter;
-import android.filterfw.core.FilterContext;
-import android.filterfw.core.Frame;
-import android.filterfw.core.FrameFormat;
-import android.filterfw.format.ObjectFormat;
-import android.util.Log;
-
-/**
- * @hide
- */
-public class StringLogger extends Filter {
-
- public StringLogger(String name) {
- super(name);
- }
-
- @Override
- public void setupPorts() {
- addMaskedInputPort("string", ObjectFormat.fromClass(Object.class,
- FrameFormat.TARGET_SIMPLE));
- }
-
- @Override
- public void process(FilterContext env) {
- Frame input = pullInput("string");
- String inputString = input.getObjectValue().toString();
- Log.i("StringLogger", inputString);
- }
-
-}
+++ /dev/null
-/*
- * 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.filterpacks.text;
-
-import android.filterfw.core.Filter;
-import android.filterfw.core.FilterContext;
-import android.filterfw.core.Frame;
-import android.filterfw.core.FrameFormat;
-import android.filterfw.core.GenerateFieldPort;
-import android.filterfw.core.KeyValueMap;
-import android.filterfw.core.MutableFrameFormat;
-import android.filterfw.format.ObjectFormat;
-
-/**
- * @hide
- */
-public class StringSource extends Filter {
-
- @GenerateFieldPort(name = "stringValue")
- private String mString;
-
- private FrameFormat mOutputFormat;
-
- public StringSource(String name) {
- super(name);
- }
-
- @Override
- public void setupPorts() {
- mOutputFormat = ObjectFormat.fromClass(String.class, FrameFormat.TARGET_SIMPLE);
- addOutputPort("string", mOutputFormat);
- }
-
- @Override
- public void process(FilterContext env) {
- Frame output = env.getFrameManager().newFrame(mOutputFormat);
- output.setObjectValue(mString);
- output.setTimestamp(Frame.TIMESTAMP_UNKNOWN);
- pushOutput("string", output);
- closeOutputPort("string");
- }
-
-
-}
+++ /dev/null
-/*
- * 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.filterpacks.text;
-
-import android.filterfw.core.Filter;
-import android.filterfw.core.FilterContext;
-import android.filterfw.core.Frame;
-import android.filterfw.core.FrameFormat;
-import android.filterfw.format.ObjectFormat;
-
-/**
- * @hide
- */
-public class ToUpperCase extends Filter {
-
- private FrameFormat mOutputFormat;
-
- public ToUpperCase(String name) {
- super(name);
- }
-
- @Override
- public void setupPorts() {
- mOutputFormat = ObjectFormat.fromClass(String.class, FrameFormat.TARGET_SIMPLE);
- addMaskedInputPort("mixedcase", mOutputFormat);
- addOutputPort("uppercase", mOutputFormat);
- }
-
- @Override
- public void process(FilterContext env) {
- Frame input = pullInput("mixedcase");
- String inputString = (String)input.getObjectValue();
-
- Frame output = env.getFrameManager().newFrame(mOutputFormat);
- output.setObjectValue(inputString.toUpperCase());
-
- pushOutput("uppercase", output);
- }
-
-}
+++ /dev/null
-/**
- * @hide
- */
-package android.filterpacks.text;
+++ /dev/null
-/*
- * 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.filterpacks.ui;
-
-import android.filterfw.core.Filter;
-import android.filterfw.core.FilterContext;
-import android.filterfw.core.FilterSurfaceView;
-import android.filterfw.core.Frame;
-import android.filterfw.core.FrameFormat;
-import android.filterfw.core.GenerateFieldPort;
-import android.filterfw.core.GenerateFinalPort;
-import android.filterfw.core.GLEnvironment;
-import android.filterfw.core.GLFrame;
-import android.filterfw.core.KeyValueMap;
-import android.filterfw.core.MutableFrameFormat;
-import android.filterfw.core.NativeProgram;
-import android.filterfw.core.NativeFrame;
-import android.filterfw.core.Program;
-import android.filterfw.core.ShaderProgram;
-import android.filterfw.format.ImageFormat;
-
-import android.view.Surface;
-import android.view.SurfaceHolder;
-import android.view.SurfaceView;
-
-import android.graphics.Rect;
-
-import android.util.Log;
-
-/**
- * @hide
- */
-public class SurfaceRenderFilter extends Filter implements SurfaceHolder.Callback {
-
- private final int RENDERMODE_STRETCH = 0;
- private final int RENDERMODE_FIT = 1;
- private final int RENDERMODE_FILL_CROP = 2;
-
- /** Required. Sets the destination filter surface view for this
- * node.
- */
- @GenerateFinalPort(name = "surfaceView")
- private FilterSurfaceView mSurfaceView;
-
- /** Optional. Control how the incoming frames are rendered onto the
- * output. Default is FIT.
- * RENDERMODE_STRETCH: Just fill the output surfaceView.
- * RENDERMODE_FIT: Keep aspect ratio and fit without cropping. May
- * have black bars.
- * RENDERMODE_FILL_CROP: Keep aspect ratio and fit without black
- * bars. May crop.
- */
- @GenerateFieldPort(name = "renderMode", hasDefault = true)
- private String mRenderModeString;
-
- private boolean mIsBound = false;
-
- private ShaderProgram mProgram;
- private GLFrame mScreen;
- private int mRenderMode = RENDERMODE_FIT;
- private float mAspectRatio = 1.f;
-
- private int mScreenWidth;
- private int mScreenHeight;
-
- private boolean mLogVerbose;
- private static final String TAG = "SurfaceRenderFilter";
-
- public SurfaceRenderFilter(String name) {
- super(name);
-
- mLogVerbose = Log.isLoggable(TAG, Log.VERBOSE);
- }
-
- @Override
- public void setupPorts() {
- // Make sure we have a SurfaceView
- if (mSurfaceView == null) {
- throw new RuntimeException("NULL SurfaceView passed to SurfaceRenderFilter");
- }
-
- // Add input port
- addMaskedInputPort("frame", ImageFormat.create(ImageFormat.COLORSPACE_RGBA));
- }
-
- public void updateRenderMode() {
- if (mRenderModeString != null) {
- if (mRenderModeString.equals("stretch")) {
- mRenderMode = RENDERMODE_STRETCH;
- } else if (mRenderModeString.equals("fit")) {
- mRenderMode = RENDERMODE_FIT;
- } else if (mRenderModeString.equals("fill_crop")) {
- mRenderMode = RENDERMODE_FILL_CROP;
- } else {
- throw new RuntimeException("Unknown render mode '" + mRenderModeString + "'!");
- }
- }
- updateTargetRect();
- }
-
- @Override
- public void prepare(FilterContext context) {
- // Create identity shader to render, and make sure to render upside-down, as textures
- // are stored internally bottom-to-top.
- mProgram = ShaderProgram.createIdentity(context);
- mProgram.setSourceRect(0, 1, 1, -1);
- mProgram.setClearsOutput(true);
- mProgram.setClearColor(0.0f, 0.0f, 0.0f);
-
- updateRenderMode();
-
- // Create a frame representing the screen
- MutableFrameFormat screenFormat = ImageFormat.create(mSurfaceView.getWidth(),
- mSurfaceView.getHeight(),
- ImageFormat.COLORSPACE_RGBA,
- FrameFormat.TARGET_GPU);
- mScreen = (GLFrame)context.getFrameManager().newBoundFrame(screenFormat,
- GLFrame.EXISTING_FBO_BINDING,
- 0);
- }
-
- @Override
- public void open(FilterContext context) {
- // Bind surface view to us. This will emit a surfaceCreated and surfaceChanged call that
- // will update our screen width and height.
- mSurfaceView.unbind();
- mSurfaceView.bindToListener(this, context.getGLEnvironment());
- }
-
- @Override
- public void process(FilterContext context) {
- // Make sure we are bound to a surface before rendering
- if (!mIsBound) {
- Log.w("SurfaceRenderFilter",
- this + ": Ignoring frame as there is no surface to render to!");
- return;
- }
-
- if (mLogVerbose) Log.v(TAG, "Starting frame processing");
-
- GLEnvironment glEnv = mSurfaceView.getGLEnv();
- if (glEnv != context.getGLEnvironment()) {
- throw new RuntimeException("Surface created under different GLEnvironment!");
- }
-
-
- // Get input frame
- Frame input = pullInput("frame");
- boolean createdFrame = false;
-
- float currentAspectRatio = (float)input.getFormat().getWidth() / input.getFormat().getHeight();
- if (currentAspectRatio != mAspectRatio) {
- if (mLogVerbose) Log.v(TAG, "New aspect ratio: " + currentAspectRatio +", previously: " + mAspectRatio);
- mAspectRatio = currentAspectRatio;
- updateTargetRect();
- }
-
- // See if we need to copy to GPU
- Frame gpuFrame = null;
- if (mLogVerbose) Log.v("SurfaceRenderFilter", "Got input format: " + input.getFormat());
- int target = input.getFormat().getTarget();
- if (target != FrameFormat.TARGET_GPU) {
- gpuFrame = context.getFrameManager().duplicateFrameToTarget(input,
- FrameFormat.TARGET_GPU);
- createdFrame = true;
- } else {
- gpuFrame = input;
- }
-
- // Activate our surface
- glEnv.activateSurfaceWithId(mSurfaceView.getSurfaceId());
-
- // Process
- mProgram.process(gpuFrame, mScreen);
-
- // And swap buffers
- glEnv.swapBuffers();
-
- if (createdFrame) {
- gpuFrame.release();
- }
- }
-
- @Override
- public void fieldPortValueUpdated(String name, FilterContext context) {
- updateTargetRect();
- }
-
- @Override
- public void close(FilterContext context) {
- mSurfaceView.unbind();
- }
-
- @Override
- public void tearDown(FilterContext context) {
- if (mScreen != null) {
- mScreen.release();
- }
- }
-
- @Override
- public synchronized void surfaceCreated(SurfaceHolder holder) {
- mIsBound = true;
- }
-
- @Override
- public synchronized void surfaceChanged(SurfaceHolder holder,
- int format,
- int width,
- int height) {
- // If the screen is null, we do not care about surface changes (yet). Once we have a
- // screen object, we need to keep track of these changes.
- if (mScreen != null) {
- mScreenWidth = width;
- mScreenHeight = height;
- mScreen.setViewport(0, 0, mScreenWidth, mScreenHeight);
- updateTargetRect();
- }
- }
-
- @Override
- public synchronized void surfaceDestroyed(SurfaceHolder holder) {
- mIsBound = false;
- }
-
- private void updateTargetRect() {
- if (mScreenWidth > 0 && mScreenHeight > 0 && mProgram != null) {
- float screenAspectRatio = (float)mScreenWidth / mScreenHeight;
- float relativeAspectRatio = screenAspectRatio / mAspectRatio;
-
- switch (mRenderMode) {
- case RENDERMODE_STRETCH:
- mProgram.setTargetRect(0, 0, 1, 1);
- break;
- case RENDERMODE_FIT:
- if (relativeAspectRatio > 1.0f) {
- // Screen is wider than the camera, scale down X
- mProgram.setTargetRect(0.5f - 0.5f / relativeAspectRatio, 0.0f,
- 1.0f / relativeAspectRatio, 1.0f);
- } else {
- // Screen is taller than the camera, scale down Y
- mProgram.setTargetRect(0.0f, 0.5f - 0.5f * relativeAspectRatio,
- 1.0f, relativeAspectRatio);
- }
- break;
- case RENDERMODE_FILL_CROP:
- if (relativeAspectRatio > 1) {
- // Screen is wider than the camera, crop in Y
- mProgram.setTargetRect(0.0f, 0.5f - 0.5f * relativeAspectRatio,
- 1.0f, relativeAspectRatio);
- } else {
- // Screen is taller than the camera, crop in X
- mProgram.setTargetRect(0.5f - 0.5f / relativeAspectRatio, 0.0f,
- 1.0f / relativeAspectRatio, 1.0f);
- }
- break;
- }
- }
- }
-}
+++ /dev/null
-/*
- * 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.filterpacks.ui;
-
-import android.filterfw.core.Filter;
-import android.filterfw.core.FilterContext;
-import android.filterfw.core.Frame;
-import android.filterfw.core.FrameFormat;
-import android.filterfw.core.GenerateFieldPort;
-import android.filterfw.core.GenerateFinalPort;
-import android.filterfw.core.GLEnvironment;
-import android.filterfw.core.GLFrame;
-import android.filterfw.core.KeyValueMap;
-import android.filterfw.core.MutableFrameFormat;
-import android.filterfw.core.NativeProgram;
-import android.filterfw.core.NativeFrame;
-import android.filterfw.core.Program;
-import android.filterfw.core.ShaderProgram;
-import android.filterfw.format.ImageFormat;
-
-import android.view.Surface;
-import android.view.SurfaceHolder;
-import android.view.SurfaceView;
-
-import android.graphics.Rect;
-
-import android.util.Log;
-
-/**
- * @hide
- */
-public class SurfaceTargetFilter extends Filter {
-
- private final int RENDERMODE_STRETCH = 0;
- private final int RENDERMODE_FIT = 1;
- private final int RENDERMODE_FILL_CROP = 2;
-
- /** Required. Sets the destination surface for this node. This assumes that
- * higher-level code is ensuring that the surface is valid, and properly
- * updates Surface parameters if they change.
- */
- @GenerateFinalPort(name = "surface")
- private Surface mSurface;
-
- /** Required. Width of the output surface */
- @GenerateFieldPort(name = "owidth")
- private int mScreenWidth;
-
- /** Required. Height of the output surface */
- @GenerateFieldPort(name = "oheight")
- private int mScreenHeight;
-
- /** Optional. Control how the incoming frames are rendered onto the
- * output. Default is FIT.
- * RENDERMODE_STRETCH: Just fill the output surfaceView.
- * RENDERMODE_FIT: Keep aspect ratio and fit without cropping. May
- * have black bars.
- * RENDERMODE_FILL_CROP: Keep aspect ratio and fit without black
- * bars. May crop.
- */
- @GenerateFieldPort(name = "renderMode", hasDefault = true)
- private String mRenderModeString;
-
- private ShaderProgram mProgram;
- private GLEnvironment mGlEnv;
- private GLFrame mScreen;
- private int mRenderMode = RENDERMODE_FIT;
- private float mAspectRatio = 1.f;
-
- private int mSurfaceId = -1;
-
- private boolean mLogVerbose;
- private static final String TAG = "SurfaceRenderFilter";
-
- public SurfaceTargetFilter(String name) {
- super(name);
-
- mLogVerbose = Log.isLoggable(TAG, Log.VERBOSE);
- }
-
- @Override
- public void setupPorts() {
- // Make sure we have a Surface
- if (mSurface == null) {
- throw new RuntimeException("NULL Surface passed to SurfaceTargetFilter");
- }
-
- // Add input port
- addMaskedInputPort("frame", ImageFormat.create(ImageFormat.COLORSPACE_RGBA));
- }
-
- public void updateRenderMode() {
- if (mRenderModeString != null) {
- if (mRenderModeString.equals("stretch")) {
- mRenderMode = RENDERMODE_STRETCH;
- } else if (mRenderModeString.equals("fit")) {
- mRenderMode = RENDERMODE_FIT;
- } else if (mRenderModeString.equals("fill_crop")) {
- mRenderMode = RENDERMODE_FILL_CROP;
- } else {
- throw new RuntimeException("Unknown render mode '" + mRenderModeString + "'!");
- }
- }
- updateTargetRect();
- }
-
- @Override
- public void prepare(FilterContext context) {
- mGlEnv = context.getGLEnvironment();
-
- // Create identity shader to render, and make sure to render upside-down, as textures
- // are stored internally bottom-to-top.
- mProgram = ShaderProgram.createIdentity(context);
- mProgram.setSourceRect(0, 1, 1, -1);
- mProgram.setClearsOutput(true);
- mProgram.setClearColor(0.0f, 0.0f, 0.0f);
-
- MutableFrameFormat screenFormat = ImageFormat.create(mScreenWidth,
- mScreenHeight,
- ImageFormat.COLORSPACE_RGBA,
- FrameFormat.TARGET_GPU);
- mScreen = (GLFrame)context.getFrameManager().newBoundFrame(screenFormat,
- GLFrame.EXISTING_FBO_BINDING,
- 0);
-
- // Set up cropping
- updateRenderMode();
- }
-
- @Override
- public void open(FilterContext context) {
- registerSurface();
- }
-
- @Override
- public void process(FilterContext context) {
- if (mLogVerbose) Log.v(TAG, "Starting frame processing");
-
- // Get input frame
- Frame input = pullInput("frame");
- boolean createdFrame = false;
-
- float currentAspectRatio = (float)input.getFormat().getWidth() / input.getFormat().getHeight();
- if (currentAspectRatio != mAspectRatio) {
- if (mLogVerbose) Log.v(TAG, "New aspect ratio: " + currentAspectRatio +", previously: " + mAspectRatio);
- mAspectRatio = currentAspectRatio;
- updateTargetRect();
- }
-
- // See if we need to copy to GPU
- Frame gpuFrame = null;
- if (mLogVerbose) Log.v("SurfaceRenderFilter", "Got input format: " + input.getFormat());
- int target = input.getFormat().getTarget();
- if (target != FrameFormat.TARGET_GPU) {
- gpuFrame = context.getFrameManager().duplicateFrameToTarget(input,
- FrameFormat.TARGET_GPU);
- createdFrame = true;
- } else {
- gpuFrame = input;
- }
-
- // Activate our surface
- mGlEnv.activateSurfaceWithId(mSurfaceId);
-
- // Process
- mProgram.process(gpuFrame, mScreen);
-
- // And swap buffers
- mGlEnv.swapBuffers();
-
- if (createdFrame) {
- gpuFrame.release();
- }
- }
-
- @Override
- public void fieldPortValueUpdated(String name, FilterContext context) {
- mScreen.setViewport(0, 0, mScreenWidth, mScreenHeight);
- updateTargetRect();
- }
-
- @Override
- public void close(FilterContext context) {
- unregisterSurface();
- }
-
- @Override
- public void tearDown(FilterContext context) {
- if (mScreen != null) {
- mScreen.release();
- }
- }
-
- private void updateTargetRect() {
- if (mScreenWidth > 0 && mScreenHeight > 0 && mProgram != null) {
- float screenAspectRatio = (float)mScreenWidth / mScreenHeight;
- float relativeAspectRatio = screenAspectRatio / mAspectRatio;
-
- switch (mRenderMode) {
- case RENDERMODE_STRETCH:
- mProgram.setTargetRect(0, 0, 1, 1);
- break;
- case RENDERMODE_FIT:
- if (relativeAspectRatio > 1.0f) {
- // Screen is wider than the camera, scale down X
- mProgram.setTargetRect(0.5f - 0.5f / relativeAspectRatio, 0.0f,
- 1.0f / relativeAspectRatio, 1.0f);
- } else {
- // Screen is taller than the camera, scale down Y
- mProgram.setTargetRect(0.0f, 0.5f - 0.5f * relativeAspectRatio,
- 1.0f, relativeAspectRatio);
- }
- break;
- case RENDERMODE_FILL_CROP:
- if (relativeAspectRatio > 1) {
- // Screen is wider than the camera, crop in Y
- mProgram.setTargetRect(0.0f, 0.5f - 0.5f * relativeAspectRatio,
- 1.0f, relativeAspectRatio);
- } else {
- // Screen is taller than the camera, crop in X
- mProgram.setTargetRect(0.5f - 0.5f / relativeAspectRatio, 0.0f,
- 1.0f / relativeAspectRatio, 1.0f);
- }
- break;
- }
- }
- }
-
- private void registerSurface() {
- mSurfaceId = mGlEnv.registerSurface(mSurface);
- if (mSurfaceId < 0) {
- throw new RuntimeException("Could not register Surface: " + mSurface);
- }
- }
-
- private void unregisterSurface() {
- if (mSurfaceId > 0) {
- mGlEnv.unregisterSurfaceId(mSurfaceId);
- }
- }
-
-}
+++ /dev/null
-/**
- * @hide
- */
-package android.filterpacks.ui;
+++ /dev/null
-/*
- * 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.filterpacks.videoproc;
-
-import android.filterfw.core.Filter;
-import android.filterfw.core.FilterContext;
-import android.filterfw.core.GenerateFieldPort;
-import android.filterfw.core.GenerateFinalPort;
-import android.filterfw.core.Frame;
-import android.filterfw.core.GLFrame;
-import android.filterfw.core.FrameFormat;
-import android.filterfw.core.MutableFrameFormat;
-import android.filterfw.core.Program;
-import android.filterfw.core.ShaderProgram;
-import android.filterfw.format.ImageFormat;
-import android.opengl.GLES20;
-import android.os.SystemClock;
-import android.util.Log;
-
-import java.lang.ArrayIndexOutOfBoundsException;
-import java.lang.Math;
-import java.util.Arrays;
-import java.nio.ByteBuffer;
-
-/**
- * @hide
- */
-public class BackDropperFilter extends Filter {
- /** User-visible parameters */
-
- private final int BACKGROUND_STRETCH = 0;
- private final int BACKGROUND_FIT = 1;
- private final int BACKGROUND_FILL_CROP = 2;
-
- @GenerateFieldPort(name = "backgroundFitMode", hasDefault = true)
- private int mBackgroundFitMode = BACKGROUND_FILL_CROP;
- @GenerateFieldPort(name = "learningDuration", hasDefault = true)
- private int mLearningDuration = DEFAULT_LEARNING_DURATION;
- @GenerateFieldPort(name = "learningVerifyDuration", hasDefault = true)
- private int mLearningVerifyDuration = DEFAULT_LEARNING_VERIFY_DURATION;
- @GenerateFieldPort(name = "acceptStddev", hasDefault = true)
- private float mAcceptStddev = DEFAULT_ACCEPT_STDDEV;
- @GenerateFieldPort(name = "hierLrgScale", hasDefault = true)
- private float mHierarchyLrgScale = DEFAULT_HIER_LRG_SCALE;
- @GenerateFieldPort(name = "hierMidScale", hasDefault = true)
- private float mHierarchyMidScale = DEFAULT_HIER_MID_SCALE;
- @GenerateFieldPort(name = "hierSmlScale", hasDefault = true)
- private float mHierarchySmlScale = DEFAULT_HIER_SML_SCALE;
-
- // Dimensions of foreground / background mask. Optimum value should take into account only
- // image contents, NOT dimensions of input video stream.
- @GenerateFieldPort(name = "maskWidthExp", hasDefault = true)
- private int mMaskWidthExp = DEFAULT_MASK_WIDTH_EXPONENT;
- @GenerateFieldPort(name = "maskHeightExp", hasDefault = true)
- private int mMaskHeightExp = DEFAULT_MASK_HEIGHT_EXPONENT;
-
- // Levels at which to compute foreground / background decision. Think of them as are deltas
- // SUBTRACTED from maskWidthExp and maskHeightExp.
- @GenerateFieldPort(name = "hierLrgExp", hasDefault = true)
- private int mHierarchyLrgExp = DEFAULT_HIER_LRG_EXPONENT;
- @GenerateFieldPort(name = "hierMidExp", hasDefault = true)
- private int mHierarchyMidExp = DEFAULT_HIER_MID_EXPONENT;
- @GenerateFieldPort(name = "hierSmlExp", hasDefault = true)
- private int mHierarchySmlExp = DEFAULT_HIER_SML_EXPONENT;
-
- @GenerateFieldPort(name = "lumScale", hasDefault = true)
- private float mLumScale = DEFAULT_Y_SCALE_FACTOR;
- @GenerateFieldPort(name = "chromaScale", hasDefault = true)
- private float mChromaScale = DEFAULT_UV_SCALE_FACTOR;
- @GenerateFieldPort(name = "maskBg", hasDefault = true)
- private float mMaskBg = DEFAULT_MASK_BLEND_BG;
- @GenerateFieldPort(name = "maskFg", hasDefault = true)
- private float mMaskFg = DEFAULT_MASK_BLEND_FG;
- @GenerateFieldPort(name = "exposureChange", hasDefault = true)
- private float mExposureChange = DEFAULT_EXPOSURE_CHANGE;
- @GenerateFieldPort(name = "whitebalanceredChange", hasDefault = true)
- private float mWhiteBalanceRedChange = DEFAULT_WHITE_BALANCE_RED_CHANGE;
- @GenerateFieldPort(name = "whitebalanceblueChange", hasDefault = true)
- private float mWhiteBalanceBlueChange = DEFAULT_WHITE_BALANCE_BLUE_CHANGE;
- @GenerateFieldPort(name = "autowbToggle", hasDefault = true)
- private int mAutoWBToggle = DEFAULT_WHITE_BALANCE_TOGGLE;
-
- // TODO: These are not updatable:
- @GenerateFieldPort(name = "learningAdaptRate", hasDefault = true)
- private float mAdaptRateLearning = DEFAULT_LEARNING_ADAPT_RATE;
- @GenerateFieldPort(name = "adaptRateBg", hasDefault = true)
- private float mAdaptRateBg = DEFAULT_ADAPT_RATE_BG;
- @GenerateFieldPort(name = "adaptRateFg", hasDefault = true)
- private float mAdaptRateFg = DEFAULT_ADAPT_RATE_FG;
- @GenerateFieldPort(name = "maskVerifyRate", hasDefault = true)
- private float mVerifyRate = DEFAULT_MASK_VERIFY_RATE;
- @GenerateFieldPort(name = "learningDoneListener", hasDefault = true)
- private LearningDoneListener mLearningDoneListener = null;
-
- @GenerateFieldPort(name = "useTheForce", hasDefault = true)
- private boolean mUseTheForce = false;
-
- @GenerateFinalPort(name = "provideDebugOutputs", hasDefault = true)
- private boolean mProvideDebugOutputs = false;
-
- // Whether to mirror the background or not. For ex, the Camera app
- // would mirror the preview for the front camera
- @GenerateFieldPort(name = "mirrorBg", hasDefault = true)
- private boolean mMirrorBg = false;
-
- // The orientation of the display. This will change the flipping
- // coordinates, if we were to mirror the background
- @GenerateFieldPort(name = "orientation", hasDefault = true)
- private int mOrientation = 0;
-
- /** Default algorithm parameter values, for non-shader use */
-
- // Frame count for learning bg model
- private static final int DEFAULT_LEARNING_DURATION = 40;
- // Frame count for learning verification
- private static final int DEFAULT_LEARNING_VERIFY_DURATION = 10;
- // Maximum distance (in standard deviations) for considering a pixel as background
- private static final float DEFAULT_ACCEPT_STDDEV = 0.85f;
- // Variance threshold scale factor for large scale of hierarchy
- private static final float DEFAULT_HIER_LRG_SCALE = 0.7f;
- // Variance threshold scale factor for medium scale of hierarchy
- private static final float DEFAULT_HIER_MID_SCALE = 0.6f;
- // Variance threshold scale factor for small scale of hierarchy
- private static final float DEFAULT_HIER_SML_SCALE = 0.5f;
- // Width of foreground / background mask.
- private static final int DEFAULT_MASK_WIDTH_EXPONENT = 8;
- // Height of foreground / background mask.
- private static final int DEFAULT_MASK_HEIGHT_EXPONENT = 8;
- // Area over which to average for large scale (length in pixels = 2^HIERARCHY_*_EXPONENT)
- private static final int DEFAULT_HIER_LRG_EXPONENT = 3;
- // Area over which to average for medium scale
- private static final int DEFAULT_HIER_MID_EXPONENT = 2;
- // Area over which to average for small scale
- private static final int DEFAULT_HIER_SML_EXPONENT = 0;
- // Scale factor for luminance channel in distance calculations (larger = more significant)
- private static final float DEFAULT_Y_SCALE_FACTOR = 0.40f;
- // Scale factor for chroma channels in distance calculations
- private static final float DEFAULT_UV_SCALE_FACTOR = 1.35f;
- // Mask value to start blending away from background
- private static final float DEFAULT_MASK_BLEND_BG = 0.65f;
- // Mask value to start blending away from foreground
- private static final float DEFAULT_MASK_BLEND_FG = 0.95f;
- // Exposure stop number to change the brightness of foreground
- private static final float DEFAULT_EXPOSURE_CHANGE = 1.0f;
- // White balance change in Red channel for foreground
- private static final float DEFAULT_WHITE_BALANCE_RED_CHANGE = 0.0f;
- // White balance change in Blue channel for foreground
- private static final float DEFAULT_WHITE_BALANCE_BLUE_CHANGE = 0.0f;
- // Variable to control automatic white balance effect
- // 0.f -> Auto WB is off; 1.f-> Auto WB is on
- private static final int DEFAULT_WHITE_BALANCE_TOGGLE = 0;
-
- // Default rate at which to learn bg model during learning period
- private static final float DEFAULT_LEARNING_ADAPT_RATE = 0.2f;
- // Default rate at which to learn bg model from new background pixels
- private static final float DEFAULT_ADAPT_RATE_BG = 0.0f;
- // Default rate at which to learn bg model from new foreground pixels
- private static final float DEFAULT_ADAPT_RATE_FG = 0.0f;
- // Default rate at which to verify whether background is stable
- private static final float DEFAULT_MASK_VERIFY_RATE = 0.25f;
- // Default rate at which to verify whether background is stable
- private static final int DEFAULT_LEARNING_DONE_THRESHOLD = 20;
-
- // Default 3x3 matrix, column major, for fitting background 1:1
- private static final float[] DEFAULT_BG_FIT_TRANSFORM = new float[] {
- 1.0f, 0.0f, 0.0f,
- 0.0f, 1.0f, 0.0f,
- 0.0f, 0.0f, 1.0f
- };
-
- /** Default algorithm parameter values, for shader use */
-
- // Area over which to blur binary mask values (length in pixels = 2^MASK_SMOOTH_EXPONENT)
- private static final String MASK_SMOOTH_EXPONENT = "2.0";
- // Scale value for mapping variance distance to fit nicely to 0-1, 8-bit
- private static final String DISTANCE_STORAGE_SCALE = "0.6";
- // Scale value for mapping variance to fit nicely to 0-1, 8-bit
- private static final String VARIANCE_STORAGE_SCALE = "5.0";
- // Default scale of auto white balance parameters
- private static final String DEFAULT_AUTO_WB_SCALE = "0.25";
- // Minimum variance (0-255 scale)
- private static final String MIN_VARIANCE = "3.0";
- // Column-major array for 4x4 matrix converting RGB to YCbCr, JPEG definition (no pedestal)
- private static final String RGB_TO_YUV_MATRIX = "0.299, -0.168736, 0.5, 0.000, " +
- "0.587, -0.331264, -0.418688, 0.000, " +
- "0.114, 0.5, -0.081312, 0.000, " +
- "0.000, 0.5, 0.5, 1.000 ";
- /** Stream names */
-
- private static final String[] mInputNames = {"video",
- "background"};
-
- private static final String[] mOutputNames = {"video"};
-
- private static final String[] mDebugOutputNames = {"debug1",
- "debug2"};
-
- /** Other private variables */
-
- private FrameFormat mOutputFormat;
- private MutableFrameFormat mMemoryFormat;
- private MutableFrameFormat mMaskFormat;
- private MutableFrameFormat mAverageFormat;
-
- private final boolean mLogVerbose;
- private static final String TAG = "BackDropperFilter";
-
- /** Shader source code */
-
- // Shared uniforms and utility functions
- private static String mSharedUtilShader =
- "precision mediump float;\n" +
- "uniform float fg_adapt_rate;\n" +
- "uniform float bg_adapt_rate;\n" +
- "const mat4 coeff_yuv = mat4(" + RGB_TO_YUV_MATRIX + ");\n" +
- "const float dist_scale = " + DISTANCE_STORAGE_SCALE + ";\n" +
- "const float inv_dist_scale = 1. / dist_scale;\n" +
- "const float var_scale=" + VARIANCE_STORAGE_SCALE + ";\n" +
- "const float inv_var_scale = 1. / var_scale;\n" +
- "const float min_variance = inv_var_scale *" + MIN_VARIANCE + "/ 256.;\n" +
- "const float auto_wb_scale = " + DEFAULT_AUTO_WB_SCALE + ";\n" +
- "\n" +
- // Variance distance in luminance between current pixel and background model
- "float gauss_dist_y(float y, float mean, float variance) {\n" +
- " float dist = (y - mean) * (y - mean) / variance;\n" +
- " return dist;\n" +
- "}\n" +
- // Sum of variance distances in chroma between current pixel and background
- // model
- "float gauss_dist_uv(vec2 uv, vec2 mean, vec2 variance) {\n" +
- " vec2 dist = (uv - mean) * (uv - mean) / variance;\n" +
- " return dist.r + dist.g;\n" +
- "}\n" +
- // Select learning rate for pixel based on smoothed decision mask alpha
- "float local_adapt_rate(float alpha) {\n" +
- " return mix(bg_adapt_rate, fg_adapt_rate, alpha);\n" +
- "}\n" +
- "\n";
-
- // Distance calculation shader. Calculates a distance metric between the foreground and the
- // current background model, in both luminance and in chroma (yuv space). Distance is
- // measured in variances from the mean background value. For chroma, the distance is the sum
- // of the two individual color channel distances. The distances are output on the b and alpha
- // channels, r and g are for debug information.
- // Inputs:
- // tex_sampler_0: Mip-map for foreground (live) video frame.
- // tex_sampler_1: Background mean mask.
- // tex_sampler_2: Background variance mask.
- // subsample_level: Level on foreground frame's mip-map.
- private static final String mBgDistanceShader =
- "uniform sampler2D tex_sampler_0;\n" +
- "uniform sampler2D tex_sampler_1;\n" +
- "uniform sampler2D tex_sampler_2;\n" +
- "uniform float subsample_level;\n" +
- "varying vec2 v_texcoord;\n" +
- "void main() {\n" +
- " vec4 fg_rgb = texture2D(tex_sampler_0, v_texcoord, subsample_level);\n" +
- " vec4 fg = coeff_yuv * vec4(fg_rgb.rgb, 1.);\n" +
- " vec4 mean = texture2D(tex_sampler_1, v_texcoord);\n" +
- " vec4 variance = inv_var_scale * texture2D(tex_sampler_2, v_texcoord);\n" +
- "\n" +
- " float dist_y = gauss_dist_y(fg.r, mean.r, variance.r);\n" +
- " float dist_uv = gauss_dist_uv(fg.gb, mean.gb, variance.gb);\n" +
- " gl_FragColor = vec4(0.5*fg.rg, dist_scale*dist_y, dist_scale*dist_uv);\n" +
- "}\n";
-
- // Foreground/background mask decision shader. Decides whether a frame is in the foreground or
- // the background using a hierarchical threshold on the distance. Binary foreground/background
- // mask is placed in the alpha channel. The RGB channels contain debug information.
- private static final String mBgMaskShader =
- "uniform sampler2D tex_sampler_0;\n" +
- "uniform float accept_variance;\n" +
- "uniform vec2 yuv_weights;\n" +
- "uniform float scale_lrg;\n" +
- "uniform float scale_mid;\n" +
- "uniform float scale_sml;\n" +
- "uniform float exp_lrg;\n" +
- "uniform float exp_mid;\n" +
- "uniform float exp_sml;\n" +
- "varying vec2 v_texcoord;\n" +
- // Decide whether pixel is foreground or background based on Y and UV
- // distance and maximum acceptable variance.
- // yuv_weights.x is smaller than yuv_weights.y to discount the influence of shadow
- "bool is_fg(vec2 dist_yc, float accept_variance) {\n" +
- " return ( dot(yuv_weights, dist_yc) >= accept_variance );\n" +
- "}\n" +
- "void main() {\n" +
- " vec4 dist_lrg_sc = texture2D(tex_sampler_0, v_texcoord, exp_lrg);\n" +
- " vec4 dist_mid_sc = texture2D(tex_sampler_0, v_texcoord, exp_mid);\n" +
- " vec4 dist_sml_sc = texture2D(tex_sampler_0, v_texcoord, exp_sml);\n" +
- " vec2 dist_lrg = inv_dist_scale * dist_lrg_sc.ba;\n" +
- " vec2 dist_mid = inv_dist_scale * dist_mid_sc.ba;\n" +
- " vec2 dist_sml = inv_dist_scale * dist_sml_sc.ba;\n" +
- " vec2 norm_dist = 0.75 * dist_sml / accept_variance;\n" + // For debug viz
- " bool is_fg_lrg = is_fg(dist_lrg, accept_variance * scale_lrg);\n" +
- " bool is_fg_mid = is_fg_lrg || is_fg(dist_mid, accept_variance * scale_mid);\n" +
- " float is_fg_sml =\n" +
- " float(is_fg_mid || is_fg(dist_sml, accept_variance * scale_sml));\n" +
- " float alpha = 0.5 * is_fg_sml + 0.3 * float(is_fg_mid) + 0.2 * float(is_fg_lrg);\n" +
- " gl_FragColor = vec4(alpha, norm_dist, is_fg_sml);\n" +
- "}\n";
-
- // Automatic White Balance parameter decision shader
- // Use the Gray World assumption that in a white balance corrected image, the average of R, G, B
- // channel will be a common gray value.
- // To match the white balance of foreground and background, the average of R, G, B channel of
- // two videos should match.
- // Inputs:
- // tex_sampler_0: Mip-map for foreground (live) video frame.
- // tex_sampler_1: Mip-map for background (playback) video frame.
- // pyramid_depth: Depth of input frames' mip-maps.
- private static final String mAutomaticWhiteBalance =
- "uniform sampler2D tex_sampler_0;\n" +
- "uniform sampler2D tex_sampler_1;\n" +
- "uniform float pyramid_depth;\n" +
- "uniform bool autowb_toggle;\n" +
- "varying vec2 v_texcoord;\n" +
- "void main() {\n" +
- " vec4 mean_video = texture2D(tex_sampler_0, v_texcoord, pyramid_depth);\n"+
- " vec4 mean_bg = texture2D(tex_sampler_1, v_texcoord, pyramid_depth);\n" +
- // If Auto WB is toggled off, the return texture will be a unicolor texture of value 1
- // If Auto WB is toggled on, the return texture will be a unicolor texture with
- // adjustment parameters for R and B channels stored in the corresponding channel
- " float green_normalizer = mean_video.g / mean_bg.g;\n"+
- " vec4 adjusted_value = vec4(mean_bg.r / mean_video.r * green_normalizer, 1., \n" +
- " mean_bg.b / mean_video.b * green_normalizer, 1.) * auto_wb_scale; \n" +
- " gl_FragColor = autowb_toggle ? adjusted_value : vec4(auto_wb_scale);\n" +
- "}\n";
-
-
- // Background subtraction shader. Uses a mipmap of the binary mask map to blend smoothly between
- // foreground and background
- // Inputs:
- // tex_sampler_0: Foreground (live) video frame.
- // tex_sampler_1: Background (playback) video frame.
- // tex_sampler_2: Foreground/background mask.
- // tex_sampler_3: Auto white-balance factors.
- private static final String mBgSubtractShader =
- "uniform mat3 bg_fit_transform;\n" +
- "uniform float mask_blend_bg;\n" +
- "uniform float mask_blend_fg;\n" +
- "uniform float exposure_change;\n" +
- "uniform float whitebalancered_change;\n" +
- "uniform float whitebalanceblue_change;\n" +
- "uniform sampler2D tex_sampler_0;\n" +
- "uniform sampler2D tex_sampler_1;\n" +
- "uniform sampler2D tex_sampler_2;\n" +
- "uniform sampler2D tex_sampler_3;\n" +
- "varying vec2 v_texcoord;\n" +
- "void main() {\n" +
- " vec2 bg_texcoord = (bg_fit_transform * vec3(v_texcoord, 1.)).xy;\n" +
- " vec4 bg_rgb = texture2D(tex_sampler_1, bg_texcoord);\n" +
- // The foreground texture is modified by multiplying both manual and auto white balance changes in R and B
- // channel and multiplying exposure change in all R, G, B channels.
- " vec4 wb_auto_scale = texture2D(tex_sampler_3, v_texcoord) * exposure_change / auto_wb_scale;\n" +
- " vec4 wb_manual_scale = vec4(1. + whitebalancered_change, 1., 1. + whitebalanceblue_change, 1.);\n" +
- " vec4 fg_rgb = texture2D(tex_sampler_0, v_texcoord);\n" +
- " vec4 fg_adjusted = fg_rgb * wb_manual_scale * wb_auto_scale;\n"+
- " vec4 mask = texture2D(tex_sampler_2, v_texcoord, \n" +
- " " + MASK_SMOOTH_EXPONENT + ");\n" +
- " float alpha = smoothstep(mask_blend_bg, mask_blend_fg, mask.a);\n" +
- " gl_FragColor = mix(bg_rgb, fg_adjusted, alpha);\n";
-
- // May the Force... Makes the foreground object translucent blue, with a bright
- // blue-white outline
- private static final String mBgSubtractForceShader =
- " vec4 ghost_rgb = (fg_adjusted * 0.7 + vec4(0.3,0.3,0.4,0.))*0.65 + \n" +
- " 0.35*bg_rgb;\n" +
- " float glow_start = 0.75 * mask_blend_bg; \n"+
- " float glow_max = mask_blend_bg; \n"+
- " gl_FragColor = mask.a < glow_start ? bg_rgb : \n" +
- " mask.a < glow_max ? mix(bg_rgb, vec4(0.9,0.9,1.0,1.0), \n" +
- " (mask.a - glow_start) / (glow_max - glow_start) ) : \n" +
- " mask.a < mask_blend_fg ? mix(vec4(0.9,0.9,1.0,1.0), ghost_rgb, \n" +
- " (mask.a - glow_max) / (mask_blend_fg - glow_max) ) : \n" +
- " ghost_rgb;\n" +
- "}\n";
-
- // Background model mean update shader. Skews the current model mean toward the most recent pixel
- // value for a pixel, weighted by the learning rate and by whether the pixel is classified as
- // foreground or background.
- // Inputs:
- // tex_sampler_0: Mip-map for foreground (live) video frame.
- // tex_sampler_1: Background mean mask.
- // tex_sampler_2: Foreground/background mask.
- // subsample_level: Level on foreground frame's mip-map.
- private static final String mUpdateBgModelMeanShader =
- "uniform sampler2D tex_sampler_0;\n" +
- "uniform sampler2D tex_sampler_1;\n" +
- "uniform sampler2D tex_sampler_2;\n" +
- "uniform float subsample_level;\n" +
- "varying vec2 v_texcoord;\n" +
- "void main() {\n" +
- " vec4 fg_rgb = texture2D(tex_sampler_0, v_texcoord, subsample_level);\n" +
- " vec4 fg = coeff_yuv * vec4(fg_rgb.rgb, 1.);\n" +
- " vec4 mean = texture2D(tex_sampler_1, v_texcoord);\n" +
- " vec4 mask = texture2D(tex_sampler_2, v_texcoord, \n" +
- " " + MASK_SMOOTH_EXPONENT + ");\n" +
- "\n" +
- " float alpha = local_adapt_rate(mask.a);\n" +
- " vec4 new_mean = mix(mean, fg, alpha);\n" +
- " gl_FragColor = new_mean;\n" +
- "}\n";
-
- // Background model variance update shader. Skews the current model variance toward the most
- // recent variance for the pixel, weighted by the learning rate and by whether the pixel is
- // classified as foreground or background.
- // Inputs:
- // tex_sampler_0: Mip-map for foreground (live) video frame.
- // tex_sampler_1: Background mean mask.
- // tex_sampler_2: Background variance mask.
- // tex_sampler_3: Foreground/background mask.
- // subsample_level: Level on foreground frame's mip-map.
- // TODO: to improve efficiency, use single mark for mean + variance, then merge this into
- // mUpdateBgModelMeanShader.
- private static final String mUpdateBgModelVarianceShader =
- "uniform sampler2D tex_sampler_0;\n" +
- "uniform sampler2D tex_sampler_1;\n" +
- "uniform sampler2D tex_sampler_2;\n" +
- "uniform sampler2D tex_sampler_3;\n" +
- "uniform float subsample_level;\n" +
- "varying vec2 v_texcoord;\n" +
- "void main() {\n" +
- " vec4 fg_rgb = texture2D(tex_sampler_0, v_texcoord, subsample_level);\n" +
- " vec4 fg = coeff_yuv * vec4(fg_rgb.rgb, 1.);\n" +
- " vec4 mean = texture2D(tex_sampler_1, v_texcoord);\n" +
- " vec4 variance = inv_var_scale * texture2D(tex_sampler_2, v_texcoord);\n" +
- " vec4 mask = texture2D(tex_sampler_3, v_texcoord, \n" +
- " " + MASK_SMOOTH_EXPONENT + ");\n" +
- "\n" +
- " float alpha = local_adapt_rate(mask.a);\n" +
- " vec4 cur_variance = (fg-mean)*(fg-mean);\n" +
- " vec4 new_variance = mix(variance, cur_variance, alpha);\n" +
- " new_variance = max(new_variance, vec4(min_variance));\n" +
- " gl_FragColor = var_scale * new_variance;\n" +
- "}\n";
-
- // Background verification shader. Skews the current background verification mask towards the
- // most recent frame, weighted by the learning rate.
- private static final String mMaskVerifyShader =
- "uniform sampler2D tex_sampler_0;\n" +
- "uniform sampler2D tex_sampler_1;\n" +
- "uniform float verify_rate;\n" +
- "varying vec2 v_texcoord;\n" +
- "void main() {\n" +
- " vec4 lastmask = texture2D(tex_sampler_0, v_texcoord);\n" +
- " vec4 mask = texture2D(tex_sampler_1, v_texcoord);\n" +
- " float newmask = mix(lastmask.a, mask.a, verify_rate);\n" +
- " gl_FragColor = vec4(0., 0., 0., newmask);\n" +
- "}\n";
-
- /** Shader program objects */
-
- private ShaderProgram mBgDistProgram;
- private ShaderProgram mBgMaskProgram;
- private ShaderProgram mBgSubtractProgram;
- private ShaderProgram mBgUpdateMeanProgram;
- private ShaderProgram mBgUpdateVarianceProgram;
- private ShaderProgram mCopyOutProgram;
- private ShaderProgram mAutomaticWhiteBalanceProgram;
- private ShaderProgram mMaskVerifyProgram;
- private ShaderProgram copyShaderProgram;
-
- /** Background model storage */
-
- private boolean mPingPong;
- private GLFrame mBgMean[];
- private GLFrame mBgVariance[];
- private GLFrame mMaskVerify[];
- private GLFrame mDistance;
- private GLFrame mAutoWB;
- private GLFrame mMask;
- private GLFrame mVideoInput;
- private GLFrame mBgInput;
- private GLFrame mMaskAverage;
-
- /** Overall filter state */
-
- private boolean isOpen;
- private int mFrameCount;
- private boolean mStartLearning;
- private boolean mBackgroundFitModeChanged;
- private float mRelativeAspect;
- private int mPyramidDepth;
- private int mSubsampleLevel;
-
- /** Learning listener object */
-
- public interface LearningDoneListener {
- public void onLearningDone(BackDropperFilter filter);
- }
-
- /** Public Filter methods */
-
- public BackDropperFilter(String name) {
- super(name);
-
- mLogVerbose = Log.isLoggable(TAG, Log.VERBOSE);
- }
-
- @Override
- public void setupPorts() {
- // Inputs.
- // TODO: Target should be GPU, but relaxed for now.
- FrameFormat imageFormat = ImageFormat.create(ImageFormat.COLORSPACE_RGBA,
- FrameFormat.TARGET_UNSPECIFIED);
- for (String inputName : mInputNames) {
- addMaskedInputPort(inputName, imageFormat);
- }
- // Normal outputs
- for (String outputName : mOutputNames) {
- addOutputBasedOnInput(outputName, "video");
- }
-
- // Debug outputs
- if (mProvideDebugOutputs) {
- for (String outputName : mDebugOutputNames) {
- addOutputBasedOnInput(outputName, "video");
- }
- }
- }
-
- @Override
- public FrameFormat getOutputFormat(String portName, FrameFormat inputFormat) {
- // Create memory format based on video input.
- MutableFrameFormat format = inputFormat.mutableCopy();
- // Is this a debug output port? If so, leave dimensions unspecified.
- if (!Arrays.asList(mOutputNames).contains(portName)) {
- format.setDimensions(FrameFormat.SIZE_UNSPECIFIED, FrameFormat.SIZE_UNSPECIFIED);
- }
- return format;
- }
-
- private boolean createMemoryFormat(FrameFormat inputFormat) {
- // We can't resize because that would require re-learning.
- if (mMemoryFormat != null) {
- return false;
- }
-
- if (inputFormat.getWidth() == FrameFormat.SIZE_UNSPECIFIED ||
- inputFormat.getHeight() == FrameFormat.SIZE_UNSPECIFIED) {
- throw new RuntimeException("Attempting to process input frame with unknown size");
- }
-
- mMaskFormat = inputFormat.mutableCopy();
- int maskWidth = (int)Math.pow(2, mMaskWidthExp);
- int maskHeight = (int)Math.pow(2, mMaskHeightExp);
- mMaskFormat.setDimensions(maskWidth, maskHeight);
-
- mPyramidDepth = Math.max(mMaskWidthExp, mMaskHeightExp);
- mMemoryFormat = mMaskFormat.mutableCopy();
- int widthExp = Math.max(mMaskWidthExp, pyramidLevel(inputFormat.getWidth()));
- int heightExp = Math.max(mMaskHeightExp, pyramidLevel(inputFormat.getHeight()));
- mPyramidDepth = Math.max(widthExp, heightExp);
- int memWidth = Math.max(maskWidth, (int)Math.pow(2, widthExp));
- int memHeight = Math.max(maskHeight, (int)Math.pow(2, heightExp));
- mMemoryFormat.setDimensions(memWidth, memHeight);
- mSubsampleLevel = mPyramidDepth - Math.max(mMaskWidthExp, mMaskHeightExp);
-
- if (mLogVerbose) {
- Log.v(TAG, "Mask frames size " + maskWidth + " x " + maskHeight);
- Log.v(TAG, "Pyramid levels " + widthExp + " x " + heightExp);
- Log.v(TAG, "Memory frames size " + memWidth + " x " + memHeight);
- }
-
- mAverageFormat = inputFormat.mutableCopy();
- mAverageFormat.setDimensions(1,1);
- return true;
- }
-
- public void prepare(FilterContext context){
- if (mLogVerbose) Log.v(TAG, "Preparing BackDropperFilter!");
-
- mBgMean = new GLFrame[2];
- mBgVariance = new GLFrame[2];
- mMaskVerify = new GLFrame[2];
- copyShaderProgram = ShaderProgram.createIdentity(context);
- }
-
- private void allocateFrames(FrameFormat inputFormat, FilterContext context) {
- if (!createMemoryFormat(inputFormat)) {
- return; // All set.
- }
- if (mLogVerbose) Log.v(TAG, "Allocating BackDropperFilter frames");
-
- // Create initial background model values
- int numBytes = mMaskFormat.getSize();
- byte[] initialBgMean = new byte[numBytes];
- byte[] initialBgVariance = new byte[numBytes];
- byte[] initialMaskVerify = new byte[numBytes];
- for (int i = 0; i < numBytes; i++) {
- initialBgMean[i] = (byte)128;
- initialBgVariance[i] = (byte)10;
- initialMaskVerify[i] = (byte)0;
- }
-
- // Get frames to store background model in
- for (int i = 0; i < 2; i++) {
- mBgMean[i] = (GLFrame)context.getFrameManager().newFrame(mMaskFormat);
- mBgMean[i].setData(initialBgMean, 0, numBytes);
-
- mBgVariance[i] = (GLFrame)context.getFrameManager().newFrame(mMaskFormat);
- mBgVariance[i].setData(initialBgVariance, 0, numBytes);
-
- mMaskVerify[i] = (GLFrame)context.getFrameManager().newFrame(mMaskFormat);
- mMaskVerify[i].setData(initialMaskVerify, 0, numBytes);
- }
-
- // Get frames to store other textures in
- if (mLogVerbose) Log.v(TAG, "Done allocating texture for Mean and Variance objects!");
-
- mDistance = (GLFrame)context.getFrameManager().newFrame(mMaskFormat);
- mMask = (GLFrame)context.getFrameManager().newFrame(mMaskFormat);
- mAutoWB = (GLFrame)context.getFrameManager().newFrame(mAverageFormat);
- mVideoInput = (GLFrame)context.getFrameManager().newFrame(mMemoryFormat);
- mBgInput = (GLFrame)context.getFrameManager().newFrame(mMemoryFormat);
- mMaskAverage = (GLFrame)context.getFrameManager().newFrame(mAverageFormat);
-
- // Create shader programs
- mBgDistProgram = new ShaderProgram(context, mSharedUtilShader + mBgDistanceShader);
- mBgDistProgram.setHostValue("subsample_level", (float)mSubsampleLevel);
-
- mBgMaskProgram = new ShaderProgram(context, mSharedUtilShader + mBgMaskShader);
- mBgMaskProgram.setHostValue("accept_variance", mAcceptStddev * mAcceptStddev);
- float[] yuvWeights = { mLumScale, mChromaScale };
- mBgMaskProgram.setHostValue("yuv_weights", yuvWeights );
- mBgMaskProgram.setHostValue("scale_lrg", mHierarchyLrgScale);
- mBgMaskProgram.setHostValue("scale_mid", mHierarchyMidScale);
- mBgMaskProgram.setHostValue("scale_sml", mHierarchySmlScale);
- mBgMaskProgram.setHostValue("exp_lrg", (float)(mSubsampleLevel + mHierarchyLrgExp));
- mBgMaskProgram.setHostValue("exp_mid", (float)(mSubsampleLevel + mHierarchyMidExp));
- mBgMaskProgram.setHostValue("exp_sml", (float)(mSubsampleLevel + mHierarchySmlExp));
-
- if (mUseTheForce) {
- mBgSubtractProgram = new ShaderProgram(context, mSharedUtilShader + mBgSubtractShader + mBgSubtractForceShader);
- } else {
- mBgSubtractProgram = new ShaderProgram(context, mSharedUtilShader + mBgSubtractShader + "}\n");
- }
- mBgSubtractProgram.setHostValue("bg_fit_transform", DEFAULT_BG_FIT_TRANSFORM);
- mBgSubtractProgram.setHostValue("mask_blend_bg", mMaskBg);
- mBgSubtractProgram.setHostValue("mask_blend_fg", mMaskFg);
- mBgSubtractProgram.setHostValue("exposure_change", mExposureChange);
- mBgSubtractProgram.setHostValue("whitebalanceblue_change", mWhiteBalanceBlueChange);
- mBgSubtractProgram.setHostValue("whitebalancered_change", mWhiteBalanceRedChange);
-
-
- mBgUpdateMeanProgram = new ShaderProgram(context, mSharedUtilShader + mUpdateBgModelMeanShader);
- mBgUpdateMeanProgram.setHostValue("subsample_level", (float)mSubsampleLevel);
-
- mBgUpdateVarianceProgram = new ShaderProgram(context, mSharedUtilShader + mUpdateBgModelVarianceShader);
- mBgUpdateVarianceProgram.setHostValue("subsample_level", (float)mSubsampleLevel);
-
- mCopyOutProgram = ShaderProgram.createIdentity(context);
-
- mAutomaticWhiteBalanceProgram = new ShaderProgram(context, mSharedUtilShader + mAutomaticWhiteBalance);
- mAutomaticWhiteBalanceProgram.setHostValue("pyramid_depth", (float)mPyramidDepth);
- mAutomaticWhiteBalanceProgram.setHostValue("autowb_toggle", mAutoWBToggle);
-
- mMaskVerifyProgram = new ShaderProgram(context, mSharedUtilShader + mMaskVerifyShader);
- mMaskVerifyProgram.setHostValue("verify_rate", mVerifyRate);
-
- if (mLogVerbose) Log.v(TAG, "Shader width set to " + mMemoryFormat.getWidth());
-
- mRelativeAspect = 1.f;
-
- mFrameCount = 0;
- mStartLearning = true;
- }
-
- public void process(FilterContext context) {
- // Grab inputs and ready intermediate frames and outputs.
- Frame video = pullInput("video");
- Frame background = pullInput("background");
- allocateFrames(video.getFormat(), context);
-
- // Update learning rate after initial learning period
- if (mStartLearning) {
- if (mLogVerbose) Log.v(TAG, "Starting learning");
- mBgUpdateMeanProgram.setHostValue("bg_adapt_rate", mAdaptRateLearning);
- mBgUpdateMeanProgram.setHostValue("fg_adapt_rate", mAdaptRateLearning);
- mBgUpdateVarianceProgram.setHostValue("bg_adapt_rate", mAdaptRateLearning);
- mBgUpdateVarianceProgram.setHostValue("fg_adapt_rate", mAdaptRateLearning);
- mFrameCount = 0;
- mStartLearning = false;
- }
-
- // Select correct pingpong buffers
- int inputIndex = mPingPong ? 0 : 1;
- int outputIndex = mPingPong ? 1 : 0;
- mPingPong = !mPingPong;
-
- // Check relative aspect ratios
- updateBgScaling(video, background, mBackgroundFitModeChanged);
- mBackgroundFitModeChanged = false;
-
- // Make copies for input frames to GLFrames
-
- copyShaderProgram.process(video, mVideoInput);
- copyShaderProgram.process(background, mBgInput);
-
- mVideoInput.generateMipMap();
- mVideoInput.setTextureParameter(GLES20.GL_TEXTURE_MIN_FILTER,
- GLES20.GL_LINEAR_MIPMAP_NEAREST);
-
- mBgInput.generateMipMap();
- mBgInput.setTextureParameter(GLES20.GL_TEXTURE_MIN_FILTER,
- GLES20.GL_LINEAR_MIPMAP_NEAREST);
-
- // Process shaders
- Frame[] distInputs = { mVideoInput, mBgMean[inputIndex], mBgVariance[inputIndex] };
- mBgDistProgram.process(distInputs, mDistance);
- mDistance.generateMipMap();
- mDistance.setTextureParameter(GLES20.GL_TEXTURE_MIN_FILTER,
- GLES20.GL_LINEAR_MIPMAP_NEAREST);
-
- mBgMaskProgram.process(mDistance, mMask);
- mMask.generateMipMap();
- mMask.setTextureParameter(GLES20.GL_TEXTURE_MIN_FILTER,
- GLES20.GL_LINEAR_MIPMAP_NEAREST);
-
- Frame[] autoWBInputs = { mVideoInput, mBgInput };
- mAutomaticWhiteBalanceProgram.process(autoWBInputs, mAutoWB);
-
- if (mFrameCount <= mLearningDuration) {
- // During learning
- pushOutput("video", video);
-
- if (mFrameCount == mLearningDuration - mLearningVerifyDuration) {
- copyShaderProgram.process(mMask, mMaskVerify[outputIndex]);
-
- mBgUpdateMeanProgram.setHostValue("bg_adapt_rate", mAdaptRateBg);
- mBgUpdateMeanProgram.setHostValue("fg_adapt_rate", mAdaptRateFg);
- mBgUpdateVarianceProgram.setHostValue("bg_adapt_rate", mAdaptRateBg);
- mBgUpdateVarianceProgram.setHostValue("fg_adapt_rate", mAdaptRateFg);
-
-
- } else if (mFrameCount > mLearningDuration - mLearningVerifyDuration) {
- // In the learning verification stage, compute background masks and a weighted average
- // with weights grow exponentially with time
- Frame[] maskVerifyInputs = {mMaskVerify[inputIndex], mMask};
- mMaskVerifyProgram.process(maskVerifyInputs, mMaskVerify[outputIndex]);
- mMaskVerify[outputIndex].generateMipMap();
- mMaskVerify[outputIndex].setTextureParameter(GLES20.GL_TEXTURE_MIN_FILTER,
- GLES20.GL_LINEAR_MIPMAP_NEAREST);
- }
-
- if (mFrameCount == mLearningDuration) {
- // In the last verification frame, verify if the verification mask is almost blank
- // If not, restart learning
- copyShaderProgram.process(mMaskVerify[outputIndex], mMaskAverage);
- ByteBuffer mMaskAverageByteBuffer = mMaskAverage.getData();
- byte[] mask_average = mMaskAverageByteBuffer.array();
- int bi = (int)(mask_average[3] & 0xFF);
- if (mLogVerbose) Log.v(TAG, String.format("Mask_average is %d", bi));
-
- if (bi >= DEFAULT_LEARNING_DONE_THRESHOLD) {
- mStartLearning = true; // Restart learning
- } else {
- if (mLogVerbose) Log.v(TAG, "Learning done");
- if (mLearningDoneListener != null) {
- mLearningDoneListener.onLearningDone(this);
- }
- }
- }
- } else {
- Frame output = context.getFrameManager().newFrame(video.getFormat());
- Frame[] subtractInputs = { video, background, mMask, mAutoWB };
- mBgSubtractProgram.process(subtractInputs, output);
- pushOutput("video", output);
- output.release();
- }
-
- // Compute mean and variance of the background
- if (mFrameCount < mLearningDuration - mLearningVerifyDuration ||
- mAdaptRateBg > 0.0 || mAdaptRateFg > 0.0) {
- Frame[] meanUpdateInputs = { mVideoInput, mBgMean[inputIndex], mMask };
- mBgUpdateMeanProgram.process(meanUpdateInputs, mBgMean[outputIndex]);
- mBgMean[outputIndex].generateMipMap();
- mBgMean[outputIndex].setTextureParameter(GLES20.GL_TEXTURE_MIN_FILTER,
- GLES20.GL_LINEAR_MIPMAP_NEAREST);
-
- Frame[] varianceUpdateInputs = {
- mVideoInput, mBgMean[inputIndex], mBgVariance[inputIndex], mMask
- };
- mBgUpdateVarianceProgram.process(varianceUpdateInputs, mBgVariance[outputIndex]);
- mBgVariance[outputIndex].generateMipMap();
- mBgVariance[outputIndex].setTextureParameter(GLES20.GL_TEXTURE_MIN_FILTER,
- GLES20.GL_LINEAR_MIPMAP_NEAREST);
- }
-
- // Provide debug output to two smaller viewers
- if (mProvideDebugOutputs) {
- Frame dbg1 = context.getFrameManager().newFrame(video.getFormat());
- mCopyOutProgram.process(video, dbg1);
- pushOutput("debug1", dbg1);
- dbg1.release();
-
- Frame dbg2 = context.getFrameManager().newFrame(mMemoryFormat);
- mCopyOutProgram.process(mMask, dbg2);
- pushOutput("debug2", dbg2);
- dbg2.release();
- }
-
- mFrameCount++;
-
- if (mLogVerbose) {
- if (mFrameCount % 30 == 0) {
- if (startTime == -1) {
- context.getGLEnvironment().activate();
- GLES20.glFinish();
- startTime = SystemClock.elapsedRealtime();
- } else {
- context.getGLEnvironment().activate();
- GLES20.glFinish();
- long endTime = SystemClock.elapsedRealtime();
- Log.v(TAG, "Avg. frame duration: " + String.format("%.2f",(endTime-startTime)/30.) +
- " ms. Avg. fps: " + String.format("%.2f", 1000./((endTime-startTime)/30.)) );
- startTime = endTime;
- }
- }
- }
- }
-
- private long startTime = -1;
-
- public void close(FilterContext context) {
- if (mMemoryFormat == null) {
- return;
- }
-
- if (mLogVerbose) Log.v(TAG, "Filter Closing!");
- for (int i = 0; i < 2; i++) {
- mBgMean[i].release();
- mBgVariance[i].release();
- mMaskVerify[i].release();
- }
- mDistance.release();
- mMask.release();
- mAutoWB.release();
- mVideoInput.release();
- mBgInput.release();
- mMaskAverage.release();
-
- mMemoryFormat = null;
- }
-
- // Relearn background model
- synchronized public void relearn() {
- // Let the processing thread know about learning restart
- mStartLearning = true;
- }
-
- @Override
- public void fieldPortValueUpdated(String name, FilterContext context) {
- // TODO: Many of these can be made ProgramPorts!
- if (name.equals("backgroundFitMode")) {
- mBackgroundFitModeChanged = true;
- } else if (name.equals("acceptStddev")) {
- mBgMaskProgram.setHostValue("accept_variance", mAcceptStddev * mAcceptStddev);
- } else if (name.equals("hierLrgScale")) {
- mBgMaskProgram.setHostValue("scale_lrg", mHierarchyLrgScale);
- } else if (name.equals("hierMidScale")) {
- mBgMaskProgram.setHostValue("scale_mid", mHierarchyMidScale);
- } else if (name.equals("hierSmlScale")) {
- mBgMaskProgram.setHostValue("scale_sml", mHierarchySmlScale);
- } else if (name.equals("hierLrgExp")) {
- mBgMaskProgram.setHostValue("exp_lrg", (float)(mSubsampleLevel + mHierarchyLrgExp));
- } else if (name.equals("hierMidExp")) {
- mBgMaskProgram.setHostValue("exp_mid", (float)(mSubsampleLevel + mHierarchyMidExp));
- } else if (name.equals("hierSmlExp")) {
- mBgMaskProgram.setHostValue("exp_sml", (float)(mSubsampleLevel + mHierarchySmlExp));
- } else if (name.equals("lumScale") || name.equals("chromaScale")) {
- float[] yuvWeights = { mLumScale, mChromaScale };
- mBgMaskProgram.setHostValue("yuv_weights", yuvWeights );
- } else if (name.equals("maskBg")) {
- mBgSubtractProgram.setHostValue("mask_blend_bg", mMaskBg);
- } else if (name.equals("maskFg")) {
- mBgSubtractProgram.setHostValue("mask_blend_fg", mMaskFg);
- } else if (name.equals("exposureChange")) {
- mBgSubtractProgram.setHostValue("exposure_change", mExposureChange);
- } else if (name.equals("whitebalanceredChange")) {
- mBgSubtractProgram.setHostValue("whitebalancered_change", mWhiteBalanceRedChange);
- } else if (name.equals("whitebalanceblueChange")) {
- mBgSubtractProgram.setHostValue("whitebalanceblue_change", mWhiteBalanceBlueChange);
- } else if (name.equals("autowbToggle")){
- mAutomaticWhiteBalanceProgram.setHostValue("autowb_toggle", mAutoWBToggle);
- }
- }
-
- private void updateBgScaling(Frame video, Frame background, boolean fitModeChanged) {
- float foregroundAspect = (float)video.getFormat().getWidth() / video.getFormat().getHeight();
- float backgroundAspect = (float)background.getFormat().getWidth() / background.getFormat().getHeight();
- float currentRelativeAspect = foregroundAspect/backgroundAspect;
- if (currentRelativeAspect != mRelativeAspect || fitModeChanged) {
- mRelativeAspect = currentRelativeAspect;
- float xMin = 0.f, xWidth = 1.f, yMin = 0.f, yWidth = 1.f;
- switch (mBackgroundFitMode) {
- case BACKGROUND_STRETCH:
- // Just map 1:1
- break;
- case BACKGROUND_FIT:
- if (mRelativeAspect > 1.0f) {
- // Foreground is wider than background, scale down
- // background in X
- xMin = 0.5f - 0.5f * mRelativeAspect;
- xWidth = 1.f * mRelativeAspect;
- } else {
- // Foreground is taller than background, scale down
- // background in Y
- yMin = 0.5f - 0.5f / mRelativeAspect;
- yWidth = 1 / mRelativeAspect;
- }
- break;
- case BACKGROUND_FILL_CROP:
- if (mRelativeAspect > 1.0f) {
- // Foreground is wider than background, crop
- // background in Y
- yMin = 0.5f - 0.5f / mRelativeAspect;
- yWidth = 1.f / mRelativeAspect;
- } else {
- // Foreground is taller than background, crop
- // background in X
- xMin = 0.5f - 0.5f * mRelativeAspect;
- xWidth = mRelativeAspect;
- }
- break;
- }
- // If mirroring is required (for ex. the camera mirrors the preview
- // in the front camera)
- // TODO: Backdropper does not attempt to apply any other transformation
- // than just flipping. However, in the current state, it's "x-axis" is always aligned
- // with the Camera's width. Hence, we need to define the mirroring based on the camera
- // orientation. In the future, a cleaner design would be to cast away all the rotation
- // in a separate place.
- if (mMirrorBg) {
- if (mLogVerbose) Log.v(TAG, "Mirroring the background!");
- // Mirroring in portrait
- if (mOrientation == 0 || mOrientation == 180) {
- xWidth = -xWidth;
- xMin = 1.0f - xMin;
- } else {
- // Mirroring in landscape
- yWidth = -yWidth;
- yMin = 1.0f - yMin;
- }
- }
- if (mLogVerbose) Log.v(TAG, "bgTransform: xMin, yMin, xWidth, yWidth : " +
- xMin + ", " + yMin + ", " + xWidth + ", " + yWidth +
- ", mRelAspRatio = " + mRelativeAspect);
- // The following matrix is the transpose of the actual matrix
- float[] bgTransform = {xWidth, 0.f, 0.f,
- 0.f, yWidth, 0.f,
- xMin, yMin, 1.f};
- mBgSubtractProgram.setHostValue("bg_fit_transform", bgTransform);
- }
- }
-
- private int pyramidLevel(int size) {
- return (int)Math.floor(Math.log10(size) / Math.log10(2)) - 1;
- }
-
-}
+++ /dev/null
-/*
- * 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.filterpacks.videosink;
-
-import android.content.Context;
-import android.filterfw.core.Filter;
-import android.filterfw.core.FilterContext;
-import android.filterfw.core.Frame;
-import android.filterfw.core.FrameFormat;
-import android.filterfw.core.FrameManager;
-import android.filterfw.core.GenerateFieldPort;
-import android.filterfw.core.GenerateFinalPort;
-import android.filterfw.core.GLFrame;
-import android.filterfw.core.KeyValueMap;
-import android.filterfw.core.MutableFrameFormat;
-import android.filterfw.core.NativeFrame;
-import android.filterfw.core.Program;
-import android.filterfw.core.ShaderProgram;
-import android.filterfw.format.ImageFormat;
-import android.filterfw.geometry.Point;
-import android.filterfw.geometry.Quad;
-import android.os.ConditionVariable;
-import android.media.MediaRecorder;
-import android.media.CamcorderProfile;
-import android.filterfw.core.GLEnvironment;
-
-import java.io.IOException;
-import java.io.FileDescriptor;
-import java.util.List;
-import java.util.Set;
-
-import android.util.Log;
-
-/** @hide */
-public class MediaEncoderFilter extends Filter {
-
- /** User-visible parameters */
-
- /** Recording state. When set to false, recording will stop, or will not
- * start if not yet running the graph. Instead, frames are simply ignored.
- * When switched back to true, recording will restart. This allows a single
- * graph to both provide preview and to record video. If this is false,
- * recording settings can be updated while the graph is running.
- */
- @GenerateFieldPort(name = "recording", hasDefault = true)
- private boolean mRecording = true;
-
- /** Filename to save the output. */
- @GenerateFieldPort(name = "outputFile", hasDefault = true)
- private String mOutputFile = new String("/sdcard/MediaEncoderOut.mp4");
-
- /** File Descriptor to save the output. */
- @GenerateFieldPort(name = "outputFileDescriptor", hasDefault = true)
- private FileDescriptor mFd = null;
-
- /** Input audio source. If not set, no audio will be recorded.
- * Select from the values in MediaRecorder.AudioSource
- */
- @GenerateFieldPort(name = "audioSource", hasDefault = true)
- private int mAudioSource = NO_AUDIO_SOURCE;
-
- /** Media recorder info listener, which needs to implement
- * MediaRecorder.OnInfoListener. Set this to receive notifications about
- * recording events.
- */
- @GenerateFieldPort(name = "infoListener", hasDefault = true)
- private MediaRecorder.OnInfoListener mInfoListener = null;
-
- /** Media recorder error listener, which needs to implement
- * MediaRecorder.OnErrorListener. Set this to receive notifications about
- * recording errors.
- */
- @GenerateFieldPort(name = "errorListener", hasDefault = true)
- private MediaRecorder.OnErrorListener mErrorListener = null;
-
- /** Media recording done callback, which needs to implement OnRecordingDoneListener.
- * Set this to finalize media upon completion of media recording.
- */
- @GenerateFieldPort(name = "recordingDoneListener", hasDefault = true)
- private OnRecordingDoneListener mRecordingDoneListener = null;
-
- /** Orientation hint. Used for indicating proper video playback orientation.
- * Units are in degrees of clockwise rotation, valid values are (0, 90, 180,
- * 270).
- */
- @GenerateFieldPort(name = "orientationHint", hasDefault = true)
- private int mOrientationHint = 0;
-
- /** Camcorder profile to use. Select from the profiles available in
- * android.media.CamcorderProfile. If this field is set, it overrides
- * settings to width, height, framerate, outputFormat, and videoEncoder.
- */
- @GenerateFieldPort(name = "recordingProfile", hasDefault = true)
- private CamcorderProfile mProfile = null;
-
- /** Frame width to be encoded, defaults to 320.
- * Actual received frame size has to match this */
- @GenerateFieldPort(name = "width", hasDefault = true)
- private int mWidth = 320;
-
- /** Frame height to to be encoded, defaults to 240.
- * Actual received frame size has to match */
- @GenerateFieldPort(name = "height", hasDefault = true)
- private int mHeight = 240;
-
- /** Stream framerate to encode the frames at.
- * By default, frames are encoded at 30 FPS*/
- @GenerateFieldPort(name = "framerate", hasDefault = true)
- private int mFps = 30;
-
- /** The output format to encode the frames in.
- * Choose an output format from the options in
- * android.media.MediaRecorder.OutputFormat */
- @GenerateFieldPort(name = "outputFormat", hasDefault = true)
- private int mOutputFormat = MediaRecorder.OutputFormat.MPEG_4;
-
- /** The videoencoder to encode the frames with.
- * Choose a videoencoder from the options in
- * android.media.MediaRecorder.VideoEncoder */
- @GenerateFieldPort(name = "videoEncoder", hasDefault = true)
- private int mVideoEncoder = MediaRecorder.VideoEncoder.H264;
-
- /** The input region to read from the frame. The corners of this quad are
- * mapped to the output rectangle. The input frame ranges from (0,0)-(1,1),
- * top-left to bottom-right. The corners of the quad are specified in the
- * order bottom-left, bottom-right, top-left, top-right.
- */
- @GenerateFieldPort(name = "inputRegion", hasDefault = true)
- private Quad mSourceRegion;
-
- /** The maximum filesize (in bytes) of the recording session.
- * By default, it will be 0 and will be passed on to the MediaRecorder.
- * If the limit is zero or negative, MediaRecorder will disable the limit*/
- @GenerateFieldPort(name = "maxFileSize", hasDefault = true)
- private long mMaxFileSize = 0;
-
- /** The maximum duration (in milliseconds) of the recording session.
- * By default, it will be 0 and will be passed on to the MediaRecorder.
- * If the limit is zero or negative, MediaRecorder will record indefinitely*/
- @GenerateFieldPort(name = "maxDurationMs", hasDefault = true)
- private int mMaxDurationMs = 0;
-
- /** TimeLapse Interval between frames.
- * By default, it will be 0. Whether the recording is timelapsed
- * is inferred based on its value being greater than 0 */
- @GenerateFieldPort(name = "timelapseRecordingIntervalUs", hasDefault = true)
- private long mTimeBetweenTimeLapseFrameCaptureUs = 0;
-
- // End of user visible parameters
-
- private static final int NO_AUDIO_SOURCE = -1;
-
- private int mSurfaceId;
- private ShaderProgram mProgram;
- private GLFrame mScreen;
-
- private boolean mRecordingActive = false;
- private long mTimestampNs = 0;
- private long mLastTimeLapseFrameRealTimestampNs = 0;
- private int mNumFramesEncoded = 0;
- // Used to indicate whether recording is timelapsed.
- // Inferred based on (mTimeBetweenTimeLapseFrameCaptureUs > 0)
- private boolean mCaptureTimeLapse = false;
-
- private boolean mLogVerbose;
- private static final String TAG = "MediaEncoderFilter";
-
- // Our hook to the encoder
- private MediaRecorder mMediaRecorder;
-
- /** Callback to be called when media recording completes. */
-
- public interface OnRecordingDoneListener {
- public void onRecordingDone();
- }
-
- public MediaEncoderFilter(String name) {
- super(name);
- Point bl = new Point(0, 0);
- Point br = new Point(1, 0);
- Point tl = new Point(0, 1);
- Point tr = new Point(1, 1);
- mSourceRegion = new Quad(bl, br, tl, tr);
- mLogVerbose = Log.isLoggable(TAG, Log.VERBOSE);
- }
-
- @Override
- public void setupPorts() {
- // Add input port- will accept RGBA GLFrames
- addMaskedInputPort("videoframe", ImageFormat.create(ImageFormat.COLORSPACE_RGBA,
- FrameFormat.TARGET_GPU));
- }
-
- @Override
- public void fieldPortValueUpdated(String name, FilterContext context) {
- if (mLogVerbose) Log.v(TAG, "Port " + name + " has been updated");
- if (name.equals("recording")) return;
- if (name.equals("inputRegion")) {
- if (isOpen()) updateSourceRegion();
- return;
- }
- // TODO: Not sure if it is possible to update the maxFileSize
- // when the recording is going on. For now, not doing that.
- if (isOpen() && mRecordingActive) {
- throw new RuntimeException("Cannot change recording parameters"
- + " when the filter is recording!");
- }
- }
-
- private void updateSourceRegion() {
- // Flip source quad to map to OpenGL origin
- Quad flippedRegion = new Quad();
- flippedRegion.p0 = mSourceRegion.p2;
- flippedRegion.p1 = mSourceRegion.p3;
- flippedRegion.p2 = mSourceRegion.p0;
- flippedRegion.p3 = mSourceRegion.p1;
- mProgram.setSourceRegion(flippedRegion);
- }
-
- // update the MediaRecorderParams based on the variables.
- // These have to be in certain order as per the MediaRecorder
- // documentation
- private void updateMediaRecorderParams() {
- mCaptureTimeLapse = mTimeBetweenTimeLapseFrameCaptureUs > 0;
- final int GRALLOC_BUFFER = 2;
- mMediaRecorder.setVideoSource(GRALLOC_BUFFER);
- if (!mCaptureTimeLapse && (mAudioSource != NO_AUDIO_SOURCE)) {
- mMediaRecorder.setAudioSource(mAudioSource);
- }
- if (mProfile != null) {
- mMediaRecorder.setProfile(mProfile);
- mFps = mProfile.videoFrameRate;
- } else {
- mMediaRecorder.setOutputFormat(mOutputFormat);
- mMediaRecorder.setVideoEncoder(mVideoEncoder);
- mMediaRecorder.setVideoSize(mWidth, mHeight);
- mMediaRecorder.setVideoFrameRate(mFps);
- }
- mMediaRecorder.setOrientationHint(mOrientationHint);
- mMediaRecorder.setOnInfoListener(mInfoListener);
- mMediaRecorder.setOnErrorListener(mErrorListener);
- if (mFd != null) {
- mMediaRecorder.setOutputFile(mFd);
- } else {
- mMediaRecorder.setOutputFile(mOutputFile);
- }
- try {
- mMediaRecorder.setMaxFileSize(mMaxFileSize);
- } catch (Exception e) {
- // Following the logic in VideoCamera.java (in Camera app)
- // We are going to ignore failure of setMaxFileSize here, as
- // a) The composer selected may simply not support it, or
- // b) The underlying media framework may not handle 64-bit range
- // on the size restriction.
- Log.w(TAG, "Setting maxFileSize on MediaRecorder unsuccessful! "
- + e.getMessage());
- }
- mMediaRecorder.setMaxDuration(mMaxDurationMs);
- }
-
- @Override
- public void prepare(FilterContext context) {
- if (mLogVerbose) Log.v(TAG, "Preparing");
-
- mProgram = ShaderProgram.createIdentity(context);
-
- mRecordingActive = false;
- }
-
- @Override
- public void open(FilterContext context) {
- if (mLogVerbose) Log.v(TAG, "Opening");
- updateSourceRegion();
- if (mRecording) startRecording(context);
- }
-
- private void startRecording(FilterContext context) {
- if (mLogVerbose) Log.v(TAG, "Starting recording");
-
- // Create a frame representing the screen
- MutableFrameFormat screenFormat = new MutableFrameFormat(
- FrameFormat.TYPE_BYTE, FrameFormat.TARGET_GPU);
- screenFormat.setBytesPerSample(4);
-
- int width, height;
- if (mProfile != null) {
- width = mProfile.videoFrameWidth;
- height = mProfile.videoFrameHeight;
- } else {
- width = mWidth;
- height = mHeight;
- }
- screenFormat.setDimensions(width, height);
- mScreen = (GLFrame)context.getFrameManager().newBoundFrame(
- screenFormat, GLFrame.EXISTING_FBO_BINDING, 0);
-
- // Initialize the media recorder
-
- mMediaRecorder = new MediaRecorder();
- updateMediaRecorderParams();
-
- try {
- mMediaRecorder.prepare();
- } catch (IllegalStateException e) {
- throw e;
- } catch (IOException e) {
- throw new RuntimeException("IOException in"
- + "MediaRecorder.prepare()!", e);
- } catch (Exception e) {
- throw new RuntimeException("Unknown Exception in"
- + "MediaRecorder.prepare()!", e);
- }
- // Make sure start() is called before trying to
- // register the surface. The native window handle needed to create
- // the surface is initiated in start()
- mMediaRecorder.start();
- if (mLogVerbose) Log.v(TAG, "Open: registering surface from Mediarecorder");
- mSurfaceId = context.getGLEnvironment().
- registerSurfaceFromMediaRecorder(mMediaRecorder);
- mNumFramesEncoded = 0;
- mRecordingActive = true;
- }
-
- public boolean skipFrameAndModifyTimestamp(long timestampNs) {
- // first frame- encode. Don't skip
- if (mNumFramesEncoded == 0) {
- mLastTimeLapseFrameRealTimestampNs = timestampNs;
- mTimestampNs = timestampNs;
- if (mLogVerbose) Log.v(TAG, "timelapse: FIRST frame, last real t= "
- + mLastTimeLapseFrameRealTimestampNs +
- ", setting t = " + mTimestampNs );
- return false;
- }
-
- // Workaround to bypass the first 2 input frames for skipping.
- // The first 2 output frames from the encoder are: decoder specific info and
- // the compressed video frame data for the first input video frame.
- if (mNumFramesEncoded >= 2 && timestampNs <
- (mLastTimeLapseFrameRealTimestampNs + 1000L * mTimeBetweenTimeLapseFrameCaptureUs)) {
- // If 2 frames have been already encoded,
- // Skip all frames from last encoded frame until
- // sufficient time (mTimeBetweenTimeLapseFrameCaptureUs) has passed.
- if (mLogVerbose) Log.v(TAG, "timelapse: skipping intermediate frame");
- return true;
- } else {
- // Desired frame has arrived after mTimeBetweenTimeLapseFrameCaptureUs time:
- // - Reset mLastTimeLapseFrameRealTimestampNs to current time.
- // - Artificially modify timestampNs to be one frame time (1/framerate) ahead
- // of the last encoded frame's time stamp.
- if (mLogVerbose) Log.v(TAG, "timelapse: encoding frame, Timestamp t = " + timestampNs +
- ", last real t= " + mLastTimeLapseFrameRealTimestampNs +
- ", interval = " + mTimeBetweenTimeLapseFrameCaptureUs);
- mLastTimeLapseFrameRealTimestampNs = timestampNs;
- mTimestampNs = mTimestampNs + (1000000000L / (long)mFps);
- if (mLogVerbose) Log.v(TAG, "timelapse: encoding frame, setting t = "
- + mTimestampNs + ", delta t = " + (1000000000L / (long)mFps) +
- ", fps = " + mFps );
- return false;
- }
- }
-
- @Override
- public void process(FilterContext context) {
- if (mLogVerbose) Log.v(TAG, "Starting frame processing");
-
- GLEnvironment glEnv = context.getGLEnvironment();
- // Get input frame
- Frame input = pullInput("videoframe");
-
- // Check if recording needs to start
- if (!mRecordingActive && mRecording) {
- startRecording(context);
- }
- // Check if recording needs to stop
- if (mRecordingActive && !mRecording) {
- stopRecording(context);
- }
-
- if (!mRecordingActive) return;
-
- if (mCaptureTimeLapse) {
- if (skipFrameAndModifyTimestamp(input.getTimestamp())) {
- return;
- }
- } else {
- mTimestampNs = input.getTimestamp();
- }
-
- // Activate our surface
- glEnv.activateSurfaceWithId(mSurfaceId);
-
- // Process
- mProgram.process(input, mScreen);
-
- // Set timestamp from input
- glEnv.setSurfaceTimestamp(mTimestampNs);
- // And swap buffers
- glEnv.swapBuffers();
- mNumFramesEncoded++;
- if (mLogVerbose) Log.v(TAG, "numFramesEncoded = " + mNumFramesEncoded);
- }
-
- private void stopRecording(FilterContext context) {
- if (mLogVerbose) Log.v(TAG, "Stopping recording");
-
- mRecordingActive = false;
- mNumFramesEncoded = 0;
- GLEnvironment glEnv = context.getGLEnvironment();
- // The following call will switch the surface_id to 0
- // (thus, calling eglMakeCurrent on surface with id 0) and
- // then call eglDestroy on the surface. Hence, this will
- // call disconnect the SurfaceMediaSource, which is needed to
- // be called before calling Stop on the mediarecorder
- if (mLogVerbose) Log.v(TAG, String.format("Unregistering surface %d", mSurfaceId));
- glEnv.unregisterSurfaceId(mSurfaceId);
- try {
- mMediaRecorder.stop();
- } catch (RuntimeException e) {
- throw new MediaRecorderStopException("MediaRecorder.stop() failed!", e);
- }
- mMediaRecorder.release();
- mMediaRecorder = null;
-
- mScreen.release();
- mScreen = null;
-
- // Use an EffectsRecorder callback to forward a media finalization
- // call so that it creates the video thumbnail, and whatever else needs
- // to be done to finalize media.
- if (mRecordingDoneListener != null) {
- mRecordingDoneListener.onRecordingDone();
- }
- }
-
- @Override
- public void close(FilterContext context) {
- if (mLogVerbose) Log.v(TAG, "Closing");
- if (mRecordingActive) stopRecording(context);
- }
-
- @Override
- public void tearDown(FilterContext context) {
- // Release all the resources associated with the MediaRecorder
- // and GLFrame members
- if (mMediaRecorder != null) {
- mMediaRecorder.release();
- }
- if (mScreen != null) {
- mScreen.release();
- }
-
- }
-
-}
+++ /dev/null
-/*
- * 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.filterpacks.videosink;
-
-import java.lang.RuntimeException;
-import android.util.Log;
-
-/** @hide **/
-public class MediaRecorderStopException extends RuntimeException {
-
- private static final String TAG = "MediaRecorderStopException";
-
- public MediaRecorderStopException(String msg) {
- super(msg);
- }
-
- public MediaRecorderStopException() {
- super();
- }
-
- public MediaRecorderStopException(String msg, Throwable t) {
- super(msg, t);
- }
-
- public MediaRecorderStopException(Throwable t) {
- super(t);
- }
-}
-
+++ /dev/null
-/*
- * 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.filterpacks.videosrc;
-
-import android.content.Context;
-import android.filterfw.core.Filter;
-import android.filterfw.core.FilterContext;
-import android.filterfw.core.Frame;
-import android.filterfw.core.FrameFormat;
-import android.filterfw.core.FrameManager;
-import android.filterfw.core.GenerateFieldPort;
-import android.filterfw.core.GenerateFinalPort;
-import android.filterfw.core.GLFrame;
-import android.filterfw.core.KeyValueMap;
-import android.filterfw.core.MutableFrameFormat;
-import android.filterfw.core.NativeFrame;
-import android.filterfw.core.Program;
-import android.filterfw.core.ShaderProgram;
-import android.filterfw.format.ImageFormat;
-import android.graphics.SurfaceTexture;
-import android.hardware.Camera;
-import android.os.ConditionVariable;
-import android.opengl.Matrix;
-
-import java.io.IOException;
-import java.util.List;
-import java.util.Set;
-
-import android.util.Log;
-
-/**
- * @hide
- */
-public class CameraSource extends Filter {
-
- /** User-visible parameters */
-
- /** Camera ID to use for input. Defaults to 0. */
- @GenerateFieldPort(name = "id", hasDefault = true)
- private int mCameraId = 0;
-
- /** Frame width to request from camera. Actual size may not match requested. */
- @GenerateFieldPort(name = "width", hasDefault = true)
- private int mWidth = 320;
-
- /** Frame height to request from camera. Actual size may not match requested. */
- @GenerateFieldPort(name = "height", hasDefault = true)
- private int mHeight = 240;
-
- /** Stream framerate to request from camera. Actual frame rate may not match requested. */
- @GenerateFieldPort(name = "framerate", hasDefault = true)
- private int mFps = 30;
-
- /** Whether the filter should always wait for a new frame from the camera
- * before providing output. If set to false, the filter will keep
- * outputting the last frame it received from the camera if multiple process
- * calls are received before the next update from the Camera. Defaults to true.
- */
- @GenerateFinalPort(name = "waitForNewFrame", hasDefault = true)
- private boolean mWaitForNewFrame = true;
-
- private Camera mCamera;
- private GLFrame mCameraFrame;
- private SurfaceTexture mSurfaceTexture;
- private ShaderProgram mFrameExtractor;
- private MutableFrameFormat mOutputFormat;
-
- private float[] mCameraTransform;
- private float[] mMappedCoords;
- // These default source coordinates perform the necessary flip
- // for converting from OpenGL origin to MFF/Bitmap origin.
- private static final float[] mSourceCoords = { 0, 1, 0, 1,
- 1, 1, 0, 1,
- 0, 0, 0, 1,
- 1, 0, 0, 1 };
-
- private static final int NEWFRAME_TIMEOUT = 100; //ms
- private static final int NEWFRAME_TIMEOUT_REPEAT = 10;
-
- private boolean mNewFrameAvailable;
-
- private Camera.Parameters mCameraParameters;
-
- private static final String mFrameShader =
- "#extension GL_OES_EGL_image_external : require\n" +
- "precision mediump float;\n" +
- "uniform samplerExternalOES tex_sampler_0;\n" +
- "varying vec2 v_texcoord;\n" +
- "void main() {\n" +
- " gl_FragColor = texture2D(tex_sampler_0, v_texcoord);\n" +
- "}\n";
-
- private final boolean mLogVerbose;
- private static final String TAG = "CameraSource";
-
- public CameraSource(String name) {
- super(name);
- mCameraTransform = new float[16];
- mMappedCoords = new float[16];
-
- mLogVerbose = Log.isLoggable(TAG, Log.VERBOSE);
- }
-
- @Override
- public void setupPorts() {
- // Add input port
- addOutputPort("video", ImageFormat.create(ImageFormat.COLORSPACE_RGBA,
- FrameFormat.TARGET_GPU));
- }
-
- private void createFormats() {
- mOutputFormat = ImageFormat.create(mWidth, mHeight,
- ImageFormat.COLORSPACE_RGBA,
- FrameFormat.TARGET_GPU);
- }
-
- @Override
- public void prepare(FilterContext context) {
- if (mLogVerbose) Log.v(TAG, "Preparing");
- // Compile shader TODO: Move to onGLEnvSomething?
- mFrameExtractor = new ShaderProgram(context, mFrameShader);
- }
-
- @Override
- public void open(FilterContext context) {
- if (mLogVerbose) Log.v(TAG, "Opening");
- // Open camera
- mCamera = Camera.open(mCameraId);
-
- // Set parameters
- getCameraParameters();
- mCamera.setParameters(mCameraParameters);
-
- // Create frame formats
- createFormats();
-
- // Bind it to our camera frame
- mCameraFrame = (GLFrame)context.getFrameManager().newBoundFrame(mOutputFormat,
- GLFrame.EXTERNAL_TEXTURE,
- 0);
- mSurfaceTexture = new SurfaceTexture(mCameraFrame.getTextureId());
- try {
- mCamera.setPreviewTexture(mSurfaceTexture);
- } catch (IOException e) {
- throw new RuntimeException("Could not bind camera surface texture: " +
- e.getMessage() + "!");
- }
-
- // Connect SurfaceTexture to callback
- mSurfaceTexture.setOnFrameAvailableListener(onCameraFrameAvailableListener);
- // Start the preview
- mNewFrameAvailable = false;
- mCamera.startPreview();
- }
-
- @Override
- public void process(FilterContext context) {
- if (mLogVerbose) Log.v(TAG, "Processing new frame");
-
- if (mWaitForNewFrame) {
- int waitCount = 0;
- while (!mNewFrameAvailable) {
- if (waitCount == NEWFRAME_TIMEOUT_REPEAT) {
- throw new RuntimeException("Timeout waiting for new frame");
- }
- try {
- this.wait(NEWFRAME_TIMEOUT);
- } catch (InterruptedException e) {
- if (mLogVerbose) Log.v(TAG, "Interrupted while waiting for new frame");
- }
- }
- mNewFrameAvailable = false;
- if (mLogVerbose) Log.v(TAG, "Got new frame");
- }
-
- mSurfaceTexture.updateTexImage();
-
- if (mLogVerbose) Log.v(TAG, "Using frame extractor in thread: " + Thread.currentThread());
- mSurfaceTexture.getTransformMatrix(mCameraTransform);
- Matrix.multiplyMM(mMappedCoords, 0,
- mCameraTransform, 0,
- mSourceCoords, 0);
- mFrameExtractor.setSourceRegion(mMappedCoords[0], mMappedCoords[1],
- mMappedCoords[4], mMappedCoords[5],
- mMappedCoords[8], mMappedCoords[9],
- mMappedCoords[12], mMappedCoords[13]);
-
- Frame output = context.getFrameManager().newFrame(mOutputFormat);
- mFrameExtractor.process(mCameraFrame, output);
-
- long timestamp = mSurfaceTexture.getTimestamp();
- if (mLogVerbose) Log.v(TAG, "Timestamp: " + (timestamp / 1000000000.0) + " s");
- output.setTimestamp(timestamp);
-
- pushOutput("video", output);
-
- // Release pushed frame
- output.release();
-
- if (mLogVerbose) Log.v(TAG, "Done processing new frame");
- }
-
- @Override
- public void close(FilterContext context) {
- if (mLogVerbose) Log.v(TAG, "Closing");
-
- mCamera.release();
- mCamera = null;
- mSurfaceTexture.release();
- mSurfaceTexture = null;
- }
-
- @Override
- public void tearDown(FilterContext context) {
- if (mCameraFrame != null) {
- mCameraFrame.release();
- }
- }
-
- @Override
- public void fieldPortValueUpdated(String name, FilterContext context) {
- if (name.equals("framerate")) {
- getCameraParameters();
- int closestRange[] = findClosestFpsRange(mFps, mCameraParameters);
- mCameraParameters.setPreviewFpsRange(closestRange[Camera.Parameters.PREVIEW_FPS_MIN_INDEX],
- closestRange[Camera.Parameters.PREVIEW_FPS_MAX_INDEX]);
- mCamera.setParameters(mCameraParameters);
- }
- }
-
- synchronized public Camera.Parameters getCameraParameters() {
- boolean closeCamera = false;
- if (mCameraParameters == null) {
- if (mCamera == null) {
- mCamera = Camera.open(mCameraId);
- closeCamera = true;
- }
- mCameraParameters = mCamera.getParameters();
-
- if (closeCamera) {
- mCamera.release();
- mCamera = null;
- }
- }
-
- int closestSize[] = findClosestSize(mWidth, mHeight, mCameraParameters);
- mWidth = closestSize[0];
- mHeight = closestSize[1];
- mCameraParameters.setPreviewSize(mWidth, mHeight);
-
- int closestRange[] = findClosestFpsRange(mFps, mCameraParameters);
-
- mCameraParameters.setPreviewFpsRange(closestRange[Camera.Parameters.PREVIEW_FPS_MIN_INDEX],
- closestRange[Camera.Parameters.PREVIEW_FPS_MAX_INDEX]);
-
- return mCameraParameters;
- }
-
- /** Update camera parameters. Image resolution cannot be changed. */
- synchronized public void setCameraParameters(Camera.Parameters params) {
- params.setPreviewSize(mWidth, mHeight);
- mCameraParameters = params;
- if (isOpen()) {
- mCamera.setParameters(mCameraParameters);
- }
- }
-
- private int[] findClosestSize(int width, int height, Camera.Parameters parameters) {
- List<Camera.Size> previewSizes = parameters.getSupportedPreviewSizes();
- int closestWidth = -1;
- int closestHeight = -1;
- int smallestWidth = previewSizes.get(0).width;
- int smallestHeight = previewSizes.get(0).height;
- for (Camera.Size size : previewSizes) {
- // Best match defined as not being larger in either dimension than
- // the requested size, but as close as possible. The below isn't a
- // stable selection (reording the size list can give different
- // results), but since this is a fallback nicety, that's acceptable.
- if ( size.width <= width &&
- size.height <= height &&
- size.width >= closestWidth &&
- size.height >= closestHeight) {
- closestWidth = size.width;
- closestHeight = size.height;
- }
- if ( size.width < smallestWidth &&
- size.height < smallestHeight) {
- smallestWidth = size.width;
- smallestHeight = size.height;
- }
- }
- if (closestWidth == -1) {
- // Requested size is smaller than any listed size; match with smallest possible
- closestWidth = smallestWidth;
- closestHeight = smallestHeight;
- }
-
- if (mLogVerbose) {
- Log.v(TAG,
- "Requested resolution: (" + width + ", " + height
- + "). Closest match: (" + closestWidth + ", "
- + closestHeight + ").");
- }
- int[] closestSize = {closestWidth, closestHeight};
- return closestSize;
- }
-
- private int[] findClosestFpsRange(int fps, Camera.Parameters params) {
- List<int[]> supportedFpsRanges = params.getSupportedPreviewFpsRange();
- int[] closestRange = supportedFpsRanges.get(0);
- for (int[] range : supportedFpsRanges) {
- if (range[Camera.Parameters.PREVIEW_FPS_MIN_INDEX] < fps*1000 &&
- range[Camera.Parameters.PREVIEW_FPS_MAX_INDEX] > fps*1000 &&
- range[Camera.Parameters.PREVIEW_FPS_MIN_INDEX] >
- closestRange[Camera.Parameters.PREVIEW_FPS_MIN_INDEX] &&
- range[Camera.Parameters.PREVIEW_FPS_MAX_INDEX] <
- closestRange[Camera.Parameters.PREVIEW_FPS_MAX_INDEX]) {
- closestRange = range;
- }
- }
- if (mLogVerbose) Log.v(TAG, "Requested fps: " + fps
- + ".Closest frame rate range: ["
- + closestRange[Camera.Parameters.PREVIEW_FPS_MIN_INDEX] / 1000.
- + ","
- + closestRange[Camera.Parameters.PREVIEW_FPS_MAX_INDEX] / 1000.
- + "]");
-
- return closestRange;
- }
-
- private SurfaceTexture.OnFrameAvailableListener onCameraFrameAvailableListener =
- new SurfaceTexture.OnFrameAvailableListener() {
- @Override
- public void onFrameAvailable(SurfaceTexture surfaceTexture) {
- if (mLogVerbose) Log.v(TAG, "New frame from camera");
- synchronized(CameraSource.this) {
- mNewFrameAvailable = true;
- CameraSource.this.notify();
- }
- }
- };
-
-}
+++ /dev/null
-/*
- * 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.filterpacks.videosrc;
-
-import android.content.Context;
-import android.content.res.AssetFileDescriptor;
-import android.filterfw.core.Filter;
-import android.filterfw.core.FilterContext;
-import android.filterfw.core.Frame;
-import android.filterfw.core.FrameFormat;
-import android.filterfw.core.FrameManager;
-import android.filterfw.core.GenerateFieldPort;
-import android.filterfw.core.GenerateFinalPort;
-import android.filterfw.core.GLFrame;
-import android.filterfw.core.KeyValueMap;
-import android.filterfw.core.MutableFrameFormat;
-import android.filterfw.core.NativeFrame;
-import android.filterfw.core.Program;
-import android.filterfw.core.ShaderProgram;
-import android.filterfw.format.ImageFormat;
-import android.graphics.SurfaceTexture;
-import android.media.MediaPlayer;
-import android.os.ConditionVariable;
-import android.opengl.Matrix;
-import android.view.Surface;
-
-import java.io.IOException;
-import java.io.FileDescriptor;
-import java.lang.IllegalArgumentException;
-import java.util.List;
-import java.util.Set;
-
-import android.util.Log;
-
-/**
- * @hide
- */
-public class MediaSource extends Filter {
-
- /** User-visible parameters */
-
- /** The source URL for the media source. Can be an http: link to a remote
- * resource, or a file: link to a local media file
- */
- @GenerateFieldPort(name = "sourceUrl", hasDefault = true)
- private String mSourceUrl = "";
-
- /** An open asset file descriptor to a local media source. Default is null */
- @GenerateFieldPort(name = "sourceAsset", hasDefault = true)
- private AssetFileDescriptor mSourceAsset = null;
-
- /** Whether the media source is a URL or an asset file descriptor. Defaults
- * to false.
- */
- @GenerateFieldPort(name = "sourceIsUrl", hasDefault = true)
- private boolean mSelectedIsUrl = false;
-
- /** Whether the filter will always wait for a new video frame, or whether it
- * will output an old frame again if a new frame isn't available. Defaults
- * to true.
- */
- @GenerateFinalPort(name = "waitForNewFrame", hasDefault = true)
- private boolean mWaitForNewFrame = true;
-
- /** Whether the media source should loop automatically or not. Defaults to
- * true.
- */
- @GenerateFieldPort(name = "loop", hasDefault = true)
- private boolean mLooping = true;
-
- /** Volume control. Currently sound is piped directly to the speakers, so
- * this defaults to mute.
- */
- @GenerateFieldPort(name = "volume", hasDefault = true)
- private float mVolume = 0.f;
-
- /** Orientation. This controls the output orientation of the video. Valid
- * values are 0, 90, 180, 270
- */
- @GenerateFieldPort(name = "orientation", hasDefault = true)
- private int mOrientation = 0;
-
- private MediaPlayer mMediaPlayer;
- private GLFrame mMediaFrame;
- private SurfaceTexture mSurfaceTexture;
- private ShaderProgram mFrameExtractor;
- private MutableFrameFormat mOutputFormat;
- private int mWidth, mHeight;
-
- // Total timeouts will be PREP_TIMEOUT*PREP_TIMEOUT_REPEAT
- private static final int PREP_TIMEOUT = 100; // ms
- private static final int PREP_TIMEOUT_REPEAT = 100;
- private static final int NEWFRAME_TIMEOUT = 100; //ms
- private static final int NEWFRAME_TIMEOUT_REPEAT = 10;
-
- // This is an identity shader; not using the default identity
- // shader because reading from a SurfaceTexture requires the
- // GL_OES_EGL_image_external extension.
- private final String mFrameShader =
- "#extension GL_OES_EGL_image_external : require\n" +
- "precision mediump float;\n" +
- "uniform samplerExternalOES tex_sampler_0;\n" +
- "varying vec2 v_texcoord;\n" +
- "void main() {\n" +
- " gl_FragColor = texture2D(tex_sampler_0, v_texcoord);\n" +
- "}\n";
-
- // The following transforms enable rotation of the decoded source.
- // These are multiplied with the transform obtained from the
- // SurfaceTexture to get the final transform to be set on the media source.
- // Currently, given a device orientation, the MediaSource rotates in such a way
- // that the source is displayed upright. A particular use case
- // is "Background Replacement" feature in the Camera app
- // where the MediaSource rotates the source to align with the camera feed and pass it
- // on to the backdropper filter. The backdropper only does the blending
- // and does not have to do any rotation
- // (except for mirroring in case of front camera).
- // TODO: Currently the rotations are spread over a bunch of stages in the
- // pipeline. A cleaner design
- // could be to cast away all the rotation in a separate filter or attach a transform
- // to the frame so that MediaSource itself need not know about any rotation.
- private static final float[] mSourceCoords_0 = { 1, 1, 0, 1,
- 0, 1, 0, 1,
- 1, 0, 0, 1,
- 0, 0, 0, 1 };
- private static final float[] mSourceCoords_270 = { 0, 1, 0, 1,
- 0, 0, 0, 1,
- 1, 1, 0, 1,
- 1, 0, 0, 1 };
- private static final float[] mSourceCoords_180 = { 0, 0, 0, 1,
- 1, 0, 0, 1,
- 0, 1, 0, 1,
- 1, 1, 0, 1 };
- private static final float[] mSourceCoords_90 = { 1, 0, 0, 1,
- 1, 1, 0, 1,
- 0, 0, 0, 1,
- 0, 1, 0, 1 };
-
- private boolean mGotSize;
- private boolean mPrepared;
- private boolean mPlaying;
- private boolean mNewFrameAvailable;
- private boolean mOrientationUpdated;
- private boolean mPaused;
- private boolean mCompleted;
-
- private final boolean mLogVerbose;
- private static final String TAG = "MediaSource";
-
- public MediaSource(String name) {
- super(name);
- mNewFrameAvailable = false;
-
- mLogVerbose = Log.isLoggable(TAG, Log.VERBOSE);
- }
-
- @Override
- public void setupPorts() {
- // Add input port
- addOutputPort("video", ImageFormat.create(ImageFormat.COLORSPACE_RGBA,
- FrameFormat.TARGET_GPU));
- }
-
- private void createFormats() {
- mOutputFormat = ImageFormat.create(ImageFormat.COLORSPACE_RGBA,
- FrameFormat.TARGET_GPU);
- }
-
- @Override
- protected void prepare(FilterContext context) {
- if (mLogVerbose) Log.v(TAG, "Preparing MediaSource");
-
- mFrameExtractor = new ShaderProgram(context, mFrameShader);
- // SurfaceTexture defines (0,0) to be bottom-left. The filter framework
- // defines (0,0) as top-left, so do the flip here.
- mFrameExtractor.setSourceRect(0, 1, 1, -1);
-
- createFormats();
- }
-
- @Override
- public void open(FilterContext context) {
- if (mLogVerbose) {
- Log.v(TAG, "Opening MediaSource");
- if (mSelectedIsUrl) {
- Log.v(TAG, "Current URL is " + mSourceUrl);
- } else {
- Log.v(TAG, "Current source is Asset!");
- }
- }
-
- mMediaFrame = (GLFrame)context.getFrameManager().newBoundFrame(
- mOutputFormat,
- GLFrame.EXTERNAL_TEXTURE,
- 0);
-
- mSurfaceTexture = new SurfaceTexture(mMediaFrame.getTextureId());
-
- if (!setupMediaPlayer(mSelectedIsUrl)) {
- throw new RuntimeException("Error setting up MediaPlayer!");
- }
- }
-
- @Override
- public void process(FilterContext context) {
- // Note: process is synchronized by its caller in the Filter base class
- if (mLogVerbose) Log.v(TAG, "Processing new frame");
-
- if (mMediaPlayer == null) {
- // Something went wrong in initialization or parameter updates
- throw new NullPointerException("Unexpected null media player!");
- }
-
- if (mCompleted) {
- // Video playback is done, so close us down
- closeOutputPort("video");
- return;
- }
-
- if (!mPlaying) {
- int waitCount = 0;
- if (mLogVerbose) Log.v(TAG, "Waiting for preparation to complete");
- while (!mGotSize || !mPrepared) {
- try {
- this.wait(PREP_TIMEOUT);
- } catch (InterruptedException e) {
- // ignoring
- }
- if (mCompleted) {
- // Video playback is done, so close us down
- closeOutputPort("video");
- return;
- }
- waitCount++;
- if (waitCount == PREP_TIMEOUT_REPEAT) {
- mMediaPlayer.release();
- throw new RuntimeException("MediaPlayer timed out while preparing!");
- }
- }
- if (mLogVerbose) Log.v(TAG, "Starting playback");
- mMediaPlayer.start();
- }
-
- // Use last frame if paused, unless just starting playback, in which case
- // we want at least one valid frame before pausing
- if (!mPaused || !mPlaying) {
- if (mWaitForNewFrame) {
- if (mLogVerbose) Log.v(TAG, "Waiting for new frame");
-
- int waitCount = 0;
- while (!mNewFrameAvailable) {
- if (waitCount == NEWFRAME_TIMEOUT_REPEAT) {
- if (mCompleted) {
- // Video playback is done, so close us down
- closeOutputPort("video");
- return;
- } else {
- throw new RuntimeException("Timeout waiting for new frame!");
- }
- }
- try {
- this.wait(NEWFRAME_TIMEOUT);
- } catch (InterruptedException e) {
- if (mLogVerbose) Log.v(TAG, "interrupted");
- // ignoring
- }
- waitCount++;
- }
- mNewFrameAvailable = false;
- if (mLogVerbose) Log.v(TAG, "Got new frame");
- }
-
- mSurfaceTexture.updateTexImage();
- mOrientationUpdated = true;
- }
- if (mOrientationUpdated) {
- float[] surfaceTransform = new float[16];
- mSurfaceTexture.getTransformMatrix(surfaceTransform);
-
- float[] sourceCoords = new float[16];
- switch (mOrientation) {
- default:
- case 0:
- Matrix.multiplyMM(sourceCoords, 0,
- surfaceTransform, 0,
- mSourceCoords_0, 0);
- break;
- case 90:
- Matrix.multiplyMM(sourceCoords, 0,
- surfaceTransform, 0,
- mSourceCoords_90, 0);
- break;
- case 180:
- Matrix.multiplyMM(sourceCoords, 0,
- surfaceTransform, 0,
- mSourceCoords_180, 0);
- break;
- case 270:
- Matrix.multiplyMM(sourceCoords, 0,
- surfaceTransform, 0,
- mSourceCoords_270, 0);
- break;
- }
- if (mLogVerbose) {
- Log.v(TAG, "OrientationHint = " + mOrientation);
- String temp = String.format("SetSourceRegion: %.2f, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f",
- sourceCoords[4], sourceCoords[5],sourceCoords[0], sourceCoords[1],
- sourceCoords[12], sourceCoords[13],sourceCoords[8], sourceCoords[9]);
- Log.v(TAG, temp);
- }
- mFrameExtractor.setSourceRegion(sourceCoords[4], sourceCoords[5],
- sourceCoords[0], sourceCoords[1],
- sourceCoords[12], sourceCoords[13],
- sourceCoords[8], sourceCoords[9]);
- mOrientationUpdated = false;
- }
-
- Frame output = context.getFrameManager().newFrame(mOutputFormat);
- mFrameExtractor.process(mMediaFrame, output);
-
- long timestamp = mSurfaceTexture.getTimestamp();
- if (mLogVerbose) Log.v(TAG, "Timestamp: " + (timestamp / 1000000000.0) + " s");
- output.setTimestamp(timestamp);
-
- pushOutput("video", output);
- output.release();
-
- mPlaying = true;
- }
-
- @Override
- public void close(FilterContext context) {
- if (mMediaPlayer.isPlaying()) {
- mMediaPlayer.stop();
- }
- mPrepared = false;
- mGotSize = false;
- mPlaying = false;
- mPaused = false;
- mCompleted = false;
- mNewFrameAvailable = false;
-
- mMediaPlayer.release();
- mMediaPlayer = null;
- mSurfaceTexture.release();
- mSurfaceTexture = null;
- if (mLogVerbose) Log.v(TAG, "MediaSource closed");
- }
-
- @Override
- public void tearDown(FilterContext context) {
- if (mMediaFrame != null) {
- mMediaFrame.release();
- }
- }
-
- // When updating the port values of the filter, users can update sourceIsUrl to switch
- // between using URL objects or Assets.
- // If updating only sourceUrl/sourceAsset, MediaPlayer gets reset if the current player
- // uses Url objects/Asset.
- // Otherwise the new sourceUrl/sourceAsset is stored and will be used when users switch
- // sourceIsUrl next time.
- @Override
- public void fieldPortValueUpdated(String name, FilterContext context) {
- if (mLogVerbose) Log.v(TAG, "Parameter update");
- if (name.equals("sourceUrl")) {
- if (isOpen()) {
- if (mLogVerbose) Log.v(TAG, "Opening new source URL");
- if (mSelectedIsUrl) {
- setupMediaPlayer(mSelectedIsUrl);
- }
- }
- } else if (name.equals("sourceAsset") ) {
- if (isOpen()) {
- if (mLogVerbose) Log.v(TAG, "Opening new source FD");
- if (!mSelectedIsUrl) {
- setupMediaPlayer(mSelectedIsUrl);
- }
- }
- } else if (name.equals("loop")) {
- if (isOpen()) {
- mMediaPlayer.setLooping(mLooping);
- }
- } else if (name.equals("sourceIsUrl")) {
- if (isOpen()){
- if (mSelectedIsUrl){
- if (mLogVerbose) Log.v(TAG, "Opening new source URL");
- } else {
- if (mLogVerbose) Log.v(TAG, "Opening new source Asset");
- }
- setupMediaPlayer(mSelectedIsUrl);
- }
- } else if (name.equals("volume")) {
- if (isOpen()) {
- mMediaPlayer.setVolume(mVolume, mVolume);
- }
- } else if (name.equals("orientation") && mGotSize) {
- if (mOrientation == 0 || mOrientation == 180) {
- mOutputFormat.setDimensions(mWidth, mHeight);
- } else {
- mOutputFormat.setDimensions(mHeight, mWidth);
- }
- mOrientationUpdated = true;
- }
- }
-
- synchronized public void pauseVideo(boolean pauseState) {
- if (isOpen()) {
- if (pauseState && !mPaused) {
- mMediaPlayer.pause();
- } else if (!pauseState && mPaused) {
- mMediaPlayer.start();
- }
- }
- mPaused = pauseState;
- }
-
- /** Creates a media player, sets it up, and calls prepare */
- synchronized private boolean setupMediaPlayer(boolean useUrl) {
- mPrepared = false;
- mGotSize = false;
- mPlaying = false;
- mPaused = false;
- mCompleted = false;
- mNewFrameAvailable = false;
-
- if (mLogVerbose) Log.v(TAG, "Setting up playback.");
-
- if (mMediaPlayer != null) {
- // Clean up existing media players
- if (mLogVerbose) Log.v(TAG, "Resetting existing MediaPlayer.");
- mMediaPlayer.reset();
- } else {
- // Create new media player
- if (mLogVerbose) Log.v(TAG, "Creating new MediaPlayer.");
- mMediaPlayer = new MediaPlayer();
- }
-
- if (mMediaPlayer == null) {
- throw new RuntimeException("Unable to create a MediaPlayer!");
- }
-
- // Set up data sources, etc
- try {
- if (useUrl) {
- if (mLogVerbose) Log.v(TAG, "Setting MediaPlayer source to URI " + mSourceUrl);
- mMediaPlayer.setDataSource(mSourceUrl);
- } else {
- if (mLogVerbose) Log.v(TAG, "Setting MediaPlayer source to asset " + mSourceAsset);
- mMediaPlayer.setDataSource(mSourceAsset.getFileDescriptor(), mSourceAsset.getStartOffset(), mSourceAsset.getLength());
- }
- } catch(IOException e) {
- mMediaPlayer.release();
- mMediaPlayer = null;
- if (useUrl) {
- throw new RuntimeException(String.format("Unable to set MediaPlayer to URL %s!", mSourceUrl), e);
- } else {
- throw new RuntimeException(String.format("Unable to set MediaPlayer to asset %s!", mSourceAsset), e);
- }
- } catch(IllegalArgumentException e) {
- mMediaPlayer.release();
- mMediaPlayer = null;
- if (useUrl) {
- throw new RuntimeException(String.format("Unable to set MediaPlayer to URL %s!", mSourceUrl), e);
- } else {
- throw new RuntimeException(String.format("Unable to set MediaPlayer to asset %s!", mSourceAsset), e);
- }
- }
-
- mMediaPlayer.setLooping(mLooping);
- mMediaPlayer.setVolume(mVolume, mVolume);
-
- // Bind it to our media frame
- Surface surface = new Surface(mSurfaceTexture);
- mMediaPlayer.setSurface(surface);
- surface.release();
-
- // Connect Media Player to callbacks
-
- mMediaPlayer.setOnVideoSizeChangedListener(onVideoSizeChangedListener);
- mMediaPlayer.setOnPreparedListener(onPreparedListener);
- mMediaPlayer.setOnCompletionListener(onCompletionListener);
-
- // Connect SurfaceTexture to callback
- mSurfaceTexture.setOnFrameAvailableListener(onMediaFrameAvailableListener);
-
- if (mLogVerbose) Log.v(TAG, "Preparing MediaPlayer.");
- mMediaPlayer.prepareAsync();
-
- return true;
- }
-
- private MediaPlayer.OnVideoSizeChangedListener onVideoSizeChangedListener =
- new MediaPlayer.OnVideoSizeChangedListener() {
- public void onVideoSizeChanged(MediaPlayer mp, int width, int height) {
- if (mLogVerbose) Log.v(TAG, "MediaPlayer sent dimensions: " + width + " x " + height);
- if (!mGotSize) {
- if (mOrientation == 0 || mOrientation == 180) {
- mOutputFormat.setDimensions(width, height);
- } else {
- mOutputFormat.setDimensions(height, width);
- }
- mWidth = width;
- mHeight = height;
- } else {
- if (mOutputFormat.getWidth() != width ||
- mOutputFormat.getHeight() != height) {
- Log.e(TAG, "Multiple video size change events received!");
- }
- }
- synchronized(MediaSource.this) {
- mGotSize = true;
- MediaSource.this.notify();
- }
- }
- };
-
- private MediaPlayer.OnPreparedListener onPreparedListener =
- new MediaPlayer.OnPreparedListener() {
- public void onPrepared(MediaPlayer mp) {
- if (mLogVerbose) Log.v(TAG, "MediaPlayer is prepared");
- synchronized(MediaSource.this) {
- mPrepared = true;
- MediaSource.this.notify();
- }
- }
- };
-
- private MediaPlayer.OnCompletionListener onCompletionListener =
- new MediaPlayer.OnCompletionListener() {
- public void onCompletion(MediaPlayer mp) {
- if (mLogVerbose) Log.v(TAG, "MediaPlayer has completed playback");
- synchronized(MediaSource.this) {
- mCompleted = true;
- }
- }
- };
-
- private SurfaceTexture.OnFrameAvailableListener onMediaFrameAvailableListener =
- new SurfaceTexture.OnFrameAvailableListener() {
- public void onFrameAvailable(SurfaceTexture surfaceTexture) {
- if (mLogVerbose) Log.v(TAG, "New frame from media player");
- synchronized(MediaSource.this) {
- if (mLogVerbose) Log.v(TAG, "New frame: notify");
- mNewFrameAvailable = true;
- MediaSource.this.notify();
- if (mLogVerbose) Log.v(TAG, "New frame: notify done");
- }
- }
- };
-
-}
+++ /dev/null
-/*
- * 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.filterpacks.videosrc;
-
-import android.content.Context;
-import android.content.res.AssetFileDescriptor;
-import android.filterfw.core.Filter;
-import android.filterfw.core.FilterContext;
-import android.filterfw.core.Frame;
-import android.filterfw.core.FrameFormat;
-import android.filterfw.core.FrameManager;
-import android.filterfw.core.GenerateFieldPort;
-import android.filterfw.core.GenerateFinalPort;
-import android.filterfw.core.GLFrame;
-import android.filterfw.core.KeyValueMap;
-import android.filterfw.core.MutableFrameFormat;
-import android.filterfw.core.ShaderProgram;
-import android.filterfw.format.ImageFormat;
-import android.graphics.SurfaceTexture;
-import android.media.MediaPlayer;
-import android.os.ConditionVariable;
-import android.opengl.Matrix;
-
-import java.io.IOException;
-import java.io.FileDescriptor;
-import java.lang.IllegalArgumentException;
-import java.util.List;
-import java.util.Set;
-
-import android.util.Log;
-
-/** <p>A filter that converts textures from a SurfaceTexture object into frames for
- * processing in the filter framework.</p>
- *
- * <p>To use, connect up the sourceListener callback, and then when executing
- * the graph, use the SurfaceTexture object passed to the callback to feed
- * frames into the filter graph. For example, pass the SurfaceTexture into
- * {#link
- * android.hardware.Camera.setPreviewTexture(android.graphics.SurfaceTexture)}.
- * This filter is intended for applications that need for flexibility than the
- * CameraSource and MediaSource provide. Note that the application needs to
- * provide width and height information for the SurfaceTextureSource, which it
- * should obtain from wherever the SurfaceTexture data is coming from to avoid
- * unnecessary resampling.</p>
- *
- * @hide
- */
-public class SurfaceTextureSource extends Filter {
-
- /** User-visible parameters */
-
- /** The callback interface for the sourceListener parameter */
- public interface SurfaceTextureSourceListener {
- public void onSurfaceTextureSourceReady(SurfaceTexture source);
- }
- /** A callback to send the internal SurfaceTexture object to, once it is
- * created. This callback will be called when the the filter graph is
- * preparing to execute, but before any processing has actually taken
- * place. The SurfaceTexture object passed to this callback is the only way
- * to feed this filter. When the filter graph is shutting down, this
- * callback will be called again with null as the source.
- *
- * This callback may be called from an arbitrary thread, so it should not
- * assume it is running in the UI thread in particular.
- */
- @GenerateFinalPort(name = "sourceListener")
- private SurfaceTextureSourceListener mSourceListener;
-
- /** The width of the output image frame. If the texture width for the
- * SurfaceTexture source is known, use it here to minimize resampling. */
- @GenerateFieldPort(name = "width")
- private int mWidth;
-
- /** The height of the output image frame. If the texture height for the
- * SurfaceTexture source is known, use it here to minimize resampling. */
- @GenerateFieldPort(name = "height")
- private int mHeight;
-
- /** Whether the filter will always wait for a new frame from its
- * SurfaceTexture, or whether it will output an old frame again if a new
- * frame isn't available. The filter will always wait for the first frame,
- * to avoid outputting a blank frame. Defaults to true.
- */
- @GenerateFieldPort(name = "waitForNewFrame", hasDefault = true)
- private boolean mWaitForNewFrame = true;
-
- /** Maximum timeout before signaling error when waiting for a new frame. Set
- * this to zero to disable the timeout and wait indefinitely. In milliseconds.
- */
- @GenerateFieldPort(name = "waitTimeout", hasDefault = true)
- private int mWaitTimeout = 1000;
-
- /** Whether a timeout is an exception-causing failure, or just causes the
- * filter to close.
- */
- @GenerateFieldPort(name = "closeOnTimeout", hasDefault = true)
- private boolean mCloseOnTimeout = false;
-
- // Variables for input->output conversion
- private GLFrame mMediaFrame;
- private ShaderProgram mFrameExtractor;
- private SurfaceTexture mSurfaceTexture;
- private MutableFrameFormat mOutputFormat;
- private ConditionVariable mNewFrameAvailable;
- private boolean mFirstFrame;
-
- private float[] mFrameTransform;
- private float[] mMappedCoords;
- // These default source coordinates perform the necessary flip
- // for converting from MFF/Bitmap origin to OpenGL origin.
- private static final float[] mSourceCoords = { 0, 1, 0, 1,
- 1, 1, 0, 1,
- 0, 0, 0, 1,
- 1, 0, 0, 1 };
- // Shader for output
- private final String mRenderShader =
- "#extension GL_OES_EGL_image_external : require\n" +
- "precision mediump float;\n" +
- "uniform samplerExternalOES tex_sampler_0;\n" +
- "varying vec2 v_texcoord;\n" +
- "void main() {\n" +
- " gl_FragColor = texture2D(tex_sampler_0, v_texcoord);\n" +
- "}\n";
-
- // Variables for logging
-
- private static final String TAG = "SurfaceTextureSource";
- private static final boolean mLogVerbose = Log.isLoggable(TAG, Log.VERBOSE);
-
- public SurfaceTextureSource(String name) {
- super(name);
- mNewFrameAvailable = new ConditionVariable();
- mFrameTransform = new float[16];
- mMappedCoords = new float[16];
- }
-
- @Override
- public void setupPorts() {
- // Add input port
- addOutputPort("video", ImageFormat.create(ImageFormat.COLORSPACE_RGBA,
- FrameFormat.TARGET_GPU));
- }
-
- private void createFormats() {
- mOutputFormat = ImageFormat.create(mWidth, mHeight,
- ImageFormat.COLORSPACE_RGBA,
- FrameFormat.TARGET_GPU);
- }
-
- @Override
- protected void prepare(FilterContext context) {
- if (mLogVerbose) Log.v(TAG, "Preparing SurfaceTextureSource");
-
- createFormats();
-
- // Prepare input
- mMediaFrame = (GLFrame)context.getFrameManager().newBoundFrame(mOutputFormat,
- GLFrame.EXTERNAL_TEXTURE,
- 0);
-
- // Prepare output
- mFrameExtractor = new ShaderProgram(context, mRenderShader);
- }
-
- @Override
- public void open(FilterContext context) {
- if (mLogVerbose) Log.v(TAG, "Opening SurfaceTextureSource");
- // Create SurfaceTexture anew each time - it can use substantial memory.
- mSurfaceTexture = new SurfaceTexture(mMediaFrame.getTextureId());
- // Connect SurfaceTexture to callback
- mSurfaceTexture.setOnFrameAvailableListener(onFrameAvailableListener);
- // Connect SurfaceTexture to source
- mSourceListener.onSurfaceTextureSourceReady(mSurfaceTexture);
- mFirstFrame = true;
- }
-
- @Override
- public void process(FilterContext context) {
- if (mLogVerbose) Log.v(TAG, "Processing new frame");
-
- // First, get new frame if available
- if (mWaitForNewFrame || mFirstFrame) {
- boolean gotNewFrame;
- if (mWaitTimeout != 0) {
- gotNewFrame = mNewFrameAvailable.block(mWaitTimeout);
- if (!gotNewFrame) {
- if (!mCloseOnTimeout) {
- throw new RuntimeException("Timeout waiting for new frame");
- } else {
- if (mLogVerbose) Log.v(TAG, "Timeout waiting for a new frame. Closing.");
- closeOutputPort("video");
- return;
- }
- }
- } else {
- mNewFrameAvailable.block();
- }
- mNewFrameAvailable.close();
- mFirstFrame = false;
- }
-
- mSurfaceTexture.updateTexImage();
-
- mSurfaceTexture.getTransformMatrix(mFrameTransform);
- Matrix.multiplyMM(mMappedCoords, 0,
- mFrameTransform, 0,
- mSourceCoords, 0);
- mFrameExtractor.setSourceRegion(mMappedCoords[0], mMappedCoords[1],
- mMappedCoords[4], mMappedCoords[5],
- mMappedCoords[8], mMappedCoords[9],
- mMappedCoords[12], mMappedCoords[13]);
- // Next, render to output
- Frame output = context.getFrameManager().newFrame(mOutputFormat);
- mFrameExtractor.process(mMediaFrame, output);
-
- output.setTimestamp(mSurfaceTexture.getTimestamp());
-
- pushOutput("video", output);
- output.release();
- }
-
- @Override
- public void close(FilterContext context) {
- if (mLogVerbose) Log.v(TAG, "SurfaceTextureSource closed");
- mSourceListener.onSurfaceTextureSourceReady(null);
- mSurfaceTexture.release();
- mSurfaceTexture = null;
- }
-
- @Override
- public void tearDown(FilterContext context) {
- if (mMediaFrame != null) {
- mMediaFrame.release();
- }
- }
-
- @Override
- public void fieldPortValueUpdated(String name, FilterContext context) {
- if (name.equals("width") || name.equals("height") ) {
- mOutputFormat.setDimensions(mWidth, mHeight);
- }
- }
-
- private SurfaceTexture.OnFrameAvailableListener onFrameAvailableListener =
- new SurfaceTexture.OnFrameAvailableListener() {
- public void onFrameAvailable(SurfaceTexture surfaceTexture) {
- if (mLogVerbose) Log.v(TAG, "New frame from SurfaceTexture");
- mNewFrameAvailable.open();
- }
- };
-}
+++ /dev/null
-/*
- * 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.filterpacks.videosrc;
-
-import android.filterfw.core.Filter;
-import android.filterfw.core.FilterContext;
-import android.filterfw.core.FilterSurfaceView;
-import android.filterfw.core.Frame;
-import android.filterfw.core.FrameFormat;
-import android.filterfw.core.GenerateFieldPort;
-import android.filterfw.core.GenerateFinalPort;
-import android.filterfw.core.GLEnvironment;
-import android.filterfw.core.GLFrame;
-import android.filterfw.core.KeyValueMap;
-import android.filterfw.core.MutableFrameFormat;
-import android.filterfw.core.NativeProgram;
-import android.filterfw.core.NativeFrame;
-import android.filterfw.core.Program;
-import android.filterfw.core.ShaderProgram;
-import android.filterfw.format.ImageFormat;
-
-import android.filterfw.geometry.Quad;
-import android.filterfw.geometry.Point;
-
-import android.view.Surface;
-import android.view.SurfaceHolder;
-import android.view.SurfaceView;
-
-import android.graphics.Rect;
-import android.graphics.SurfaceTexture;
-
-import android.util.Log;
-
-/**
- * @hide
- */
-public class SurfaceTextureTarget extends Filter {
-
- private final int RENDERMODE_STRETCH = 0;
- private final int RENDERMODE_FIT = 1;
- private final int RENDERMODE_FILL_CROP = 2;
- private final int RENDERMODE_CUSTOMIZE = 3;
-
- /** Required. Sets the destination surfaceTexture.
- */
- @GenerateFinalPort(name = "surfaceTexture")
- private SurfaceTexture mSurfaceTexture;
-
- /** Required. Sets the width of the output surfaceTexture images */
- @GenerateFinalPort(name = "width")
- private int mScreenWidth;
-
- /** Required. Sets the height of the output surfaceTexture images */
- @GenerateFinalPort(name = "height")
- private int mScreenHeight;
-
-
- /** Optional. Control how the incoming frames are rendered onto the
- * output. Default is FIT.
- * RENDERMODE_STRETCH: Just fill the output surfaceView.
- * RENDERMODE_FIT: Keep aspect ratio and fit without cropping. May
- * have black bars.
- * RENDERMODE_FILL_CROP: Keep aspect ratio and fit without black
- * bars. May crop.
- */
- @GenerateFieldPort(name = "renderMode", hasDefault = true)
- private String mRenderModeString;
-
- @GenerateFieldPort(name = "sourceQuad", hasDefault = true)
- private Quad mSourceQuad = new Quad(new Point(0.0f, 1.0f),
- new Point(1.0f, 1.0f),
- new Point(0.0f, 0.0f),
- new Point(1.0f, 0.0f));
-
- @GenerateFieldPort(name = "targetQuad", hasDefault = true)
- private Quad mTargetQuad = new Quad(new Point(0.0f, 0.0f),
- new Point(1.0f, 0.0f),
- new Point(0.0f, 1.0f),
- new Point(1.0f, 1.0f));
-
- private int mSurfaceId;
-
- private ShaderProgram mProgram;
- private GLFrame mScreen;
- private int mRenderMode = RENDERMODE_FIT;
- private float mAspectRatio = 1.f;
-
- private boolean mLogVerbose;
- private static final String TAG = "SurfaceTextureTarget";
-
- public SurfaceTextureTarget(String name) {
- super(name);
-
- mLogVerbose = Log.isLoggable(TAG, Log.VERBOSE);
- }
-
- @Override
- public void setupPorts() {
- // Make sure we have a SurfaceView
- if (mSurfaceTexture == null) {
- throw new RuntimeException("Null SurfaceTexture passed to SurfaceTextureTarget");
- }
-
- // Add input port - will accept anything that's 4-channel.
- addMaskedInputPort("frame", ImageFormat.create(ImageFormat.COLORSPACE_RGBA));
- }
-
- public void updateRenderMode() {
- if (mRenderModeString != null) {
- if (mRenderModeString.equals("stretch")) {
- mRenderMode = RENDERMODE_STRETCH;
- } else if (mRenderModeString.equals("fit")) {
- mRenderMode = RENDERMODE_FIT;
- } else if (mRenderModeString.equals("fill_crop")) {
- mRenderMode = RENDERMODE_FILL_CROP;
- } else if (mRenderModeString.equals("customize")) {
- mRenderMode = RENDERMODE_CUSTOMIZE;
- } else {
- throw new RuntimeException("Unknown render mode '" + mRenderModeString + "'!");
- }
- }
- updateTargetRect();
- }
-
- @Override
- public void prepare(FilterContext context) {
- // Create identity shader to render, and make sure to render upside-down, as textures
- // are stored internally bottom-to-top.
- mProgram = ShaderProgram.createIdentity(context);
- mProgram.setSourceRect(0, 1, 1, -1);
- mProgram.setClearColor(0.0f, 0.0f, 0.0f);
-
- updateRenderMode();
-
- // Create a frame representing the screen
- MutableFrameFormat screenFormat = new MutableFrameFormat(FrameFormat.TYPE_BYTE,
- FrameFormat.TARGET_GPU);
- screenFormat.setBytesPerSample(4);
- screenFormat.setDimensions(mScreenWidth, mScreenHeight);
- mScreen = (GLFrame)context.getFrameManager().newBoundFrame(screenFormat,
- GLFrame.EXISTING_FBO_BINDING,
- 0);
- }
-
- @Override
- public void open(FilterContext context) {
- // Set up SurfaceTexture internals
- mSurfaceId = context.getGLEnvironment().registerSurfaceTexture(mSurfaceTexture, mScreenWidth, mScreenHeight);
- }
-
- @Override
- public void process(FilterContext context) {
- if (mLogVerbose) Log.v(TAG, "Starting frame processing");
-
- GLEnvironment glEnv = context.getGLEnvironment();
-
- // Get input frame
- Frame input = pullInput("frame");
- boolean createdFrame = false;
-
- float currentAspectRatio = (float)input.getFormat().getWidth() / input.getFormat().getHeight();
- if (currentAspectRatio != mAspectRatio) {
- if (mLogVerbose) Log.v(TAG, "New aspect ratio: " + currentAspectRatio +", previously: " + mAspectRatio);
- mAspectRatio = currentAspectRatio;
- updateTargetRect();
- }
-
- // See if we need to copy to GPU
- Frame gpuFrame = null;
- if (mLogVerbose) Log.v("SurfaceTextureTarget", "Got input format: " + input.getFormat());
-
- int target = input.getFormat().getTarget();
- if (target != FrameFormat.TARGET_GPU) {
- gpuFrame = context.getFrameManager().duplicateFrameToTarget(input,
- FrameFormat.TARGET_GPU);
- createdFrame = true;
- } else {
- gpuFrame = input;
- }
-
- // Activate our surface
- glEnv.activateSurfaceWithId(mSurfaceId);
-
- // Process
- mProgram.process(gpuFrame, mScreen);
-
- glEnv.setSurfaceTimestamp(input.getTimestamp());
-
- // And swap buffers
- glEnv.swapBuffers();
-
- if (createdFrame) {
- gpuFrame.release();
- }
- }
-
- @Override
- public void fieldPortValueUpdated(String name, FilterContext context) {
- updateRenderMode();
- }
-
- @Override
- public void tearDown(FilterContext context) {
- if (mScreen != null) {
- mScreen.release();
- }
- }
-
- private void updateTargetRect() {
- if (mScreenWidth > 0 && mScreenHeight > 0 && mProgram != null) {
- float screenAspectRatio = (float)mScreenWidth / mScreenHeight;
- float relativeAspectRatio = screenAspectRatio / mAspectRatio;
-
- if (relativeAspectRatio == 1.0f && mRenderMode != RENDERMODE_CUSTOMIZE) {
- mProgram.setClearsOutput(false);
- } else {
- switch (mRenderMode) {
- case RENDERMODE_STRETCH:
- mProgram.setTargetRect(0, 0, 1, 1);
- mTargetQuad.p0.set(0f, 0.0f);
- mTargetQuad.p1.set(1f, 0.0f);
- mTargetQuad.p2.set(0f, 1.0f);
- mTargetQuad.p3.set(1f, 1.0f);
- mProgram.setClearsOutput(false);
- break;
- case RENDERMODE_FIT:
- if (relativeAspectRatio > 1.0f) {
- // Screen is wider than the camera, scale down X
- mTargetQuad.p0.set(0.5f - 0.5f / relativeAspectRatio, 0.0f);
- mTargetQuad.p1.set(0.5f + 0.5f / relativeAspectRatio, 0.0f);
- mTargetQuad.p2.set(0.5f - 0.5f / relativeAspectRatio, 1.0f);
- mTargetQuad.p3.set(0.5f + 0.5f / relativeAspectRatio, 1.0f);
-
- } else {
- // Screen is taller than the camera, scale down Y
- mTargetQuad.p0.set(0.0f, 0.5f - 0.5f * relativeAspectRatio);
- mTargetQuad.p1.set(1.0f, 0.5f - 0.5f * relativeAspectRatio);
- mTargetQuad.p2.set(0.0f, 0.5f + 0.5f * relativeAspectRatio);
- mTargetQuad.p3.set(1.0f, 0.5f + 0.5f * relativeAspectRatio);
- }
- mProgram.setClearsOutput(true);
- break;
- case RENDERMODE_FILL_CROP:
- if (relativeAspectRatio > 1) {
- // Screen is wider than the camera, crop in Y
- mTargetQuad.p0.set(0.0f, 0.5f - 0.5f * relativeAspectRatio);
- mTargetQuad.p1.set(1.0f, 0.5f - 0.5f * relativeAspectRatio);
- mTargetQuad.p2.set(0.0f, 0.5f + 0.5f * relativeAspectRatio);
- mTargetQuad.p3.set(1.0f, 0.5f + 0.5f * relativeAspectRatio);
- } else {
- // Screen is taller than the camera, crop in X
- mTargetQuad.p0.set(0.5f - 0.5f / relativeAspectRatio, 0.0f);
- mTargetQuad.p1.set(0.5f + 0.5f / relativeAspectRatio, 0.0f);
- mTargetQuad.p2.set(0.5f - 0.5f / relativeAspectRatio, 1.0f);
- mTargetQuad.p3.set(0.5f + 0.5f / relativeAspectRatio, 1.0f);
- }
- mProgram.setClearsOutput(true);
- break;
- case RENDERMODE_CUSTOMIZE:
- ((ShaderProgram) mProgram).setSourceRegion(mSourceQuad);
- break;
- }
- ((ShaderProgram) mProgram).setTargetRegion(mTargetQuad);
- }
- }
- }
-}
+++ /dev/null
-/**
- * @hide
- */
-package android.filterpacks.videosrc;
+++ /dev/null
-/*
- * 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.
- */
-
-#include <cutils/log.h>
-#include <cmath>
-
-#include "geometry.h"
-
-namespace android {
-namespace filterfw {
-
-float Point::Length() const {
- return std::sqrt(x_ * x_ + y_ * y_);
-}
-
-bool Point::ScaleTo(float new_length) {
- float length = Length();
- if (length == 0.0f) {
- return false;
- }
- x_ *= new_length / length;
- y_ *= new_length / length;
- return true;
-}
-
-float Point::Distance(const Point& p0, const Point& p1) {
- Point diff = p1 - p0;
- return diff.Length();
-}
-
-Point Point::operator+(const Point& other) const {
- Point out;
- out.x_ = x_ + other.x_;
- out.y_ = y_ + other.y_;
- return out;
-}
-
-Point Point::operator-(const Point& other) const {
- Point out;
- out.x_ = x_ - other.x_;
- out.y_ = y_ - other.y_;
- return out;
-}
-
-Point Point::operator*(float factor) const {
- Point out;
- out.x_ = factor * x_;
- out.y_ = factor * y_;
- return out;
-}
-
-void Point::Rotate90Clockwise() {
- const float x = x_;
- x_ = y_;
- y_ = -x;
-}
-
-bool Rect::ExpandToAspectRatio(float ratio) {
- if (width <= 0.0f || height <= 0.0f || ratio <= 0.0f) {
- return false;
- }
-
- const float current_ratio = width / height;
- if (current_ratio < ratio) {
- const float dx = width * (ratio / current_ratio - 1.0f);
- x -= dx / 2.0f;
- width += dx;
- } else {
- const float dy = height * (current_ratio / ratio - 1.0f);
- y -= dy / 2.0f;
- height += dy;
- }
- return true;
-}
-
-bool Rect::ExpandToMinLength(float length) {
- if (width <= 0.0f || height <= 0.0f || length <= 0.0f) {
- return false;
- }
-
- const float current_length = width > height ? width : height;
- if (length > current_length) {
- const float dx = width * (length / current_length - 1.0f);
- x -= dx / 2.0f;
- width += dx;
- const float dy = height * (length / current_length - 1.0f);
- y -= dy / 2.0f;
- height += dy;
- }
- return true;
-}
-
-bool Rect::ScaleWithLengthLimit(float factor, float max_length) {
- if (width <= 0.0f || height <= 0.0f || factor <= 0.0f) {
- return false;
- }
-
- const float current_length = width > height ? width : height;
- if (current_length >= max_length) {
- return true;
- }
-
- float f = factor;
- if (current_length * f > max_length) {
- f *= max_length / (current_length * f);
- }
-
- const float dx = width * (f - 1.0f);
- x -= dx / 2.0f;
- width += dx;
- const float dy = height * (f - 1.0f);
- y -= dy / 2.0f;
- height += dy;
- return true;
-}
-
-const Point& Quad::point(int ix) const {
- ALOG_ASSERT(ix < static_cast<int>(points_.size()), "Access out of bounds");
- return points_[ix];
-}
-
-bool SlantedRect::FromCenterAxisAndLengths(const Point& center,
- const Point& vert_axis,
- const Point& lengths) {
- Point dy = vert_axis;
- if (!dy.ScaleTo(lengths.y() / 2.0f)) {
- ALOGE("Illegal axis: %f %f", vert_axis.x(), vert_axis.y());
- return false;
- }
-
- Point dx = dy;
- dx.Rotate90Clockwise();
- dx.ScaleTo(lengths.x() / 2.0f);
-
- points_[0] = center - dx - dy;
- points_[1] = center + dx - dy;
- points_[2] = center - dx + dy;
- points_[3] = center + dx + dy;
-
- width_ = lengths.x();
- height_ = lengths.y();
-
- return true;
-}
-
-} // namespace filterfw
-} // namespace android
+++ /dev/null
-/*
- * 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.
- */
-
-#ifndef ANDROID_FILTERFW_FILTERPACKS_BASE_GEOMETRY_H
-#define ANDROID_FILTERFW_FILTERPACKS_BASE_GEOMETRY_H
-
-#include <vector>
-
-namespace android {
-namespace filterfw {
-
-// This is an initial implementation of some geometrical structures. This is
-// likely to grow and become more sophisticated in the future.
-
-class Point {
- public:
- Point() : x_(0.0f), y_(0.0f) {}
- Point(float x, float y) : x_(x), y_(y) {}
-
- float x() const { return x_; }
- float y() const { return y_; }
-
- float Length() const;
- bool ScaleTo(float new_length);
- static float Distance(const Point& p0, const Point& p1);
-
- // Add more of these as needed:
- Point operator+(const Point& other) const;
- Point operator-(const Point& other) const;
- Point operator*(float factor) const;
-
- void Rotate90Clockwise();
-
- private:
- float x_, y_;
-};
-
-class Quad {
- public:
- Quad() : points_(4) {}
- virtual ~Quad() {}
-
- Quad(const Point& p0, const Point& p1, const Point& p2, const Point& p3)
- : points_(4) {
- points_[0] = p0;
- points_[1] = p1;
- points_[2] = p2;
- points_[3] = p3;
- }
-
- const std::vector<Point>& points() const { return points_; }
- const Point& point(int ix) const;
-
- protected:
- std::vector<Point> points_;
-};
-
-class SlantedRect : public Quad {
- public:
- SlantedRect() : width_(0.0f), height_(0.0f) {}
- virtual ~SlantedRect() {}
-
- bool FromCenterAxisAndLengths(const Point& center,
- const Point& vert_axis,
- const Point& lenghts);
-
- float width() const { return width_; }
- float height() const { return height_; }
-
- private:
- float width_;
- float height_;
-};
-
-struct Rect {
- float x, y, width, height;
-
- Rect() {
- x = y = 0.0f;
- width = height = 1.0f;
- }
-
- Rect(float x, float y, float width, float height) {
- this->x = x;
- this->y = y;
- this->width = width;
- this->height = height;
- }
-
- bool ExpandToAspectRatio(float ratio);
- bool ExpandToMinLength(float length);
- bool ScaleWithLengthLimit(float factor, float max_length);
-};
-
-} // namespace filterfw
-} // namespace android
-
-#endif // ANDROID_FILTERFW_FILTERPACKS_BASE_GEOMETRY_H
+++ /dev/null
-/*
- * 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.
- */
-
-#include "time_util.h"
-#include "utilities.h"
-
-#include <cutils/log.h>
-#include <sys/time.h>
-#include <map>
-
-namespace android {
-namespace filterfw {
-
-uint64_t getTimeUs() {
- static long basesec;
- struct timeval tv;
- uint64_t nowtime;
- gettimeofday(&tv, 0);
- if (basesec == 0) {
- basesec = tv.tv_sec;
- }
- nowtime = (uint64_t)(tv.tv_sec - basesec) * (uint64_t)1000000 +
- (uint64_t)tv.tv_usec;
- return nowtime;
-}
-
-const uint64_t NamedStopWatch::kDefaultLoggingPeriodInFrames = 100;
-
-NamedStopWatch::NamedStopWatch(const std::string& name)
- : mName(name),
- mLoggingPeriodInFrames(kDefaultLoggingPeriodInFrames),
- mStartUSec(0),
- mNumCalls(0),
- mTotalUSec(0) {
-}
-
-void NamedStopWatch::Start() {
- mStartUSec = getTimeUs();
-}
-
-void NamedStopWatch::Stop() {
- if (!mStartUSec) {
- return;
- }
- uint64_t stopUSec = getTimeUs();
- if (stopUSec > mStartUSec) {
- ++mNumCalls;
- mTotalUSec += stopUSec - mStartUSec;
- if (mNumCalls % mLoggingPeriodInFrames == 0) {
- const float mSec = TotalUSec() * 1.0E-3f / NumCalls();
- ALOGE("%s: %f ms", Name().c_str(), mSec);
- }
- }
- mStartUSec = 0;
-}
-
-namespace {
-static NamedStopWatch* GetWatchForName(const std::string& watch_name) {
- // TODO: this leaks the NamedStopWatch objects. Replace it with a
- // singleton to avoid that and make it thread safe.
- static std::map<std::string, NamedStopWatch*> watches;
- NamedStopWatch* watch = FindPtrOrNull(watches, watch_name);
- if (!watch) {
- watch = new NamedStopWatch(watch_name);
- watches[watch_name] = watch;
- }
- return watch;
-};
-} // namespace
-
-ScopedTimer::ScopedTimer(const std::string& stop_watch_name) {
- mWatch = GetWatchForName(stop_watch_name);
- mWatch->Start();
-}
-
-} // namespace filterfw
-} // namespace android
+++ /dev/null
-/*
- * 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.
- */
-
-#ifndef ANDROID_FILTERFW_FILTERPACKS_BASE_TIME_UTIL_H
-#define ANDROID_FILTERFW_FILTERPACKS_BASE_TIME_UTIL_H
-
-#include <string>
-#include <utils/RefBase.h>
-
-#define LOG_MFF_RUNNING_TIMES 0
-
-namespace android {
-namespace filterfw {
-
-uint64_t getTimeUs();
-
-class NamedStopWatch : public RefBase {
- public:
- static const uint64_t kDefaultLoggingPeriodInFrames;
-
- explicit NamedStopWatch(const std::string& name);
- void Start();
- void Stop();
-
- void SetName(const std::string& name) { mName = name; }
- void SetLoggingPeriodInFrames(uint64_t numFrames) {
- mLoggingPeriodInFrames = numFrames;
- }
-
- const std::string& Name() const { return mName; }
- uint64_t NumCalls() const { return mNumCalls; }
- uint64_t TotalUSec() const { return mTotalUSec; }
-
- private:
- std::string mName;
- uint64_t mLoggingPeriodInFrames;
- uint64_t mStartUSec;
- uint64_t mNumCalls;
- uint64_t mTotalUSec;
-};
-
-class ScopedTimer {
- public:
- explicit ScopedTimer(const std::string& stop_watch_name);
- explicit ScopedTimer(NamedStopWatch* watch)
- : mWatch(watch) { mWatch->Start(); }
- ~ScopedTimer() { mWatch->Stop(); }
-
- private:
- NamedStopWatch* mWatch;
-};
-
-} // namespace filterfw
-} // namespace android
-
-#endif // ANDROID_FILTERFW_FILTERPACKS_BASE_TIME_UTIL_H
+++ /dev/null
-/*
- * 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.
- */
-
-#ifndef ANDROID_FILTERFW_FILTERPACKS_BASE_UTILITIES_H
-#define ANDROID_FILTERFW_FILTERPACKS_BASE_UTILITIES_H
-
-#include <set>
-#include <utility>
-
-namespace android {
-namespace filterfw {
-
-// Convenience Macro to make copy constructor and assignment operator private
-// (thereby disallowing copying and assigning).
-#define DISALLOW_COPY_AND_ASSIGN(TypeName) \
- TypeName(const TypeName&); \
- void operator=(const TypeName&)
-
-// A macro to disallow all the implicit constructors, namely the
-// default constructor, copy constructor and operator= functions.
-#define DISALLOW_IMPLICIT_CONSTRUCTORS(TypeName) \
- TypeName(); \
- DISALLOW_COPY_AND_ASSIGN(TypeName)
-
-// STLDeleteContainerPointers()
-// For a range within a container of pointers, calls delete
-// (non-array version) on these pointers.
-// NOTE: for these three functions, we could just implement a DeleteObject
-// functor and then call for_each() on the range and functor, but this
-// requires us to pull in all of algorithm.h, which seems expensive.
-// For hash_[multi]set, it is important that this deletes behind the iterator
-// because the hash_set may call the hash function on the iterator when it is
-// advanced, which could result in the hash function trying to deference a
-// stale pointer.
-template <class ForwardIterator>
-void STLDeleteContainerPointers(ForwardIterator begin,
- ForwardIterator end) {
- while (begin != end) {
- ForwardIterator temp = begin;
- ++begin;
- delete *temp;
- }
-}
-
-// Given an STL container consisting of (key, value) pairs, STLDeleteValues
-// deletes all the "value" components and clears the container. Does nothing
-// in the case it's given a NULL pointer.
-template <class T>
-void STLDeleteValues(T *v) {
- if (!v) return;
- for (typename T::iterator i = v->begin(); i != v->end(); ++i) {
- delete i->second;
- }
- v->clear();
-}
-
-// Perform a lookup in a map or hash_map.
-// If the key is present a const pointer to the associated value is returned,
-// otherwise a NULL pointer is returned.
-template <class Collection>
-const typename Collection::value_type::second_type*
-FindOrNull(const Collection& collection,
- const typename Collection::value_type::first_type& key) {
- typename Collection::const_iterator it = collection.find(key);
- if (it == collection.end()) {
- return 0;
- }
- return &it->second;
-}
-
-// A simple class that gives checklist functionality: There are essemtially two
-// operations defined on a CheckList:
-// - Adding a new (unchecked) item.
-// - Checking off an item.
-// When checking off the last remaining item CheckItem() returns true.
-template<typename T>
-class CheckList {
- public:
- // Add a new unchecked item. Does nothing if item is already in checklist.
- void AddItem(const T& item);
-
- // Check off an item in the checklist. Returns true if all items have been
- // checked.
- bool CheckItem(const T& item);
-
- // Clear the checklist.
- void Clear() {
- items_.clear();
- }
-
- private:
- std::set<T> items_;
-};
-
-template<typename T>
-void CheckList<T>::AddItem(const T& item) {
- if (!ContainsKey(items_, item))
- items_.insert(item);
-}
-
-template<typename T>
-bool CheckList<T>::CheckItem(const T& item) {
- typename std::set<T>::iterator iter = items_.find(item);
- if (iter != items_.end())
- items_.erase(iter);
- return items_.empty();
-}
-
-// Perform a lookup in a map or hash_map whose values are pointers.
-// If the key is present a const pointer to the associated value is returned,
-// otherwise a NULL pointer is returned.
-// This function does not distinguish between a missing key and a key mapped
-// to a NULL value.
-template <class Collection>
-const typename Collection::value_type::second_type
-FindPtrOrNull(const Collection& collection,
- const typename Collection::value_type::first_type& key) {
- typename Collection::const_iterator it = collection.find(key);
- if (it == collection.end()) {
- return 0;
- }
- return it->second;
-}
-
-// Test to see if a set, map, hash_set or hash_map contains a particular key.
-// Returns true if the key is in the collection.
-template <typename Collection, typename Key>
-bool ContainsKey(const Collection& collection, const Key& key) {
- return collection.find(key) != collection.end();
-}
-
-// Insert a new key and value into a map or hash_map.
-// If the key is not present in the map the key and value are
-// inserted, otherwise nothing happens. True indicates that an insert
-// took place, false indicates the key was already present.
-template <class Collection, class Key, class Value>
-bool InsertIfNotPresent(Collection * const collection,
- const Key& key, const Value& value) {
- std::pair<typename Collection::iterator, bool> ret =
- collection->insert(typename Collection::value_type(key, value));
- return ret.second;
-}
-
-} // namespace filterfw
-} // namespace android
-
-#endif // ANDROID_FILTERFW_FILTERPACKS_BASE_UTILITIES_H
+++ /dev/null
-/*
- * 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.
- */
-
-#ifndef ANDROID_FILTERFW_FILTERPACKS_BASE_VEC_TYPES_H
-#define ANDROID_FILTERFW_FILTERPACKS_BASE_VEC_TYPES_H
-
-namespace android {
-namespace filterfw {
-
-template < class T, int dim>
-class VecBase {
- public:
- T data[dim];
- VecBase() {}
- VecBase<T,dim>& operator = (const VecBase<T, dim> &x) {
- memcpy(data, x.data, sizeof(T)*dim);
- return *this;
- }
- T & operator [] (int i) {
- // out of boundary not checked
- return data[i];
- }
- const T & operator [] (int i) const {
- // out of boundary not checked
- return data[i];
- }
- T Length() {
- double sum = 0;
- for (int i = 0; i < dim; ++i)
- sum += static_cast<double> (data[i] * data[i]);
- return static_cast<T>(sqrt(sum));
- }
-};
-
-template < class T, int dim>
-class Vec : public VecBase<T,dim> {
- public:
- Vec() {}
- Vec<T,dim>& operator = (const Vec<T, dim> &x) {
- memcpy(this->data, x.data, sizeof(T)*dim);
- return *this;
- }
-};
-
-template <class T, int dim>
-Vec<T, dim> operator + (const Vec<T,dim> &x, const Vec<T,dim> &y) {
- Vec<T, dim> out;
- for (int i = 0; i < dim; i++)
- out.data[i] = x.data[i] + y.data[i];
- return out;
-}
-
-template <class T, int dim>
-Vec<T, dim> operator - (const Vec<T,dim> &x, const Vec<T,dim> &y) {
- Vec<T, dim> out;
- for (int i = 0; i < dim; i++)
- out.data[i] = x.data[i] - y.data[i];
- return out;
-}
-
-template <class T, int dim>
-Vec<T, dim> operator * (const Vec<T,dim> &x, const Vec<T,dim> &y) {
- Vec<T, dim> out;
- for (int i = 0; i < dim; i++)
- out.data[i] = x.data[i] * y.data[i];
- return out;
-}
-
-template <class T, int dim>
-Vec<T, dim> operator / (const Vec<T,dim> &x, const Vec<T,dim> &y) {
- Vec<T, dim> out;
- for (int i = 0; i < dim; i++)
- out.data[i] = x.data[i] / y.data[i];
- return out;
-}
-
-template <class T, int dim>
-T dot(const Vec<T,dim> &x, const Vec<T,dim> &y) {
- T out = 0;
- for (int i = 0; i < dim; i++)
- out += x.data[i] * y.data[i];
- return out;
-}
-
-template <class T, int dim>
-Vec<T, dim> operator * (const Vec<T,dim> &x, T scale) {
- Vec<T, dim> out;
- for (int i = 0; i < dim; i++)
- out.data[i] = x.data[i] * scale;
- return out;
-}
-
-template <class T, int dim>
-Vec<T, dim> operator / (const Vec<T,dim> &x, T scale) {
- Vec<T, dim> out;
- for (int i = 0; i < dim; i++)
- out.data[i] = x.data[i] / scale;
- return out;
-}
-
-template <class T, int dim>
-Vec<T, dim> operator + (const Vec<T,dim> &x, T val) {
- Vec<T, dim> out;
- for (int i = 0; i < dim; i++)
- out.data[i] = x.data[i] + val;
- return out;
-}
-
-// specialization for vec2, vec3, vec4 float
-template<>
-class Vec<float, 2> : public VecBase<float, 2> {
-public:
- Vec() {}
- Vec(float x, float y) {
- data[0] = x;
- data[1] = y;
- }
- Vec<float, 2>& operator = (const Vec<float, 2> &x) {
- memcpy(data, x.data, sizeof(float)*2);
- return *this;
- }
-};
-
-template<>
-class Vec<float, 3> {
-public:
- float data[3];
- Vec() {}
- Vec(float x, float y, float z) {
- data[0] = x;
- data[1] = y;
- data[2] = z;
- }
- Vec<float, 3>& operator = (const Vec<float, 3> &x) {
- memcpy(data, x.data, sizeof(float)*3);
- return *this;
- }
-};
-
-template<>
-class Vec<float, 4> {
-public:
- float data[4];
- Vec() {}
- Vec(float x, float y, float z, float w) {
- data[0] = x;
- data[1] = y;
- data[2] = z;
- data[3] = w;
- }
- Vec<float, 4>& operator = (const Vec<float, 4> &x) {
- memcpy(data, x.data, sizeof(float)*4);
- return *this;
- }
-};
-
-typedef Vec<float,2> Vec2f;
-typedef Vec<float,3> Vec3f;
-typedef Vec<float,4> Vec4f;
-
-} // namespace filterfw
-} // namespace android
-
-#endif // ANDROID_FILTERFW_FILTERPACKS_BASE_VEC_TYPES_H
+++ /dev/null
-/*
- * 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.
- */
-
-#include <android/log.h>
-#include <stdlib.h>
-
-#define LOGI(...) __android_log_print(ANDROID_LOG_INFO, "MCA", __VA_ARGS__)
-#define LOGW(...) __android_log_print(ANDROID_LOG_WARN, "MCA", __VA_ARGS__)
-#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR, "MCA", __VA_ARGS__)
-
-typedef struct {
- float brightness;
-} BrightnessParameters;
-
-typedef union {
- int value;
- char rgba[4];
-} Pixel;
-
-void brightness_init(void** user_data) {
- (*user_data) = malloc(sizeof(BrightnessParameters));
-}
-
-void brightness_teardown(void* user_data) {
- free(user_data);
-}
-
-void brightness_setvalue(const char* key, const char* value, void* user_data) {
- if (strcmp(key, "brightness") == 0)
- ((BrightnessParameters*)user_data)->brightness = atof(value);
- else
- LOGE("Unknown parameter: %s!", key);
-}
-
-int brightness_process(const char** inputs,
- const int* input_sizes,
- int input_count,
- char* output,
- int output_size,
- void* user_data) {
- // Make sure we have exactly one input
- if (input_count != 1) {
- LOGE("Brightness: Incorrect input count! Expected 1 but got %d!", input_count);
- return 0;
- }
-
- // Make sure sizes match up
- if (input_sizes[0] != output_size) {
- LOGE("Brightness: Input-output sizes do not match up. %d vs. %d!", input_sizes[0], output_size);
- return 0;
- }
-
- // Get the input and output pointers
- const int* input_ptr = (int*)inputs[0];
- int* output_ptr = (int*)output;
- const int* end_ptr = input_ptr + (output_size / 4);
- if (!input_ptr || !output_ptr) {
- LOGE("Brightness: No input or output pointer found!");
- return 0;
- }
-
- // Get the parameters
- BrightnessParameters* params = (BrightnessParameters*)user_data;
- const float brightness = params->brightness;
-
- // Run the brightness adjustment
- const int factor = (int)(brightness * 255.0f);
- Pixel pixel;
- while (input_ptr < end_ptr) {
- pixel.value = *(input_ptr++);
-
- const short r = (pixel.rgba[0] * factor) / 255;
- const short g = (pixel.rgba[1] * factor) / 255;
- const short b = (pixel.rgba[2] * factor) / 255;
-
- *(output_ptr++) = (r > 255 ? 255 : r)
- | ((g > 255 ? 255 : g) << 8)
- | ((b > 255 ? 255 : b) << 16)
- | (pixel.rgba[3] << 24);
- }
-
- return 1;
-}
-
+++ /dev/null
-/*
- * 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.
- */
-
-#include <android/log.h>
-#include <stdlib.h>
-
-#define LOGI(...) __android_log_print(ANDROID_LOG_INFO, "MCA", __VA_ARGS__)
-#define LOGW(...) __android_log_print(ANDROID_LOG_WARN, "MCA", __VA_ARGS__)
-#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR, "MCA", __VA_ARGS__)
-
-typedef struct {
- float contrast;
-} ContrastParameters;
-
-void contrast_init(void** user_data) {
- (*user_data) = malloc(sizeof(ContrastParameters));
-}
-
-void contrast_teardown(void* user_data) {
- free(user_data);
-}
-
-void contrast_setvalue(const char* key, const char* value, void* user_data) {
- if (strcmp(key, "contrast") == 0)
- ((ContrastParameters*)user_data)->contrast = atof(value);
- else
- LOGE("Unknown parameter: %s!", key);
-}
-
-int contrast_process(const char** inputs,
- const int* input_sizes,
- int input_count,
- char* output,
- int output_size,
- void* user_data) {
- // Make sure we have exactly one input
- if (input_count != 1) {
- LOGE("Contrast: Incorrect input count! Expected 1 but got %d!", input_count);
- return 0;
- }
-
- // Make sure sizes match up
- if (input_sizes[0] != output_size) {
- LOGE("Contrast: Input-output sizes do not match up. %d vs. %d!", input_sizes[0], output_size);
- return 0;
- }
-
- // Get the input and output pointers
- const char* input_ptr = inputs[0];
- char* output_ptr = output;
- if (!input_ptr || !output_ptr) {
- LOGE("Contrast: No input or output pointer found!");
- return 0;
- }
-
- // Get the parameters
- ContrastParameters* params = (ContrastParameters*)user_data;
- const float contrast = params->contrast;
-
- // Run the contrast adjustment
- int i;
- for (i = 0; i < output_size; ++i) {
- float px = *(input_ptr++) / 255.0;
- px -= 0.5;
- px *= contrast;
- px += 0.5;
- *(output_ptr++) = (char)(px > 1.0 ? 255.0 : (px < 0.0 ? 0.0 : px * 255.0));
- }
-
- return 1;
-}
-
+++ /dev/null
-/*
- * 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.
- */
-
-#include <android/log.h>
-
-int invert_process(const char** inputs,
- const int* input_sizes,
- int input_count,
- char* output,
- int output_size,
- void* user_data) {
- // Make sure we have exactly one input
- if (input_count != 1)
- return 0;
-
- // Make sure sizes match up
- if (input_sizes[0] != output_size)
- return 0;
-
- // Get the input and output pointers
- const char* input_ptr = inputs[0];
- char* output_ptr = output;
- if (!input_ptr || !output_ptr)
- return 0;
-
- // Run the inversion
- int i;
- for (i = 0; i < output_size; ++i)
- *(output_ptr++) = 255 - *(input_ptr++);
-
- return 1;
-}
-
+++ /dev/null
-/*
- * 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.
- */
-
-#include <stdlib.h>
-
-int gray_to_rgb_process(const char** inputs,
- const int* input_sizes,
- int input_count,
- char* output,
- int output_size,
- void* user_data) {
- // Make sure we have exactly one input
- if (input_count != 1)
- return 0;
-
- // Make sure sizes match up
- if (input_sizes[0] != output_size/3)
- return 0;
-
- // Get the input and output pointers
- const char* input_ptr = inputs[0];
- char* output_ptr = output;
- if (!input_ptr || !output_ptr)
- return 0;
-
- // Run the conversion
- int i;
- for (i = 0; i < input_sizes[0]; ++i) {
- *(output_ptr++) = *(input_ptr);
- *(output_ptr++) = *(input_ptr);
- *(output_ptr++) = *(input_ptr++);
- }
-
- return 1;
-}
-
-int rgba_to_rgb_process(const char** inputs,
- const int* input_sizes,
- int input_count,
- char* output,
- int output_size,
- void* user_data) {
- // Make sure we have exactly one input
- if (input_count != 1)
- return 0;
-
- // Make sure sizes match up
- if (input_sizes[0]/4 != output_size/3)
- return 0;
-
- // Get the input and output pointers
- const char* input_ptr = inputs[0];
- char* output_ptr = output;
- if (!input_ptr || !output_ptr)
- return 0;
-
- // Run the conversion
- int i;
- for (i = 0; i < input_sizes[0] / 4; ++i) {
- *(output_ptr++) = *(input_ptr++);
- *(output_ptr++) = *(input_ptr++);
- *(output_ptr++) = *(input_ptr++);
- ++input_ptr;
- }
-
- return 1;
-}
-
-int gray_to_rgba_process(const char** inputs,
- const int* input_sizes,
- int input_count,
- char* output,
- int output_size,
- void* user_data) {
- // Make sure we have exactly one input
- if (input_count != 1)
- return 0;
-
- // Make sure sizes match up
- if (input_sizes[0] != output_size/4)
- return 0;
-
- // Get the input and output pointers
- const char* input_ptr = inputs[0];
- char* output_ptr = output;
- if (!input_ptr || !output_ptr)
- return 0;
-
- // Run the conversion
- int i;
- for (i = 0; i < input_sizes[0]; ++i) {
- *(output_ptr++) = *(input_ptr);
- *(output_ptr++) = *(input_ptr);
- *(output_ptr++) = *(input_ptr++);
- *(output_ptr++) = 255;
- }
-
- return 1;
-}
-
-int rgb_to_rgba_process(const char** inputs,
- const int* input_sizes,
- int input_count,
- char* output,
- int output_size,
- void* user_data) {
- // Make sure we have exactly one input
- if (input_count != 1)
- return 0;
-
- // Make sure sizes match up
- if (input_sizes[0]/3 != output_size/4)
- return 0;
-
- // Get the input and output pointers
- const char* input_ptr = inputs[0];
- char* output_ptr = output;
- if (!input_ptr || !output_ptr)
- return 0;
-
- // Run the conversion
- int i;
- for (i = 0; i < output_size / 4; ++i) {
- *(output_ptr++) = *(input_ptr++);
- *(output_ptr++) = *(input_ptr++);
- *(output_ptr++) = *(input_ptr++);
- *(output_ptr++) = 255;
- }
-
- return 1;
-}
-
+++ /dev/null
-# 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.
-#
-
-#
-# Build all native libraries
-#
-include $(call all-subdir-makefiles)
-
-
+++ /dev/null
-# 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.
-#
-
-# Build activity
-
-LOCAL_PATH:= $(call my-dir)
-include $(CLEAR_VARS)
-
-LOCAL_MODULE_TAGS := tests
-
-LOCAL_SRC_FILES := $(call all-subdir-java-files)
-
-LOCAL_PACKAGE_NAME := CameraEffectsRecordingSample
-
-LOCAL_PROGUARD_ENABLED := disabled
-
-include $(BUILD_PACKAGE)
-
-# ============================================================
-
-# Also build all of the sub-targets under this one: the shared library.
-include $(call all-makefiles-under,$(LOCAL_PATH))
+++ /dev/null
-<?xml version="1.0" encoding="utf-8"?>
-<!--
- * 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.
- *
- -->
-<manifest xmlns:android="http://schemas.android.com/apk/res/android"
- android:versionCode="1"
- android:versionName="1.0" package="android.media.filterfw.samples">
- <uses-sdk android:minSdkVersion="3" />
- <uses-permission android:name="android.permission.CAMERA" />
- <uses-permission android:name="android.permission.RECORD_AUDIO" />
- <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
- <uses-feature android:name="android.hardware.camera" />
- <uses-feature android:name="android.hardware.camera.autofocus" />
- <application android:label="@string/app_name"
- android:debuggable="true">
- <activity android:name=".CameraEffectsRecordingSample"
- android:label="@string/app_name">
- <intent-filter>
- <action android:name="android.intent.action.MAIN" />
- <category android:name="android.intent.category.LAUNCHER" />
- </intent-filter>
- </activity>
- </application>
-</manifest>
+++ /dev/null
-/*
- * 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.media.filterfw.samples;
-
-import android.app.Activity;
-import android.os.Bundle;
-import android.os.Environment;
-import android.view.View;
-import android.view.View.OnClickListener;
-import android.view.SurfaceView;
-import android.view.KeyEvent;
-import android.widget.Button;
-import android.filterfw.GraphEnvironment;
-import android.filterfw.core.GraphRunner;
-import android.filterpacks.videosink.MediaEncoderFilter;
-import android.graphics.Bitmap;
-import android.graphics.BitmapFactory;
-import android.content.Intent;
-
-public class CameraEffectsRecordingSample extends Activity {
-
- private Button mRunButton;
- private SurfaceView mCameraView;
-
- private GraphRunner mRunner;
- private int mCameraId = 0;
- private String mOutFileName = Environment.getExternalStorageDirectory().toString() +
- "/CameraEffectsRecordingSample.mp4";
-
- public void onCreate(Bundle savedInstanceState) {
- super.onCreate(savedInstanceState);
- setContentView(R.layout.main);
- mRunButton = (Button) findViewById(R.id.runbutton);
- mCameraView = (SurfaceView) findViewById(R.id.cameraview);
- mRunButton.setOnClickListener(mRunButtonClick);
-
- Intent intent = getIntent();
- if (intent.hasExtra("OUTPUT_FILENAME")) {
- mOutFileName = intent.getStringExtra("OUTPUT_FILENAME");
- }
- // Set up the references and load the filter graph
- createGraph();
- }
-
- @Override
- public boolean onKeyDown(int keyCode, KeyEvent event) {
- switch (keyCode) {
- case KeyEvent.KEYCODE_CAMERA:
- mRunButton.performClick();
- return true;
- }
- return super.onKeyDown(keyCode, event);
- }
-
- private void createGraph() {
- Bitmap sourceBitmap = BitmapFactory.decodeResource(getResources(), R.drawable.android);
- GraphEnvironment graphEnvironment = new GraphEnvironment();
- graphEnvironment.createGLEnvironment();
- graphEnvironment.addReferences("cameraView", mCameraView);
- graphEnvironment.addReferences("cameraId", mCameraId);
- graphEnvironment.addReferences("outputFileName", mOutFileName);
- int graphId = graphEnvironment.loadGraph(this, R.raw.cameraeffectsrecordingsample);
- mRunner = graphEnvironment.getRunner(graphId, GraphEnvironment.MODE_ASYNCHRONOUS);
- }
-
- protected void onPause() {
- super.onPause();
- if (mRunner.isRunning()) {
- mRunner.stop();
- mRunButton.setText("Record");
- }
- }
-
- private OnClickListener mRunButtonClick = new OnClickListener() {
- @Override
- public void onClick(View v) {
- if (mRunner.isRunning()) {
- mRunner.stop();
- mRunButton.setText("Record");
- } else {
- mRunner.run();
- mRunButton.setText("Stop");
- }
- }
- };
-}
+++ /dev/null
-<?xml version="1.0" encoding="utf-8"?>
-<!--
- * 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.
- *
- -->
-<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
- android:orientation="vertical"
- android:layout_width="fill_parent"
- android:layout_height="fill_parent">
- <Button
- android:id="@+id/runbutton"
- android:layout_width="fill_parent"
- android:layout_height="wrap_content"
- android:text="Record" />
- <android.filterfw.core.FilterSurfaceView
- android:id="@+id/cameraview"
- android:layout_height="fill_parent"
- android:layout_width="fill_parent"
- android:layout_weight="1" />
-</LinearLayout>
+++ /dev/null
-// 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.
-
-// A simple graph that displays the raw camera stream.
-
-@setting autoBranch = "synced";
-
-// Imports ---------------------------------------------------
-@import android.filterpacks.videosrc;
-@import android.filterpacks.ui;
-@import android.filterpacks.videosink;
-@import android.filterpacks.base;
-
-// Externals -------------------------------------------------
-@external cameraView;
-@external outputFileName;
-@external cameraId;
-
-@set widthLoc = 320;
-@set heightLoc = 240;
-
-// Filters ---------------------------------------------------
-@filter CameraSource camera {
- id = $cameraId;
- width = $widthLoc;
- height = $heightLoc;
- waitForNewFrame = false;
-}
-
-@filter MediaEncoderFilter mediaEncoder {
- width = $widthLoc;
- height = $heightLoc;
- outputFile = $outputFileName;
-}
-
-@filter SurfaceRenderFilter renderer {
- surfaceView = $cameraView;
-}
-
-
-// Connections -----------------------------------------------
-// Camera->Preview, Camera->Encoder
-// Render camera output on to a surface
-@connect camera[video] => renderer[frame];
-// Also pass it to an encoder
-@connect camera[video] => mediaEncoder[videoframe];
+++ /dev/null
-<?xml version="1.0" encoding="utf-8"?>
-<!--
- * 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.
- *
- -->
-<resources>
- <string name="app_name">CameraEffectsRecordingSample</string>
-</resources>
+++ /dev/null
-#!/usr/bin/env python
-
-#
-# 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.
-#
-
-import os
-import sys
-
-hFileTemplate = """/**
- * This file is auto-generated by platform/system/media/mca/structgen.py! Do NOT modify!
- **/
-
-#ifndef %s
-#define %s
-
-%s
-
-#endif // %s
-"""
-
-jniFileTemplate = """/**
- * This file is auto-generated by platform/system/media/mca/structgen.py! Do NOT modify!
- **/
-
-#include <stdint.h>
-#include "native/%s.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "jni.h"
-
-// Helper functions ////////////////////////////////////////////////////////////////////////////////
-%s* Get%sAtIndex(JNIEnv* env, jobject buffer, int index) {
- jclass base_class = (*env)->FindClass(env, "android/filterfw/core/NativeBuffer");
- jfieldID ptr_field = (*env)->GetFieldID(env, base_class, "mDataPointer", "J");
- uintptr_t data_ptr = (*env)->GetLongField(env, buffer, ptr_field);
- %s* array = (%s*)data_ptr;
- (*env)->DeleteLocalRef(env, base_class);
- return &array[index];
-}
-
-// Declarations ////////////////////////////////////////////////////////////////////////////////////
-JNIEXPORT jint JNICALL
-Java_%s_getElementSize(JNIEnv* env, jobject thiz);
-
-%s
-
-#ifdef __cplusplus
-}
-#endif
-
-// Implementation //////////////////////////////////////////////////////////////////////////////////
-jint Java_%s_getElementSize(JNIEnv* env, jobject thiz) {
- return sizeof(%s);
-}
-
-%s
-"""
-
-javaFileTemplate = """/**
- * This file is auto-generated by platform/system/media/mca/structgen.py! Do NOT modify!
- **/
-
-package %s;
-
-import android.filterfw.core.NativeBuffer;
-
-%s
-"""
-
-
-def ToJavaName(cname, start_upper_at = 1):
- lower = cname.split("_")
- upper = [c.title() for c in lower]
- return "".join(lower[:start_upper_at] + upper[start_upper_at:])
-
-def ToJNIPackage(package, jclassname):
- return "%s_%s" % (package.replace(".", "_"), jclassname)
-
-def ToMacroDefName(cname, pname):
- return "%s_%s" % (pname.replace(".", "_").upper(), cname.upper())
-
-class ParseError:
- def __init__(self, lineno, message):
- self.lineno = lineno
- self.message = message
-
- def __str__(self):
- return "On line %d: %s" % (self.lineno, self.message)
-
-class FieldType_BasePOD:
- def __init__(self, name, structname, jclassname, package, javatype, ctype, jtype, defval):
- self.name = name
- self.structname = structname
- self.jclassname = jclassname
- self.package = package
- self.javatype = javatype
- self.ctype = ctype
- self.jtype = jtype
- self.defval = defval
-
- def cString(self):
- return " %s %s;" % (self.ctype, self.name)
-
- def javaGetter(self):
- return " public %s get%s(int index) {\n"\
- " assertReadable();\n"\
- " return nativeGet%s(index);\n"\
- " }" % (self.javatype, ToJavaName(self.name, 0), ToJavaName(self.name, 0))
-
- def javaSetter(self):
- return " public void set%s(int index, %s value) {\n"\
- " assertWritable();\n"\
- " nativeSet%s(index, value);\n"\
- " }" % (ToJavaName(self.name, 0), self.javatype, ToJavaName(self.name, 0))
-
- def javaNativeGetter(self):
- return " private native %s nativeGet%s(int index);"\
- % (self.javatype, ToJavaName(self.name, 0))
-
- def javaNativeSetter(self):
- return " private native boolean nativeSet%s(int index, %s value);"\
- % (ToJavaName(self.name, 0), self.javatype)
-
- def jniGetterDefString(self):
- return "JNIEXPORT %s JNICALL\n" \
- "Java_%s_nativeGet%s(JNIEnv* env, jobject thiz, jint index);" \
- % (self.jtype, ToJNIPackage(self.package, self.jclassname), ToJavaName(self.name, 0))
-
- def jniGetterImplString(self):
- return \
- "%s Java_%s_nativeGet%s(JNIEnv* env, jobject thiz, jint index) {\n"\
- " %s* instance = Get%sAtIndex(env, thiz, index);\n"\
- " return instance ? instance->%s : %s;\n"\
- "}\n" % (self.jtype, ToJNIPackage(self.package, self.jclassname), ToJavaName(self.name, 0),\
- self.structname, self.structname, self.name, self.defval)
-
- def jniSetterDefString(self):
- return "JNIEXPORT jboolean JNICALL\n" \
- "Java_%s_nativeSet%s(JNIEnv* env, jobject thiz, jint index, %s value);" \
- % (ToJNIPackage(self.package, self.jclassname), ToJavaName(self.name, 0), self.jtype)
-
- def jniSetterImplString(self):
- return \
- "jboolean Java_%s_nativeSet%s(JNIEnv* env, jobject thiz, jint index, %s value) {\n"\
- " %s* instance = Get%sAtIndex(env, thiz, index);\n"\
- " if (instance) {\n"\
- " instance->%s = value;\n"\
- " return JNI_TRUE;\n"\
- " }\n"\
- " return JNI_FALSE;\n"\
- "}\n" % (ToJNIPackage(self.package, self.jclassname), ToJavaName(self.name, 0),\
- self.jtype, self.structname, self.structname, self.name)
-
-class FieldType_Float(FieldType_BasePOD):
- def __init__(self, name, structname, jclassname, package):
- FieldType_BasePOD.__init__(self, name, structname, jclassname, package, "float", "float", "jfloat", "0.0")
-
-class FieldType_Int(FieldType_BasePOD):
- def __init__(self, name, structname, jclassname, package):
- FieldType_BasePOD.__init__(self, name, structname, jclassname, package, "int", "int", "jint", "0")
-
-class FieldType_Long(FieldType_BasePOD):
- def __init__(self, name, structname, jclassname, package):
- FieldType_BasePOD.__init__(self, name, structname, jclassname, package, "long", "long long", "jlong", "0")
-
-class StructSpec:
-
- def parseTextFile(self, filepath):
- # Init
- self.name = None
- self.package = None
- self.fields = []
- self.structname = None
- self.jclassname = None
- self.libname = None
-
- # Open the file
- txtfile = open(filepath)
-
- # Parse it line by line
- lineno = 0
- for line in txtfile:
- # Split line into components
- linecomps = line.split()
- if len(linecomps) == 0:
- continue
-
- # Execute command
- cmd = linecomps[0]
- if cmd == "@name":
- self.commandArgAssert(linecomps, 1, lineno)
- self.name = linecomps[1]
- if not self.structname:
- self.structname = self.name
- if not self.jclassname:
- self.jclassname = self.name
- elif cmd == "@package":
- self.commandArgAssert(linecomps, 1, lineno)
- self.package = linecomps[1]
- elif cmd == "@libname":
- self.commandArgAssert(linecomps, 1, lineno)
- self.libname = linecomps[1]
- elif cmd == "@structname":
- self.commandArgAssert(linecomps, 1, lineno)
- self.structname = linecomps[1]
- elif cmd == "@javaclassname":
- self.commandArgAssert(linecomps, 1, lineno)
- self.jclassname = linecomps[1]
- elif cmd == "@field":
- self.commandArgAssert(linecomps, 2, lineno)
- typestr = linecomps[1]
- if typestr == "int":
- fieldtype = FieldType_Int(linecomps[2], self.structname, self.jclassname, self.package)
- elif typestr == "long":
- fieldtype = FieldType_Long(linecomps[2], self.structname, self.jclassname, self.package)
- elif typestr == "float":
- fieldtype = FieldType_Float(linecomps[2], self.structname, self.jclassname, self.package)
- else:
- raise ParseError(lineno, "Unknown field type '%s'!" % typestr)
- self.fields.append(fieldtype)
- else:
- raise ParseError(lineno, "Unknown command: '%s'!" % cmd)
-
- lineno = lineno + 1
-
- # Make sure we have all required info
- if not self.name:
- raise ParseError(lineno, "Required field '@name' missing!")
- elif not self.package:
- raise ParseError(lineno, "Required field '@package' missing!")
- elif not self.libname:
- raise ParseError(lineno, "Required field '@libname' missing!")
-
- # Normalize values
- if self.libname[:3] == "lib":
- self.libname = self.libname[3:]
-
- def commandArgAssert(self, linecomps, expectedcount, lineno):
- foundcount = len(linecomps) - 1
- if foundcount < expectedcount:
- raise ParseError(lineno, "Not enough arguments specifed for command '%s'! Expected %d, " \
- "but got only %d!" % (linecomps[0], expectedcount, foundcount))
- elif foundcount > expectedcount + 1:
- raise ParseError(lineno, "Too many arguments specifed for command '%s'! Expected %d, " \
- "but got %d!" % (linecomps[0], expectedcount, foundcount))
-
-
- def cStructString(self):
- cfields = [f.cString() for f in self.fields]
- return "typedef struct Struct%s {\n%s\n} %s;\n" % (self.structname,\
- "\n".join(cfields),\
- self.structname)
-
- def javaClassString(self):
- jgetters = [f.javaGetter() for f in self.fields]
- jsetters = [f.javaSetter() for f in self.fields]
- jnativesetters = [f.javaNativeSetter() for f in self.fields]
- jnativegetters = [f.javaNativeGetter() for f in self.fields]
- return "public class %s extends NativeBuffer {\n\n"\
- " public %s() {\n"\
- " super();\n"\
- " }\n"\
- "\n"\
- " public %s(int count) {\n"\
- " super(count);\n"\
- " }\n"\
- "\n"\
- " public native int getElementSize();\n"\
- "\n"\
- "%s\n\n"\
- "%s\n\n"\
- "%s\n\n"\
- "%s\n\n"\
- " static {\n"\
- " System.loadLibrary(\"%s\");\n"\
- " }\n"\
- "\n"\
- "};\n" % (self.jclassname,\
- self.jclassname,\
- self.jclassname,\
- "\n\n".join(jgetters),\
- "\n\n".join(jsetters),\
- "\n\n".join(jnativegetters),\
- "\n\n".join(jnativesetters),\
- self.libname)
-
- def jniDeclString(self):
- jnigetters = [f.jniGetterDefString() for f in self.fields]
- jnisetters = [f.jniSetterDefString() for f in self.fields]
- return "\n\n".join(jnigetters + jnisetters)
-
- def jniImplString(self):
- jnigetters = [f.jniGetterImplString() for f in self.fields]
- jnisetters = [f.jniSetterImplString() for f in self.fields]
- return "\n\n".join(jnigetters + jnisetters)
-
- def hFileString(self):
- defname = ToMacroDefName(self.structname, self.package)
- return hFileTemplate % (defname, defname, self.cStructString(), defname)
-
- def javaFileString(self):
- return javaFileTemplate % (self.package, self.javaClassString())
-
- def jniFileString(self):
- return jniFileTemplate % (self.structname.lower(),\
- self.structname,\
- self.structname,\
- self.structname,\
- self.structname,\
- ToJNIPackage(self.package, self.jclassname),\
- self.jniDeclString(),\
- ToJNIPackage(self.package, self.jclassname),\
- self.structname,
- self.jniImplString())
-
-def main(argv):
- if len(argv) != 2:
- print("Usage: %s <file.struct>" % argv[0])
- return -1
-
- filepath = argv[1]
-
- structspec = StructSpec()
- structspec.parseTextFile(filepath)
-
- hfilename = "%s.h" % structspec.structname.lower()
- javafilename = "%s.java" % structspec.jclassname
- jnifilename = "jni_%s.c" % structspec.structname.lower()
-
- javapackagepath = structspec.package.replace('.','/')
-
- rootdir = os.path.dirname(filepath)
- hfilepath = "%s/../native/%s" % (rootdir, hfilename)
- javafilepath = "%s/../java/%s/%s" % (rootdir, javapackagepath, javafilename)
- jnifilepath = "%s/../jni/%s" % (rootdir, jnifilename)
-
- hfile = open(hfilepath, 'w')
- hfile.write(structspec.hFileString())
- hfile.close()
-
- javafile = open(javafilepath, 'w')
- javafile.write(structspec.javaFileString())
- javafile.close()
-
- jnifile = open(jnifilepath, 'w')
- jnifile.write(structspec.jniFileString())
- jnifile.close()
-
-
-if __name__ == "__main__":
- sys.exit(main(sys.argv))
+++ /dev/null
-LOCAL_PATH:= $(call my-dir)
-include $(CLEAR_VARS)
-
-# We only want this apk build for tests.
-LOCAL_MODULE_TAGS := tests
-
-LOCAL_JAVA_LIBRARIES := android.test.runner
-
-# Include all test java files.
-LOCAL_SRC_FILES := $(call all-java-files-under, src)
-
-LOCAL_PACKAGE_NAME := CameraEffectsTests
-
-LOCAL_INSTRUMENTATION_FOR := CameraEffectsRecordingSample
-
-include $(BUILD_PACKAGE)
-
-
+++ /dev/null
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Copyright (C) 2008 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.
--->
-
-<manifest xmlns:android="http://schemas.android.com/apk/res/android"
- package="android.camera.mediaeffects.tests">
-
- <uses-permission android:name="android.permission.INJECT_EVENTS" />
-
- <application>
- <uses-library android:name="android.test.runner" />
- </application>
-
- <instrumentation android:name="android.test.InstrumentationTestRunner"
- android:targetPackage="android.media.filterfw.samples"
- android:label="Tests for Camera Effects Recording."/>
-</manifest>
+++ /dev/null
-/*
- * 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.camera.mediaeffects.tests.functional;
-
-import android.media.filterfw.samples.CameraEffectsRecordingSample;
-import android.app.Activity;
-import android.app.Instrumentation;
-import android.content.Intent;
-import android.test.ActivityInstrumentationTestCase2;
-import android.test.suitebuilder.annotation.LargeTest;
-import android.view.KeyEvent;
-import android.util.Log;
-import android.content.Intent;
-import android.os.Environment;
-import android.media.MediaMetadataRetriever;
-import android.net.Uri;
-import java.io.File;
-
-public class EffectsVideoCapture extends ActivityInstrumentationTestCase2
- <CameraEffectsRecordingSample> {
- private static final String TAG = "EffectsVideoCaptureTest";
- private static final long WAIT_FOR_PREVIEW = 4 * 1000; // 4 seconds
-
- public EffectsVideoCapture() {
- super(CameraEffectsRecordingSample.class);
- }
-
- private void captureVideos(String reportTag, Instrumentation inst) throws Exception{
- int total_num_of_videos = 1;
- int video_duration = 4 * 1000; // 4 seconds
-
- Log.v(TAG, reportTag);
- for (int i = 0; i < total_num_of_videos; i++) {
- Thread.sleep(WAIT_FOR_PREVIEW);
- // record a video
- inst.sendCharacterSync(KeyEvent.KEYCODE_CAMERA);
- Thread.sleep(video_duration);
- inst.sendCharacterSync(KeyEvent.KEYCODE_CAMERA);
- }
- }
-
- @LargeTest
- public void testBackEffectsVideoCapture() throws Exception {
- Instrumentation inst = getInstrumentation();
-
- Intent intent = new Intent();
- intent.setClass(getInstrumentation().getTargetContext(),
- CameraEffectsRecordingSample.class);
- intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
- intent.putExtra("OUTPUT_FILENAME", Environment.getExternalStorageDirectory().toString()
- + "/CameraEffectsRecordingTest.mp4");
- Activity act = inst.startActivitySync(intent);
- captureVideos("Back Camera Video Capture\n", inst);
- act.finish();
-
- // Verification
- File file = new File(Environment.getExternalStorageDirectory(),
- "CameraEffectsRecordingTest.mp4");
- Uri uri = Uri.fromFile(file);
- verify(getActivity(), uri);
- }
-
- // Verify result code, result data, and the duration.
- private void verify(CameraEffectsRecordingSample activity, Uri uri) throws Exception {
- assertNotNull(uri);
- // Verify the video file
- MediaMetadataRetriever retriever = new MediaMetadataRetriever();
- retriever.setDataSource(activity, uri);
- String duration = retriever.extractMetadata(
- MediaMetadataRetriever.METADATA_KEY_DURATION);
- assertNotNull(duration);
- int durationValue = Integer.parseInt(duration);
- Log.v(TAG, "Video duration is " + durationValue);
- assertTrue(durationValue > 0);
- }
-}
OSDN Git Service
