/* * 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);    }}