| /* |
| * Copyright (c) 1997, 2007, Oracle and/or its affiliates. All rights reserved. |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This code is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. Oracle designates this |
| * particular file as subject to the "Classpath" exception as provided |
| * by Oracle in the LICENSE file that accompanied this code. |
| * |
| * This code is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| */ |
| |
| /* |
| * @author Charlton Innovations, Inc. |
| * @author Jim Graham |
| */ |
| |
| package sun.java2d.loops; |
| |
| import java.awt.Composite; |
| import java.awt.Rectangle; |
| import java.awt.image.ColorModel; |
| import java.awt.image.DataBuffer; |
| import java.awt.image.Raster; |
| import java.awt.image.WritableRaster; |
| import sun.awt.image.IntegerComponentRaster; |
| import sun.java2d.SurfaceData; |
| import sun.java2d.pipe.Region; |
| import sun.java2d.pipe.SpanIterator; |
| |
| /** |
| * CustomComponent, collection of GraphicsPrimitive |
| * Basically, this collection of components performs conversion from |
| * ANY to ANY via opaque copy |
| */ |
| public final class CustomComponent { |
| public static void register() { |
| // REMIND: This does not work for all destinations yet since |
| // the screen SurfaceData objects do not implement getRaster |
| Class<?> owner = CustomComponent.class; |
| GraphicsPrimitive[] primitives = { |
| new GraphicsPrimitiveProxy(owner, "OpaqueCopyAnyToArgb", |
| Blit.methodSignature, |
| Blit.primTypeID, |
| SurfaceType.Any, |
| CompositeType.SrcNoEa, |
| SurfaceType.IntArgb), |
| new GraphicsPrimitiveProxy(owner, "OpaqueCopyArgbToAny", |
| Blit.methodSignature, |
| Blit.primTypeID, |
| SurfaceType.IntArgb, |
| CompositeType.SrcNoEa, |
| SurfaceType.Any), |
| new GraphicsPrimitiveProxy(owner, "XorCopyArgbToAny", |
| Blit.methodSignature, |
| Blit.primTypeID, |
| SurfaceType.IntArgb, |
| CompositeType.Xor, |
| SurfaceType.Any), |
| }; |
| GraphicsPrimitiveMgr.register(primitives); |
| } |
| |
| public static Region getRegionOfInterest(SurfaceData src, SurfaceData dst, |
| Region clip, |
| int srcx, int srcy, |
| int dstx, int dsty, |
| int w, int h) |
| { |
| /* |
| * Intersect all of: |
| * - operation area (dstx, dsty, w, h) |
| * - destination bounds |
| * - (translated) src bounds |
| * - supplied clip (may be non-rectangular) |
| * Intersect the rectangular regions first since those are |
| * simpler operations. |
| */ |
| Region ret = Region.getInstanceXYWH(dstx, dsty, w, h); |
| ret = ret.getIntersection(dst.getBounds()); |
| Rectangle r = src.getBounds(); |
| // srcxy in src space maps to dstxy in dst space |
| r.translate(dstx - srcx, dsty - srcy); |
| ret = ret.getIntersection(r); |
| if (clip != null) { |
| // Intersect with clip last since it may be non-rectangular |
| ret = ret.getIntersection(clip); |
| } |
| return ret; |
| } |
| } |
| |
| /** |
| * ANY format to ARGB format Blit |
| */ |
| class OpaqueCopyAnyToArgb extends Blit { |
| OpaqueCopyAnyToArgb() { |
| super(SurfaceType.Any, |
| CompositeType.SrcNoEa, |
| SurfaceType.IntArgb); |
| } |
| |
| public void Blit(SurfaceData src, SurfaceData dst, |
| Composite comp, Region clip, |
| int srcx, int srcy, int dstx, int dsty, int w, int h) |
| { |
| Raster srcRast = src.getRaster(srcx, srcy, w, h); |
| ColorModel srcCM = src.getColorModel(); |
| |
| Raster dstRast = dst.getRaster(dstx, dsty, w, h); |
| IntegerComponentRaster icr = (IntegerComponentRaster) dstRast; |
| int[] dstPix = icr.getDataStorage(); |
| |
| Region roi = CustomComponent.getRegionOfInterest(src, dst, clip, |
| srcx, srcy, |
| dstx, dsty, w, h); |
| SpanIterator si = roi.getSpanIterator(); |
| |
| Object srcPix = null; |
| |
| int dstScan = icr.getScanlineStride(); |
| // assert(icr.getPixelStride() == 1); |
| srcx -= dstx; |
| srcy -= dsty; |
| int span[] = new int[4]; |
| while (si.nextSpan(span)) { |
| int rowoff = icr.getDataOffset(0) + span[1] * dstScan + span[0]; |
| for (int y = span[1]; y < span[3]; y++) { |
| int off = rowoff; |
| for (int x = span[0]; x < span[2]; x++) { |
| srcPix = srcRast.getDataElements(x+srcx, y+srcy, srcPix); |
| dstPix[off++] = srcCM.getRGB(srcPix); |
| } |
| rowoff += dstScan; |
| } |
| } |
| // Pixels in the dest were modified directly, we must |
| // manually notify the raster that it was modified |
| icr.markDirty(); |
| // REMIND: We need to do something to make sure that dstRast |
| // is put back to the destination (as in the native Release |
| // function) |
| // src.releaseRaster(srcRast); // NOP? |
| // dst.releaseRaster(dstRast); |
| } |
| } |
| |
| /** |
| * ARGB format to ANY format Blit |
| */ |
| class OpaqueCopyArgbToAny extends Blit { |
| OpaqueCopyArgbToAny() { |
| super(SurfaceType.IntArgb, |
| CompositeType.SrcNoEa, |
| SurfaceType.Any); |
| } |
| |
| public void Blit(SurfaceData src, SurfaceData dst, |
| Composite comp, Region clip, |
| int srcx, int srcy, int dstx, int dsty, int w, int h) |
| { |
| Raster srcRast = src.getRaster(srcx, srcy, w, h); |
| IntegerComponentRaster icr = (IntegerComponentRaster) srcRast; |
| int[] srcPix = icr.getDataStorage(); |
| |
| WritableRaster dstRast = |
| (WritableRaster) dst.getRaster(dstx, dsty, w, h); |
| ColorModel dstCM = dst.getColorModel(); |
| |
| Region roi = CustomComponent.getRegionOfInterest(src, dst, clip, |
| srcx, srcy, |
| dstx, dsty, w, h); |
| SpanIterator si = roi.getSpanIterator(); |
| |
| Object dstPix = null; |
| |
| int srcScan = icr.getScanlineStride(); |
| // assert(icr.getPixelStride() == 1); |
| srcx -= dstx; |
| srcy -= dsty; |
| int span[] = new int[4]; |
| while (si.nextSpan(span)) { |
| int rowoff = (icr.getDataOffset(0) + |
| (srcy + span[1]) * srcScan + |
| (srcx + span[0])); |
| for (int y = span[1]; y < span[3]; y++) { |
| int off = rowoff; |
| for (int x = span[0]; x < span[2]; x++) { |
| dstPix = dstCM.getDataElements(srcPix[off++], dstPix); |
| dstRast.setDataElements(x, y, dstPix); |
| } |
| rowoff += srcScan; |
| } |
| } |
| // REMIND: We need to do something to make sure that dstRast |
| // is put back to the destination (as in the native Release |
| // function) |
| // src.releaseRaster(srcRast); // NOP? |
| // dst.releaseRaster(dstRast); |
| } |
| } |
| |
| /** |
| * ARGB format to ANY format Blit (pixels are XORed together with XOR pixel) |
| */ |
| class XorCopyArgbToAny extends Blit { |
| XorCopyArgbToAny() { |
| super(SurfaceType.IntArgb, |
| CompositeType.Xor, |
| SurfaceType.Any); |
| } |
| |
| public void Blit(SurfaceData src, SurfaceData dst, |
| Composite comp, Region clip, |
| int srcx, int srcy, int dstx, int dsty, int w, int h) |
| { |
| Raster srcRast = src.getRaster(srcx, srcy, w, h); |
| IntegerComponentRaster icr = (IntegerComponentRaster) srcRast; |
| int[] srcPix = icr.getDataStorage(); |
| |
| WritableRaster dstRast = |
| (WritableRaster) dst.getRaster(dstx, dsty, w, h); |
| ColorModel dstCM = dst.getColorModel(); |
| |
| Region roi = CustomComponent.getRegionOfInterest(src, dst, clip, |
| srcx, srcy, |
| dstx, dsty, w, h); |
| SpanIterator si = roi.getSpanIterator(); |
| |
| int xorrgb = ((XORComposite)comp).getXorColor().getRGB(); |
| Object xorPixel = dstCM.getDataElements(xorrgb, null); |
| |
| Object srcPixel = null; |
| Object dstPixel = null; |
| |
| int srcScan = icr.getScanlineStride(); |
| // assert(icr.getPixelStride() == 1); |
| srcx -= dstx; |
| srcy -= dsty; |
| int span[] = new int[4]; |
| while (si.nextSpan(span)) { |
| int rowoff = (icr.getDataOffset(0) + |
| (srcy + span[1]) * srcScan + |
| (srcx + span[0])); |
| for (int y = span[1]; y < span[3]; y++) { |
| int off = rowoff; |
| for (int x = span[0]; x < span[2]; x++) { |
| // REMIND: alpha bits of the destination pixel are |
| // currently altered by the XOR operation, but |
| // should be left untouched |
| srcPixel = dstCM.getDataElements(srcPix[off++], srcPixel); |
| dstPixel = dstRast.getDataElements(x, y, dstPixel); |
| |
| switch (dstCM.getTransferType()) { |
| case DataBuffer.TYPE_BYTE: |
| byte[] bytesrcarr = (byte[]) srcPixel; |
| byte[] bytedstarr = (byte[]) dstPixel; |
| byte[] bytexorarr = (byte[]) xorPixel; |
| for (int i = 0; i < bytedstarr.length; i++) { |
| bytedstarr[i] ^= bytesrcarr[i] ^ bytexorarr[i]; |
| } |
| break; |
| case DataBuffer.TYPE_SHORT: |
| case DataBuffer.TYPE_USHORT: |
| short[] shortsrcarr = (short[]) srcPixel; |
| short[] shortdstarr = (short[]) dstPixel; |
| short[] shortxorarr = (short[]) xorPixel; |
| for (int i = 0; i < shortdstarr.length; i++) { |
| shortdstarr[i] ^= shortsrcarr[i] ^ shortxorarr[i]; |
| } |
| break; |
| case DataBuffer.TYPE_INT: |
| int[] intsrcarr = (int[]) srcPixel; |
| int[] intdstarr = (int[]) dstPixel; |
| int[] intxorarr = (int[]) xorPixel; |
| for (int i = 0; i < intdstarr.length; i++) { |
| intdstarr[i] ^= intsrcarr[i] ^ intxorarr[i]; |
| } |
| break; |
| case DataBuffer.TYPE_FLOAT: |
| float[] floatsrcarr = (float[]) srcPixel; |
| float[] floatdstarr = (float[]) dstPixel; |
| float[] floatxorarr = (float[]) xorPixel; |
| for (int i = 0; i < floatdstarr.length; i++) { |
| int v = (Float.floatToIntBits(floatdstarr[i]) ^ |
| Float.floatToIntBits(floatsrcarr[i]) ^ |
| Float.floatToIntBits(floatxorarr[i])); |
| floatdstarr[i] = Float.intBitsToFloat(v); |
| } |
| break; |
| case DataBuffer.TYPE_DOUBLE: |
| double[] doublesrcarr = (double[]) srcPixel; |
| double[] doubledstarr = (double[]) dstPixel; |
| double[] doublexorarr = (double[]) xorPixel; |
| for (int i = 0; i < doubledstarr.length; i++) { |
| long v = (Double.doubleToLongBits(doubledstarr[i]) ^ |
| Double.doubleToLongBits(doublesrcarr[i]) ^ |
| Double.doubleToLongBits(doublexorarr[i])); |
| doubledstarr[i] = Double.longBitsToDouble(v); |
| } |
| break; |
| default: |
| throw new InternalError("Unsupported XOR pixel type"); |
| } |
| dstRast.setDataElements(x, y, dstPixel); |
| } |
| rowoff += srcScan; |
| } |
| } |
| // REMIND: We need to do something to make sure that dstRast |
| // is put back to the destination (as in the native Release |
| // function) |
| // src.releaseRaster(srcRast); // NOP? |
| // dst.releaseRaster(dstRast); |
| } |
| } |