diff options
Diffstat (limited to 'src/com/android/gallery3d/app/dualcam3d/Effect.java')
| -rwxr-xr-x | src/com/android/gallery3d/app/dualcam3d/Effect.java | 211 |
1 files changed, 211 insertions, 0 deletions
diff --git a/src/com/android/gallery3d/app/dualcam3d/Effect.java b/src/com/android/gallery3d/app/dualcam3d/Effect.java new file mode 100755 index 000000000..0f9cde4cb --- /dev/null +++ b/src/com/android/gallery3d/app/dualcam3d/Effect.java @@ -0,0 +1,211 @@ +/* + * Copyright (c) 2016, The Linux Foundation. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimer in the documentation and/or other materials provided + * with the distribution. + * * Neither the name of The Linux Foundation nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR + * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE + * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN + * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +package com.android.gallery3d.app.dualcam3d; + +import android.graphics.Bitmap; +import android.util.Log; + +import com.android.gallery3d.app.dualcam3d.threed.Controller; +import com.android.gallery3d.filtershow.tools.DualCameraNativeEngine; + +public class Effect implements GLView.Listener { + private static final String TAG = "Effect"; + public static final int INTENSITY_MAX = 10; + public static final float DEFAULT_BRIGHTNESS_INTENSITY = 1.0f; + private static final int PREVIEW_DIMENSION_MAX = 1080; + + enum Type { + NONE, FOCUS, HALO, SKETCH, FUSION, ZOOM, + MOTION, BW, BLACKBOARD, WHITEBOARD, + POSTERIZE, NEGATIVE, THREE_DIMENSIONAL + } + + private final ThreeDimensionalActivity mActivity; + private Bitmap mBitmap; + private Type mType = Type.NONE; + private int mX; + private int mY; + private float mIntensity = 0.5f; + private boolean mIsPreview = true; + + private int mScale; + + private Controller mController; + + private Thread mThread; + private Boolean mCancelled; + + public Effect(ThreeDimensionalActivity activity) { + mActivity = activity; + } + + public void setBitmap(Bitmap bitmap, int scale) { + mBitmap = bitmap; + scaleBitmap(scale); + } + + public static int scale(int width, int height) { + int scale = 1; + while (width / scale > PREVIEW_DIMENSION_MAX || height / scale > PREVIEW_DIMENSION_MAX) { + scale *= 2; + } + return scale > 1 ? scale : 1; + } + + private void scaleBitmap(int scale) { + if (scale != 1) { + mScale = scale; + } else if (mBitmap != null) { + int width = mBitmap.getWidth(), height = mBitmap.getHeight(); + mX = width / 2; + mY = height / 2; + mScale = scale(width, height); + if (mScale != 1) { + mBitmap = Bitmap.createScaledBitmap(mBitmap, + width / mScale, height / mScale, false); + } + } + mActivity.sendMessage(ThreeDimensionalActivity.MSG_UPDATE_IMAGE, mBitmap); + } + + public void set(Type type) { + if (type == Type.THREE_DIMENSIONAL) { + new Thread(new Runnable() { + @Override + public void run() { + DualCameraNativeEngine.DepthMap3D map = DualCameraNativeEngine.getInstance() + .getDepthMap3D(mBitmap); + if (map != null) { + Log.d(TAG, "got 3d map"); + mActivity.sendMessage(ThreeDimensionalActivity.MSG_UPDATE_IMAGE, mBitmap); + mActivity.sendMessage(ThreeDimensionalActivity.MSG_UPDATE_3D_DEPTH_MAP, map); + } else { + Log.e(TAG, "cannot get 3d map"); + } + } + }).start(); + if (mController == null) { + mController = mActivity.getController(); + } + mController.start(); + } else { + if (mController != null) { + mController.stop(true); + } + mActivity.sendMessage(ThreeDimensionalActivity.MSG_UPDATE_3D_DEPTH_MAP, null); + request(); + } + mType = type; + } + + private void setCoordination(float x, float y) { + if (x >= 0 && y >= 0 && x < mBitmap.getWidth() && y < mBitmap.getHeight()) { + mX = (int) (x * mScale); + mY = (int) (y * mScale); + } + } + + public void setIntensity(float intensity) { + if (intensity < 0) intensity = 0; + if (intensity > INTENSITY_MAX) intensity = 1; + if (intensity != mIntensity) { + mIntensity = intensity / INTENSITY_MAX; + request(); + } + } + + private synchronized void request() { + notify(); + } + + + public void recycle() { + if (mBitmap != null) { + mBitmap.recycle(); + } + } + + @Override + public void onMove(float deltaX, float deltaY) { + if (mType == Type.THREE_DIMENSIONAL && mController != null) { + mController.onMove(deltaX, deltaY); + } + } + + @Override + public void onClick(float x, float y) { + if (mType != Type.THREE_DIMENSIONAL) { + setCoordination(x, y); + request(); + } + } + + @Override + public void onLayout(int width, int height) { + } + + public void resume() { + if (mController != null && mType == Type.THREE_DIMENSIONAL) { + mController.start(); + } + mCancelled = false; + mThread = new Thread(new Runnable() { + @Override + public void run() { + while (!mCancelled) { + synchronized (Effect.this) { + try { + Effect.this.wait(); + } catch (InterruptedException ignored) { + } + } + } + } + }); + mThread.start(); + } + + public void pause() { + if (mController != null) { + mController.stop(false); + } + if (mThread != null) { + mCancelled = true; + synchronized (this) { + notify(); + } + try { + mThread.join(); + } catch (InterruptedException ignored) { + } + mThread = null; + } + } +} |