/* * Copyright (C) 2014 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package android.graphics; import java.awt.Composite; import java.awt.CompositeContext; import java.awt.RenderingHints; import java.awt.image.ColorModel; import java.awt.image.DataBuffer; import java.awt.image.Raster; import java.awt.image.WritableRaster; /* * (non-Javadoc) * The class is adapted from a demo tool for Blending Modes written by * Romain Guy (romainguy@android.com). The tool is available at * http://www.curious-creature.org/2006/09/20/new-blendings-modes-for-java2d/ * * This class has been adapted for applying color filters. When applying color filters, the src * image should not extend beyond the dest image, but in our implementation of the filters, it does. * To compensate for the effect, we recompute the alpha value of the src image before applying * the color filter as it should have been applied. */ public final class BlendComposite implements Composite { public enum BlendingMode { MULTIPLY(), SCREEN(), DARKEN(), LIGHTEN(), OVERLAY(), ADD(); private final BlendComposite mComposite; BlendingMode() { mComposite = new BlendComposite(this); } BlendComposite getBlendComposite() { return mComposite; } } private float alpha; private BlendingMode mode; private BlendComposite(BlendingMode mode) { this(mode, 1.0f); } private BlendComposite(BlendingMode mode, float alpha) { this.mode = mode; setAlpha(alpha); } public static BlendComposite getInstance(BlendingMode mode) { return mode.getBlendComposite(); } public static BlendComposite getInstance(BlendingMode mode, float alpha) { if (alpha > 0.9999f) { return getInstance(mode); } return new BlendComposite(mode, alpha); } public float getAlpha() { return alpha; } public BlendingMode getMode() { return mode; } private void setAlpha(float alpha) { if (alpha < 0.0f || alpha > 1.0f) { assert false : "alpha must be comprised between 0.0f and 1.0f"; alpha = Math.min(alpha, 1.0f); alpha = Math.max(alpha, 0.0f); } this.alpha = alpha; } @Override public int hashCode() { return Float.floatToIntBits(alpha) * 31 + mode.ordinal(); } @Override public boolean equals(Object obj) { if (!(obj instanceof BlendComposite)) { return false; } BlendComposite bc = (BlendComposite) obj; return mode == bc.mode && alpha == bc.alpha; } public CompositeContext createContext(ColorModel srcColorModel, ColorModel dstColorModel, RenderingHints hints) { return new BlendingContext(this); } private static final class BlendingContext implements CompositeContext { private final Blender blender; private final BlendComposite composite; private BlendingContext(BlendComposite composite) { this.composite = composite; this.blender = Blender.getBlenderFor(composite); } public void dispose() { } public void compose(Raster src, Raster dstIn, WritableRaster dstOut) { if (src.getSampleModel().getDataType() != DataBuffer.TYPE_INT || dstIn.getSampleModel().getDataType() != DataBuffer.TYPE_INT || dstOut.getSampleModel().getDataType() != DataBuffer.TYPE_INT) { throw new IllegalStateException( "Source and destination must store pixels as INT."); } int width = Math.min(src.getWidth(), dstIn.getWidth()); int height = Math.min(src.getHeight(), dstIn.getHeight()); float alpha = composite.getAlpha(); int[] srcPixel = new int[4]; int[] dstPixel = new int[4]; int[] result = new int[4]; int[] srcPixels = new int[width]; int[] dstPixels = new int[width]; for (int y = 0; y < height; y++) { dstIn.getDataElements(0, y, width, 1, dstPixels); if (alpha != 0) { src.getDataElements(0, y, width, 1, srcPixels); for (int x = 0; x < width; x++) { // pixels are stored as INT_ARGB // our arrays are [R, G, B, A] int pixel = srcPixels[x]; srcPixel[0] = (pixel >> 16) & 0xFF; srcPixel[1] = (pixel >> 8) & 0xFF; srcPixel[2] = (pixel ) & 0xFF; srcPixel[3] = (pixel >> 24) & 0xFF; pixel = dstPixels[x]; dstPixel[0] = (pixel >> 16) & 0xFF; dstPixel[1] = (pixel >> 8) & 0xFF; dstPixel[2] = (pixel ) & 0xFF; dstPixel[3] = (pixel >> 24) & 0xFF; // ---- Modified from original ---- // recompute src pixel for transparency. srcPixel[3] *= dstPixel[3] / 0xFF; // ---- Modification ends ---- result = blender.blend(srcPixel, dstPixel, result); // mixes the result with the opacity if (alpha == 1) { dstPixels[x] = (result[3] & 0xFF) << 24 | (result[0] & 0xFF) << 16 | (result[1] & 0xFF) << 8 | result[2] & 0xFF; } else { dstPixels[x] = ((int) (dstPixel[3] + (result[3] - dstPixel[3]) * alpha) & 0xFF) << 24 | ((int) (dstPixel[0] + (result[0] - dstPixel[0]) * alpha) & 0xFF) << 16 | ((int) (dstPixel[1] + (result[1] - dstPixel[1]) * alpha) & 0xFF) << 8 | (int) (dstPixel[2] + (result[2] - dstPixel[2]) * alpha) & 0xFF; } } } dstOut.setDataElements(0, y, width, 1, dstPixels); } } } private static abstract class Blender { public abstract int[] blend(int[] src, int[] dst, int[] result); public static Blender getBlenderFor(BlendComposite composite) { switch (composite.getMode()) { case ADD: return new Blender() { @Override public int[] blend(int[] src, int[] dst, int[] result) { for (int i = 0; i < 4; i++) { result[i] = Math.min(255, src[i] + dst[i]); } return result; } }; case DARKEN: return new Blender() { @Override public int[] blend(int[] src, int[] dst, int[] result) { for (int i = 0; i < 3; i++) { result[i] = Math.min(src[i], dst[i]); } result[3] = Math.min(255, src[3] + dst[3]); return result; } }; case LIGHTEN: return new Blender() { @Override public int[] blend(int[] src, int[] dst, int[] result) { for (int i = 0; i < 3; i++) { result[i] = Math.max(src[i], dst[i]); } result[3] = Math.min(255, src[3] + dst[3]); return result; } }; case MULTIPLY: return new Blender() { @Override public int[] blend(int[] src, int[] dst, int[] result) { for (int i = 0; i < 3; i++) { result[i] = (src[i] * dst[i]) >> 8; } result[3] = Math.min(255, src[3] + dst[3] - (src[3] * dst[3]) / 255); return result; } }; case OVERLAY: return new Blender() { @Override public int[] blend(int[] src, int[] dst, int[] result) { for (int i = 0; i < 3; i++) { result[i] = dst[i] < 128 ? dst[i] * src[i] >> 7 : 255 - ((255 - dst[i]) * (255 - src[i]) >> 7); } result[3] = Math.min(255, src[3] + dst[3]); return result; } }; case SCREEN: return new Blender() { @Override public int[] blend(int[] src, int[] dst, int[] result) { result[0] = 255 - ((255 - src[0]) * (255 - dst[0]) >> 8); result[1] = 255 - ((255 - src[1]) * (255 - dst[1]) >> 8); result[2] = 255 - ((255 - src[2]) * (255 - dst[2]) >> 8); result[3] = Math.min(255, src[3] + dst[3]); return result; } }; default: assert false : "Blender not implement for " + composite.getMode().name(); // Ignore the blend return new Blender() { @Override public int[] blend(int[] src, int[] dst, int[] result) { result[0] = dst[0]; result[1] = dst[1]; result[2] = dst[2]; result[3] = dst[3]; return result; } }; } } } }