import com.android.gallery3d.filtershow.imageshow.ImageCrop;
import com.android.gallery3d.filtershow.imageshow.ImageShow;
import com.android.gallery3d.filtershow.imageshow.ImageTinyPlanet;
-import com.android.gallery3d.filtershow.imageshow.ImageZoom;
import com.android.gallery3d.filtershow.imageshow.MasterImage;
import com.android.gallery3d.filtershow.presets.ImagePreset;
import com.android.gallery3d.filtershow.provider.SharedImageProvider;
ImageShow.setDefaultBackgroundColor(res.getColor(R.color.background_screen));
// TODO: get those values from XML.
- ImageZoom.setZoomedSize(getPixelsFromDip(256));
FramedTextButton.setTextSize((int) getPixelsFromDip(14));
FramedTextButton.setTrianglePadding((int) getPixelsFromDip(4));
FramedTextButton.setTriangleSize((int) getPixelsFromDip(10));
import com.android.gallery3d.filtershow.filters.ImageFilterRS;
import com.android.gallery3d.filtershow.imageshow.GeometryMetadata;
import com.android.gallery3d.filtershow.imageshow.MasterImage;
+import com.android.gallery3d.filtershow.presets.FilterEnvironment;
import com.android.gallery3d.filtershow.presets.ImagePreset;
public class CachingPipeline {
private volatile Bitmap mOriginalBitmap = null;
private volatile Bitmap mResizedOriginalBitmap = null;
+ private FilterEnvironment mEnvironment = new FilterEnvironment();
+
private volatile Allocation mOriginalAllocation = null;
private volatile Allocation mFiltersOnlyOriginalAllocation = null;
return "UNKNOWN TYPE!";
}
- private void setPresetParameters(ImagePreset preset) {
- preset.setScaleFactor(mPreviewScaleFactor);
- preset.setQuality(ImagePreset.QUALITY_PREVIEW);
- preset.setupEnvironment(mFiltersManager);
- preset.getEnvironment().setCachingPipeline(this);
+ private void setupEnvironment(ImagePreset preset) {
+ mEnvironment.setCachingPipeline(this);
+ mEnvironment.setFiltersManager(mFiltersManager);
+ mEnvironment.setScaleFactor(mPreviewScaleFactor);
+ mEnvironment.setQuality(ImagePreset.QUALITY_PREVIEW);
+ mEnvironment.setImagePreset(preset);
}
public void setOriginal(Bitmap bitmap) {
mOriginalBitmap = bitmap;
Log.v(LOGTAG,"setOriginal, size " + bitmap.getWidth() + " x " + bitmap.getHeight());
ImagePreset preset = MasterImage.getImage().getPreset();
- preset.setupEnvironment(mFiltersManager);
+ setupEnvironment(preset);
updateOriginalAllocation(preset);
}
}
Allocation originalAllocation = mOriginalAllocation;
- mResizedOriginalBitmap = preset.applyGeometry(originalBitmap);
+ mResizedOriginalBitmap = preset.applyGeometry(originalBitmap, mEnvironment);
mOriginalAllocation = Allocation.createFromBitmap(RS, mResizedOriginalBitmap,
Allocation.MipmapControl.MIPMAP_NONE, Allocation.USAGE_SCRIPT);
if (originalAllocation != null) {
Bitmap bitmap = request.getBitmap();
ImagePreset preset = request.getImagePreset();
- setPresetParameters(preset);
+ setupEnvironment(preset);
mFiltersManager.freeFilterResources(preset);
if (request.getType() == RenderingRequest.PARTIAL_RENDERING) {
Log.w(LOGTAG, "loader not yet setup, cannot handle: " + getType(request));
return;
}
- bitmap = loader.getScaleOneImageForPreset(null, preset,
- request.getBounds(), request.getDestination(), false);
+ bitmap = loader.getScaleOneImageForPreset(request.getBounds(),
+ request.getDestination());
if (bitmap == null) {
Log.w(LOGTAG, "could not get bitmap for: " + getType(request));
return;
|| request.getType() == RenderingRequest.FILTERS_RENDERING
|| request.getType() == RenderingRequest.ICON_RENDERING
|| request.getType() == RenderingRequest.PARTIAL_RENDERING) {
- Bitmap bmp = preset.apply(bitmap);
+ Bitmap bmp = preset.apply(bitmap, mEnvironment);
request.setBitmap(bmp);
mFiltersManager.freeFilterResources(preset);
}
}
public synchronized Bitmap renderFinalImage(Bitmap bitmap, ImagePreset preset) {
- setPresetParameters(preset);
+ setupEnvironment(preset);
+ mEnvironment.setQuality(ImagePreset.QUALITY_FINAL);
+ mEnvironment.setScaleFactor(1.0f);
+ mFiltersManager.freeFilterResources(preset);
+ bitmap = preset.applyGeometry(bitmap, mEnvironment);
+ bitmap = preset.apply(bitmap, mEnvironment);
+ return bitmap;
+ }
+
+ public synchronized Bitmap renderGeometryIcon(Bitmap bitmap, ImagePreset preset) {
+ setupEnvironment(preset);
+ mEnvironment.setQuality(ImagePreset.QUALITY_PREVIEW);
mFiltersManager.freeFilterResources(preset);
- bitmap = preset.applyGeometry(bitmap);
- bitmap = preset.apply(bitmap);
+ bitmap = preset.applyGeometry(bitmap, mEnvironment);
return bitmap;
}
String thread = Thread.currentThread().getName();
long time = System.currentTimeMillis();
- setPresetParameters(preset);
+ setupEnvironment(preset);
mFiltersManager.freeFilterResources(preset);
Bitmap resizedOriginalBitmap = mResizedOriginalBitmap;
}
mOriginalAllocation.copyTo(bitmap);
- bitmap = preset.apply(bitmap);
+ bitmap = preset.apply(bitmap, mEnvironment);
mFiltersManager.freeFilterResources(preset);
public String getName() {
return mName;
}
+
}
import com.android.gallery3d.exif.ExifInterface;
import com.android.gallery3d.filtershow.FilterShowActivity;
import com.android.gallery3d.filtershow.HistoryAdapter;
+import com.android.gallery3d.filtershow.filters.FiltersManager;
import com.android.gallery3d.filtershow.imageshow.ImageShow;
import com.android.gallery3d.filtershow.presets.ImagePreset;
import com.android.gallery3d.filtershow.tools.BitmapTask;
}
};
- // FIXME: this currently does the loading + filtering on the UI thread --
- // need to move this to a background thread.
- public Bitmap getScaleOneImageForPreset(ImageShow caller, ImagePreset imagePreset, Rect bounds,
- Rect destination, boolean force) {
+ public Bitmap getScaleOneImageForPreset(Rect bounds, Rect destination) {
mLoadingLock.lock();
- Bitmap bmp = mZoomCache.getImage(imagePreset, bounds);
- if (force || bmp == null) {
- BitmapFactory.Options options = new BitmapFactory.Options();
- options.inMutable = true;
- if (destination != null) {
- if (bounds.width() > destination.width()) {
- int sampleSize = 1;
- int w = bounds.width();
- while (w > destination.width()) {
- sampleSize *= 2;
- w /= sampleSize;
- }
- options.inSampleSize = sampleSize;
+ BitmapFactory.Options options = new BitmapFactory.Options();
+ options.inMutable = true;
+ if (destination != null) {
+ if (bounds.width() > destination.width()) {
+ int sampleSize = 1;
+ int w = bounds.width();
+ while (w > destination.width()) {
+ sampleSize *= 2;
+ w /= sampleSize;
}
- }
- bmp = loadRegionBitmap(mUri, options, bounds);
- if (destination != null) {
- mLoadingLock.unlock();
- return bmp;
- }
- if (bmp != null) {
- float scaleFactor = imagePreset.getScaleFactor();
- float scale = (float) bmp.getWidth() / (float) getOriginalBounds().width();
- imagePreset.setScaleFactor(scale);
- imagePreset.setupEnvironment();
- bmp = imagePreset.apply(bmp);
- imagePreset.setScaleFactor(scaleFactor);
- mZoomCache.setImage(imagePreset, bounds, bmp);
- mLoadingLock.unlock();
- return bmp;
+ options.inSampleSize = sampleSize;
}
}
+ Bitmap bmp = loadRegionBitmap(mUri, options, bounds);
mLoadingLock.unlock();
return bmp;
}
public void saveImage(ImagePreset preset, final FilterShowActivity filterShowActivity,
File destination) {
- preset.setQuality(ImagePreset.QUALITY_FINAL);
- preset.setScaleFactor(1.0f);
new SaveCopyTask(mContext, mUri, destination, new SaveCopyTask.Callback() {
@Override
public void returnFilteredResult(ImagePreset preset,
final FilterShowActivity filterShowActivity) {
- preset.setQuality(ImagePreset.QUALITY_FINAL);
- preset.setScaleFactor(1.0f);
-
BitmapTask.Callbacks<ImagePreset> cb = new BitmapTask.Callbacks<ImagePreset>() {
@Override
Log.w(LOGTAG, "Failed to save image!");
return null;
}
- param.setupEnvironment();
- bitmap = param.applyGeometry(bitmap);
- bitmap = param.apply(bitmap);
+ CachingPipeline pipeline = new CachingPipeline(
+ FiltersManager.getManager(), "Saving");
+ bitmap = pipeline.renderFinalImage(bitmap, param);
noBitmap = false;
} catch (java.lang.OutOfMemoryError e) {
// Try 5 times before failing for good.
import android.graphics.Bitmap;
import android.graphics.Rect;
import com.android.gallery3d.app.Log;
+import com.android.gallery3d.filtershow.filters.FiltersManager;
import com.android.gallery3d.filtershow.imageshow.MasterImage;
+import com.android.gallery3d.filtershow.presets.FilterEnvironment;
import com.android.gallery3d.filtershow.presets.ImagePreset;
public class RenderingRequest {
if (type == FULL_RENDERING
|| type == GEOMETRY_RENDERING
|| type == ICON_RENDERING) {
- preset.setupEnvironment();
- bitmap = preset.applyGeometry(source);
+ CachingPipeline pipeline = new CachingPipeline(
+ FiltersManager.getManager(), "Icon");
+ bitmap = pipeline.renderGeometryIcon(source, preset);
} else if (type != PARTIAL_RENDERING) {
bitmap = Bitmap.createBitmap(source.getWidth(), source.getHeight(), mConfig);
}
if (preset == null) {
return;
}
- Vector<ImageFilter> usedFilters = preset.getUsedFilters();
+ Vector<ImageFilter> usedFilters = preset.getUsedFilters(this);
for (Class c : mFilters.keySet()) {
ImageFilter filter = mFilters.get(c);
if (!usedFilters.contains(filter)) {
+++ /dev/null
-/*
- * Copyright (C) 2012 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 com.android.gallery3d.filtershow.imageshow;
-
-import android.content.Context;
-import android.graphics.*;
-import android.util.AttributeSet;
-import android.view.MotionEvent;
-
-import com.android.gallery3d.filtershow.cache.ImageLoader;
-
-public class ImageZoom extends ImageShow {
- private static final String LOGTAG = "ImageZoom";
- private boolean mTouchDown = false;
- private boolean mZoomedIn = false;
- private Rect mZoomBounds = null;
- private static float mMaxSize = 512;
-
- public ImageZoom(Context context) {
- super(context);
- }
-
- public ImageZoom(Context context, AttributeSet attrs) {
- super(context, attrs);
- }
-
- public static void setZoomedSize(float size) {
- mMaxSize = size;
- }
-
- @Override
- public void resetParameter() {
- super.resetParameter();
- mZoomedIn = false;
- mTouchDown = false;
- }
-
- public void onTouchDown(float x, float y) {
- if (mZoomedIn || mTouchDown) {
- return;
- }
- mTouchDown = true;
- GeometryMetadata geo = getImagePreset().mGeoData;
- Matrix originalToScreen = geo.getOriginalToScreen(true,
- mImageLoader.getOriginalBounds().width(),
- mImageLoader.getOriginalBounds().height(),
- getWidth(), getHeight());
- float[] point = new float[2];
- point[0] = x;
- point[1] = y;
- Matrix inverse = new Matrix();
- originalToScreen.invert(inverse);
- inverse.mapPoints(point);
-
- float ratio = (float) getWidth() / (float) getHeight();
- float mh = mMaxSize;
- float mw = ratio * mh;
- Point touch = getTouchPoint();
- RectF zoomRect = new RectF(touch.x - mw, touch.y - mh, touch.x + mw, touch.y + mw);
- inverse.mapRect(zoomRect);
- zoomRect.set(zoomRect.centerX() - mw, zoomRect.centerY() - mh,
- zoomRect.centerX() + mw, zoomRect.centerY() + mh);
- mZoomBounds = new Rect((int) zoomRect.left, (int) zoomRect.top,
- (int) zoomRect.right, (int) zoomRect.bottom);
- invalidate();
- }
-
- public void onTouchUp() {
- mTouchDown = false;
- }
-
- @Override
- public void onDraw(Canvas canvas) {
- drawBackground(canvas);
-
- Bitmap filteredImage = null;
- if ((mZoomedIn || mTouchDown) && mImageLoader != null) {
- filteredImage = mImageLoader.getScaleOneImageForPreset(this, getImagePreset(),
- mZoomBounds, null, false);
- } else {
- filteredImage = getFilteredImage();
- }
- canvas.save();
- if (mZoomedIn || mTouchDown) {
- int orientation = ImageLoader.getZoomOrientation();
- switch (orientation) {
- case ImageLoader.ORI_ROTATE_90: {
- canvas.rotate(90, getWidth() / 2, getHeight() / 2);
- break;
- }
- case ImageLoader.ORI_ROTATE_270: {
- canvas.rotate(270, getWidth() / 2, getHeight() / 2);
- break;
- }
- case ImageLoader.ORI_TRANSPOSE: {
- canvas.rotate(90, getWidth() / 2, getHeight() / 2);
- canvas.scale(1, -1);
- break;
- }
- case ImageLoader.ORI_TRANSVERSE: {
- canvas.rotate(270, getWidth() / 2, getHeight() / 2);
- canvas.scale(1, -1);
- break;
- }
- }
- }
- drawImage(canvas, filteredImage);
- canvas.restore();
-
- drawToast(canvas);
- }
-
- @Override
- public boolean onDoubleTap(MotionEvent event) {
-
- if (!mZoomedIn) {
- onTouchDown(event.getX(), event.getY());
- } else {
- onTouchUp();
- }
- mZoomedIn = !mZoomedIn;
- invalidate();
- return false;
- }
-}
import com.android.gallery3d.filtershow.ImageStateAdapter;
import com.android.gallery3d.filtershow.cache.ImageLoader;
+import com.android.gallery3d.filtershow.filters.BaseFiltersManager;
import com.android.gallery3d.filtershow.filters.FilterRepresentation;
import com.android.gallery3d.filtershow.filters.FiltersManager;
import com.android.gallery3d.filtershow.filters.ImageFilter;
private static final String LOGTAG = "ImagePreset";
private FilterRepresentation mBorder = null;
- private float mScaleFactor = 1.0f;
public static final int QUALITY_ICON = 0;
public static final int QUALITY_PREVIEW = 1;
public static final int QUALITY_FINAL = 2;
- private int mQuality = QUALITY_PREVIEW;
private ImageLoader mImageLoader = null;
private Vector<FilterRepresentation> mFilters = new Vector<FilterRepresentation>();
private Bitmap mPreviewImage;
- private FilterEnvironment mEnvironment = new FilterEnvironment();
-
public ImagePreset() {
setup();
}
// do nothing here
}
- public void setupEnvironment() {
- setupEnvironment(FiltersManager.getManager());
- }
-
- public void setupEnvironment(FiltersManager filtersManager) {
- getEnvironment().setImagePreset(this);
- getEnvironment().setScaleFactor(mScaleFactor);
- getEnvironment().setQuality(mQuality);
- getEnvironment().setFiltersManager(filtersManager);
- }
-
- public Bitmap apply(Bitmap original) {
+ public Bitmap apply(Bitmap original, FilterEnvironment environment) {
Bitmap bitmap = original;
- bitmap = applyFilters(bitmap, -1, -1);
- return applyBorder(bitmap);
+ bitmap = applyFilters(bitmap, -1, -1, environment);
+ return applyBorder(bitmap, environment);
}
- public Bitmap applyGeometry(Bitmap bitmap) {
+ public Bitmap applyGeometry(Bitmap bitmap, FilterEnvironment environment) {
// Apply any transform -- 90 rotate, flip, straighten, crop
// Returns a new bitmap.
if (mDoApplyGeometry) {
mGeoData.synchronizeRepresentation();
- bitmap = mEnvironment.applyRepresentation(mGeoData, bitmap);
+ bitmap = environment.applyRepresentation(mGeoData, bitmap);
}
return bitmap;
}
- public Bitmap applyBorder(Bitmap bitmap) {
+ public Bitmap applyBorder(Bitmap bitmap, FilterEnvironment environment) {
if (mBorder != null && mDoApplyGeometry) {
mBorder.synchronizeRepresentation();
- bitmap = mEnvironment.applyRepresentation(mBorder, bitmap);
+ bitmap = environment.applyRepresentation(mBorder, bitmap);
}
return bitmap;
}
- public Bitmap applyFilters(Bitmap bitmap, int from, int to) {
+ public Bitmap applyFilters(Bitmap bitmap, int from, int to, FilterEnvironment environment) {
if (mDoApplyFilters) {
if (from < 0) {
from = 0;
representation = mFilters.elementAt(i);
representation.synchronizeRepresentation();
}
- bitmap = mEnvironment.applyRepresentation(representation, bitmap);
+ bitmap = environment.applyRepresentation(representation, bitmap);
}
}
imageStateAdapter.notifyDataSetChanged();
}
- public float getScaleFactor() {
- return mScaleFactor;
- }
-
- public int getQuality() {
- return mQuality;
- }
-
- public void setQuality(int value) {
- mQuality = value;
- }
-
- public void setScaleFactor(float value) {
- mScaleFactor = value;
- }
-
public void setPartialRendering(boolean partialRendering, Rect bounds) {
mPartialRendering = partialRendering;
mPartialRenderingBounds = bounds;
mPreviewImage = previewImage;
}
- public Vector<ImageFilter> getUsedFilters() {
+ public Vector<ImageFilter> getUsedFilters(BaseFiltersManager filtersManager) {
Vector<ImageFilter> usedFilters = new Vector<ImageFilter>();
for (int i = 0; i < mFilters.size(); i++) {
FilterRepresentation representation = mFilters.elementAt(i);
- FiltersManager filtersManager = getEnvironment().getFiltersManager();
ImageFilter filter = filtersManager.getFilterForRepresentation(representation);
usedFilters.add(filter);
}
return usedFilters;
}
- public FilterEnvironment getEnvironment() {
- return mEnvironment;
- }
}
OSDN Git Service
