/*
 * Copyright (c) 2002, 2007, Oracle and/or its affiliates. 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 Oracle 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 BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
 * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE 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.
 */

/*
 * This source code is provided to illustrate the usage of a given feature
 * or technique and has been deliberately simplified. Additional steps
 * required for a production-quality application, such as security checks,
 * input validation and proper error handling, might not be present in
 * this sample code.
 */


package j2dbench.tests;

import j2dbench.Destinations;
import j2dbench.Group;
import j2dbench.Modifier;
import j2dbench.Option;
import j2dbench.TestEnvironment;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Color;
import java.awt.Image;
import java.awt.Canvas;
import java.awt.AlphaComposite;
import java.awt.Dimension;
import java.awt.GraphicsConfiguration;
import java.awt.image.BufferedImage;
import java.awt.image.BufferedImageOp;
import java.awt.image.ByteLookupTable;
import java.awt.image.ConvolveOp;
import java.awt.image.DataBuffer;
import java.awt.image.IndexColorModel;
import java.awt.image.Kernel;
import java.awt.image.LookupOp;
import java.awt.image.Raster;
import java.awt.image.RasterOp;
import java.awt.image.RescaleOp;
import java.awt.image.ShortLookupTable;
import java.awt.image.VolatileImage;
import java.awt.image.WritableRaster;
import java.awt.Transparency;
import java.awt.geom.AffineTransform;
import java.awt.image.DataBufferByte;
import java.awt.image.DataBufferInt;
import java.awt.image.DataBufferShort;
import java.util.ArrayList;
import javax.swing.JComponent;

public abstract class ImageTests extends GraphicsTests {
    public static boolean hasVolatileImage;
    public static boolean hasCompatImage;

    static {
        try {
            hasVolatileImage = (VolatileImage.class != null);
        } catch (NoClassDefFoundError e) {
        }
        try {
            new Canvas().getGraphicsConfiguration();
            hasCompatImage = true;
        } catch (NoSuchMethodError e) {
        }
    }

    static Group imageroot;
    static Group.EnableSet imgsrcroot;
    static Group.EnableSet bufimgsrcroot;

    static Group imgtestroot;
    static Group imgoptionsroot;

    static Group imageOpRoot;
    static Group imageOpOptRoot;
    static Group imageOpTestRoot;
    static Group graphicsTestRoot;
    static Group bufImgOpTestRoot;
    static Group rasterOpTestRoot;
    static Option opList;
    static Option doTouchSrc;

    static String transNodeNames[] = {
        null, "opaque", "bitmask", "translucent",
    };

    static String transDescriptions[] = {
        null, "Opaque", "Bitmask", "Translucent",
    };

    public static void init() {
        imageroot = new Group(graphicsroot, "imaging",
                              "Imaging Benchmarks");
        imageroot.setTabbed();

        imgsrcroot = new Group.EnableSet(imageroot, "src",
                                         "Image Rendering Sources");
        imgsrcroot.setBordered(true);

        imgoptionsroot = new Group(imgsrcroot, "options",
                                "Image Source Options");
        imgoptionsroot.setBordered(true);
        doTouchSrc =
            new Option.Toggle(imgoptionsroot, "touchsrc",
                              "Touch src image before every operation",
                               Option.Toggle.Off);

        imgtestroot = new Group(imageroot, "tests",
                                "Image Rendering Tests");
        imgtestroot.setBordered(true);

        new OffScreen();

        if (hasGraphics2D) {
            if (hasCompatImage) {
                new CompatImg(Transparency.OPAQUE);
                new CompatImg(Transparency.BITMASK);
                new CompatImg(Transparency.TRANSLUCENT);
            }

            if (hasVolatileImage) {
                new VolatileImg();
            }

            bufimgsrcroot =
                new Group.EnableSet(imgsrcroot, "bufimg",
                                    "BufferedImage Rendering Sources");
            new BufImg(BufferedImage.TYPE_INT_RGB);
            new BufImg(BufferedImage.TYPE_INT_ARGB);
            new BufImg(BufferedImage.TYPE_BYTE_GRAY);
            new BufImg(BufferedImage.TYPE_3BYTE_BGR);
            new BmByteIndexBufImg();
            new BufImg(BufferedImage.TYPE_INT_RGB, true);
            new BufImg(BufferedImage.TYPE_INT_ARGB, true);
            new BufImg(BufferedImage.TYPE_3BYTE_BGR, true);

            imageOpRoot = new Group(imageroot, "imageops",
                                    "Image Op Benchmarks");
            imageOpOptRoot = new Group(imageOpRoot, "opts", "Options");
            imageOpTestRoot = new Group(imageOpRoot, "tests", "Tests");
            graphicsTestRoot = new Group(imageOpTestRoot, "graphics2d",
                                         "Graphics2D Tests");
            bufImgOpTestRoot = new Group(imageOpTestRoot, "bufimgop",
                                         "BufferedImageOp Tests");
            rasterOpTestRoot = new Group(imageOpTestRoot, "rasterop",
                                         "RasterOp Tests");

            ArrayList opStrs = new ArrayList();
            ArrayList opDescs = new ArrayList();
            opStrs.add("convolve3x3zero");
            opDescs.add("ConvolveOp (3x3 blur, zero)");
            opStrs.add("convolve3x3noop");
            opDescs.add("ConvolveOp (3x3 blur, noop)");
            opStrs.add("convolve5x5zero");
            opDescs.add("ConvolveOp (5x5 edge, zero)");
            opStrs.add("convolve5x5noop");
            opDescs.add("ConvolveOp (5x5 edge, noop)");
            opStrs.add("lookup1byte");
            opDescs.add("LookupOp (1 band, byte)");
            opStrs.add("lookup1short");
            opDescs.add("LookupOp (1 band, short)");
            opStrs.add("lookup3byte");
            opDescs.add("LookupOp (3 band, byte)");
            opStrs.add("lookup3short");
            opDescs.add("LookupOp (3 band, short)");
            opStrs.add("rescale1band");
            opDescs.add("RescaleOp (1 band)");
            opStrs.add("rescale3band");
            opDescs.add("RescaleOp (3 band)");
            String[] opStrArr = new String[opStrs.size()];
            opStrArr = (String[])opStrs.toArray(opStrArr);
            String[] opDescArr = new String[opDescs.size()];
            opDescArr = (String[])opDescs.toArray(opDescArr);
            opList =
                new Option.ObjectList(imageOpOptRoot,
                                      "op", "Operation",
                                      opStrArr, opStrArr,
                                      opStrArr, opDescArr,
                                      0x1);
            ((Option.ObjectList) opList).setNumRows(4);

            new DrawImageOp();
            new BufImgOpFilter(false);
            new BufImgOpFilter(true);
            new RasterOpFilter(false);
            new RasterOpFilter(true);
        }

        new DrawImage();
        new DrawImageBg();
        new DrawImageScale("up", 1.5f);
        new DrawImageScale("down", .75f);
        new DrawImageTransform();
    }

    public static class Context extends GraphicsTests.Context {
        boolean touchSrc;
        Image src;
        AffineTransform tx;
    }

    public ImageTests(Group parent, String nodeName, String description) {
        this(parent, nodeName, description, null);
    }

    public ImageTests(Group parent, String nodeName, String description,
                      Modifier.Filter srcFilter)
    {
        super(parent, nodeName, description);
        addDependency(imgsrcroot, srcFilter);
        addDependency(doTouchSrc);
    }

    public GraphicsTests.Context createContext() {
        return new ImageTests.Context();
    }

    public void initContext(TestEnvironment env, GraphicsTests.Context ctx) {
        super.initContext(env, ctx);
        ImageTests.Context ictx = (ImageTests.Context) ctx;

        ictx.src = env.getSrcImage();
        ictx.touchSrc = env.isEnabled(doTouchSrc);
    }

    public abstract static class TriStateImageType extends Group {
        Image theImage;

        public TriStateImageType(Group parent, String nodename, String desc,
                                 int transparency)
        {
            super(parent, nodename, desc);
            setHorizontal();
            new DrawableImage(this, Transparency.OPAQUE, true);
            new DrawableImage(this, Transparency.BITMASK,
                              (transparency != Transparency.OPAQUE));
            new DrawableImage(this, Transparency.TRANSLUCENT,
                              (transparency == Transparency.TRANSLUCENT));
        }

        public Image getImage(TestEnvironment env, int w, int h) {
            if (theImage == null ||
                theImage.getWidth(null) != w ||
                theImage.getHeight(null) != h)
            {
                theImage = makeImage(env, w, h);
            }
            return theImage;
        }

        public abstract Image makeImage(TestEnvironment env, int w, int h);
    }

    public static class OffScreen extends TriStateImageType {
        public OffScreen() {
            super(imgsrcroot, "offscr", "Offscreen Image", Transparency.OPAQUE);
        }

        public Image makeImage(TestEnvironment env, int w, int h) {
            Canvas c = env.getCanvas();
            return c.createImage(w, h);
        }
    }

    public static class VolatileImg extends TriStateImageType {
        public VolatileImg() {
            super(imgsrcroot, "volimg", "Volatile Image", Transparency.OPAQUE);
        }

        public Image makeImage(TestEnvironment env, int w, int h) {
            Canvas c = env.getCanvas();
            return c.createVolatileImage(w, h);
        }
    }

    public static class CompatImg extends TriStateImageType {
        int transparency;

        public CompatImg(int transparency) {
            super(imgsrcroot,
                  Destinations.CompatImg.ShortNames[transparency],
                  Destinations.CompatImg.LongDescriptions[transparency],
                  transparency);
            this.transparency = transparency;
        }

        public Image makeImage(TestEnvironment env, int w, int h) {
            Canvas c = env.getCanvas();
            GraphicsConfiguration gc = c.getGraphicsConfiguration();
            return gc.createCompatibleImage(w, h, transparency);
        }
    }

    public static class BufImg extends TriStateImageType {
        int type;
        boolean unmanaged;

        static int Transparencies[] = {
            Transparency.TRANSLUCENT, // "custom",
            Transparency.OPAQUE,      // "IntXrgb",
            Transparency.TRANSLUCENT, // "IntArgb",
            Transparency.TRANSLUCENT, // "IntArgbPre",
            Transparency.OPAQUE,      // "IntXbgr",
            Transparency.OPAQUE,      // "3ByteBgr",
            Transparency.TRANSLUCENT, // "4ByteAbgr",
            Transparency.TRANSLUCENT, // "4ByteAbgrPre",
            Transparency.OPAQUE,      // "Short565",
            Transparency.OPAQUE,      // "Short555",
            Transparency.OPAQUE,      // "ByteGray",
            Transparency.OPAQUE,      // "ShortGray",
            Transparency.OPAQUE,      // "ByteBinary",
            Transparency.OPAQUE,      // "ByteIndexed",
        };

        public BufImg(int type) {
            this(type, false);
        }

        public BufImg(int type, boolean unmanaged) {
            super(bufimgsrcroot,
                  (unmanaged ? "unmanaged" : "") +
                  Destinations.BufImg.ShortNames[type],
                  (unmanaged ? "Unmanaged " : "") +
                  Destinations.BufImg.Descriptions[type],
                  Transparencies[type]);
            this.type = type;
            this.unmanaged = unmanaged;
        }

        public Image makeImage(TestEnvironment env, int w, int h) {
            BufferedImage img = new BufferedImage(w, h, type);
            if (unmanaged) {
                DataBuffer db = img.getRaster().getDataBuffer();
                if (db instanceof DataBufferInt) {
                    ((DataBufferInt)db).getData();
                } else if (db instanceof DataBufferShort) {
                    ((DataBufferShort)db).getData();
                } else if (db instanceof DataBufferByte) {
                    ((DataBufferByte)db).getData();
                } else {
                    try {
                        img.setAccelerationPriority(0.0f);
                    } catch (Throwable e) {}
                }
            }
            return img;
        }
    }

    public static class BmByteIndexBufImg extends TriStateImageType {
        static IndexColorModel icm;

        public BmByteIndexBufImg() {
            super(bufimgsrcroot,
                  "ByteIndexedBm",
                  "8-bit Transparent Indexed Image",
                  Transparency.BITMASK);
        }

        public Image makeImage(TestEnvironment env, int w, int h) {
            if (icm == null) {
                int cmap[] = new int[256];
                // Workaround for transparency rendering bug in earlier VMs
                // Can only render transparency if first cmap entry is 0x0
                // This bug is fixed in 1.4.2 (Mantis)
                int i = 1;
                for (int r = 0; r < 256; r += 51) {
                    for (int g = 0; g < 256; g += 51) {
                        for (int b = 0; b < 256; b += 51) {
                            cmap[i++] = (0xff<<24)|(r<<16)|(g<<8)|b;
                        }
                    }
                }

                // Leave the rest of the colormap transparent

                icm = new IndexColorModel(8, 256, cmap, 0, true, 255,
                                          DataBuffer.TYPE_BYTE);
            }
            return new BufferedImage(w, h, BufferedImage.TYPE_BYTE_INDEXED,
                                     icm);
        }
    }

    public static class DrawableImage extends Option.Enable {
        static Color transparentBlack  = makeAlphaColor(Color.black, 0);
        static Color translucentRed    = makeAlphaColor(Color.red, 192);
        static Color translucentGreen  = makeAlphaColor(Color.green, 128);
        static Color translucentYellow = makeAlphaColor(Color.yellow, 64);

        static Color colorsets[][] = new Color[][] {
            null,
            {
                Color.blue,       Color.red,
                Color.green,      Color.yellow,
                Color.blue,
            },
            {
                transparentBlack, Color.red,
                Color.green,      transparentBlack,
                transparentBlack,
            },
            {
                Color.blue,       translucentRed,
                translucentGreen, translucentYellow,
                translucentRed,
            },
        };

        TriStateImageType tsit;
        int transparency;
        boolean possible;

        public DrawableImage(TriStateImageType parent, int transparency,
                             boolean possible)
        {
            super(parent,
                  transNodeNames[transparency],
                  transDescriptions[transparency],
                  false);
            this.tsit = parent;
            this.transparency = transparency;
            this.possible = possible;
        }

        public int getTransparency() {
            return transparency;
        }

        public JComponent getJComponent() {
            JComponent comp = super.getJComponent();
            comp.setEnabled(possible);
            return comp;
        }

        public String setValueFromString(String value) {
            if (!possible && !value.equalsIgnoreCase("disabled")) {
                return "Bad Value";
            }
            return super.setValueFromString(value);
        }

        public void modifyTest(TestEnvironment env) {
            int size = env.getIntValue(sizeList);
            Image src = tsit.getImage(env, size, size);
            Graphics g = src.getGraphics();
            if (hasGraphics2D) {
                ((Graphics2D) g).setComposite(AlphaComposite.Src);
            }
            if (size == 1) {
                g.setColor(colorsets[transparency][4]);
                g.fillRect(0, 0, 1, 1);
            } else {
                int mid = size/2;
                g.setColor(colorsets[transparency][0]);
                g.fillRect(0, 0, mid, mid);
                g.setColor(colorsets[transparency][1]);
                g.fillRect(mid, 0, size-mid, mid);
                g.setColor(colorsets[transparency][2]);
                g.fillRect(0, mid, mid, size-mid);
                g.setColor(colorsets[transparency][3]);
                g.fillRect(mid, mid, size-mid, size-mid);
            }
            g.dispose();
            env.setSrcImage(src);
        }

        public void restoreTest(TestEnvironment env) {
            env.setSrcImage(null);
        }

        public String getAbbreviatedModifierDescription(Object value) {
            return "from "+getModifierValueName(value);
        }

        public String getModifierValueName(Object val) {
            return getParent().getNodeName()+" "+getNodeName();
        }
    }

    public static class DrawImage extends ImageTests {
        public DrawImage() {
            super(imgtestroot, "drawimage", "drawImage(img, x, y, obs);");
        }

        public void runTest(Object ctx, int numReps) {
            ImageTests.Context ictx = (ImageTests.Context) ctx;
            int x = ictx.initX;
            int y = ictx.initY;
            Graphics g = ictx.graphics;
            g.translate(ictx.orgX, ictx.orgY);
            Image src = ictx.src;
            if (ictx.animate) {
                if (ictx.touchSrc) {
                    Graphics srcG = src.getGraphics();
                    do {
                        srcG.fillRect(0, 0, 1, 1);
                        g.drawImage(src, x, y, null);
                        if ((x -= 3) < 0) x += ictx.maxX;
                        if ((y -= 1) < 0) y += ictx.maxY;
                    } while (--numReps > 0);
                } else {
                    do {
                        g.drawImage(src, x, y, null);
                        if ((x -= 3) < 0) x += ictx.maxX;
                        if ((y -= 1) < 0) y += ictx.maxY;
                    } while (--numReps > 0);
                }
            } else {
                if (ictx.touchSrc) {
                    Graphics srcG = src.getGraphics();
                    do {
                        srcG.fillRect(0, 0, 1, 1);
                        g.drawImage(src, x, y, null);
                    } while (--numReps > 0);
                } else {
                    do {
                        g.drawImage(src, x, y, null);
                    } while (--numReps > 0);
                }
            }
            g.translate(-ictx.orgX, -ictx.orgY);
        }
    }

    public static class DrawImageBg extends ImageTests {
        public DrawImageBg() {
            super(imgtestroot, "drawimagebg", "drawImage(img, x, y, bg, obs);",
                  new Modifier.Filter() {
                      public boolean isCompatible(Object val) {
                          DrawableImage di = (DrawableImage) val;
                          return (di.getTransparency() != Transparency.OPAQUE);
                      }
                  });
        }

        public void runTest(Object ctx, int numReps) {
            ImageTests.Context ictx = (ImageTests.Context) ctx;
            int x = ictx.initX;
            int y = ictx.initY;
            Graphics g = ictx.graphics;
            g.translate(ictx.orgX, ictx.orgY);
            Image src = ictx.src;
            Color bg = Color.orange;
            if (ictx.animate) {
                if (ictx.touchSrc) {
                    Graphics srcG = src.getGraphics();
                    do {
                        srcG.fillRect(0, 0, 1, 1);
                        g.drawImage(src, x, y, bg, null);
                        if ((x -= 3) < 0) x += ictx.maxX;
                        if ((y -= 1) < 0) y += ictx.maxY;
                    } while (--numReps > 0);
                } else {
                    do {
                        g.drawImage(src, x, y, bg, null);
                        if ((x -= 3) < 0) x += ictx.maxX;
                        if ((y -= 1) < 0) y += ictx.maxY;
                    } while (--numReps > 0);
                }
            } else {
                if (ictx.touchSrc) {
                    Graphics srcG = src.getGraphics();
                    do {
                        srcG.fillRect(0, 0, 1, 1);
                        g.drawImage(src, x, y, bg, null);
                    } while (--numReps > 0);
                } else {
                    do {
                        g.drawImage(src, x, y, bg, null);
                    } while (--numReps > 0);
                }
            }
            g.translate(-ictx.orgX, -ictx.orgY);
        }
    }

    public static class DrawImageScale extends ImageTests {
        float scale;

        public DrawImageScale(String dir, float scale) {
            super(imgtestroot, "drawimagescale"+dir,
                               "drawImage(img, x, y, w*"+scale+", h*"+scale+", obs);");
            this.scale = scale;
        }

        public Dimension getOutputSize(int w, int h) {
            int neww = (int) (w * scale);
            int newh = (int) (h * scale);
            if (neww == w && scale > 1f) neww = w+1;
            if (newh == h && scale > 1f) newh = h+1;
            return new Dimension(neww, newh);
        }

        public void runTest(Object ctx, int numReps) {
            ImageTests.Context ictx = (ImageTests.Context) ctx;
            int x = ictx.initX;
            int y = ictx.initY;
            int w = ictx.outdim.width;
            int h = ictx.outdim.height;
            Graphics g = ictx.graphics;
            g.translate(ictx.orgX, ictx.orgY);
            Image src = ictx.src;
            if (ictx.animate) {
                if (ictx.touchSrc) {
                    Graphics srcG = src.getGraphics();
                    do {
                        srcG.fillRect(0, 0, 1, 1);
                        g.drawImage(src, x, y, w, h, null);
                        if ((x -= 3) < 0) x += ictx.maxX;
                        if ((y -= 1) < 0) y += ictx.maxY;
                    } while (--numReps > 0);
                } else {
                    do {
                        g.drawImage(src, x, y, w, h, null);
                        if ((x -= 3) < 0) x += ictx.maxX;
                        if ((y -= 1) < 0) y += ictx.maxY;
                    } while (--numReps > 0);
                }
            } else {
                Graphics srcG = src.getGraphics();
                if (ictx.touchSrc) {
                    do {
                        srcG.fillRect(0, 0, 1, 1);
                        g.drawImage(src, x, y, w, h, null);
                    } while (--numReps > 0);
                } else {
                    do {
                        g.drawImage(src, x, y, w, h, null);
                    } while (--numReps > 0);
                }
            }
            g.translate(-ictx.orgX, -ictx.orgY);
        }
    }

    public static class DrawImageTransform extends ImageTests {
        public DrawImageTransform() {
            super(imgtestroot, "drawimagetxform", "drawImage(img, tx, obs);");
        }

        public Dimension getOutputSize(int w, int h) {
            int neww = (int) Math.ceil(w * 1.1);
            int newh = (int) Math.ceil(h * 1.1);
            return new Dimension(neww, newh);
        }

        public void initContext(TestEnvironment env, GraphicsTests.Context ctx)
        {
            super.initContext(env, ctx);
            ImageTests.Context ictx = (ImageTests.Context) ctx;

            ictx.tx = new AffineTransform();
        }

        public void runTest(Object ctx, int numReps) {
            ImageTests.Context ictx = (ImageTests.Context) ctx;
            int x = ictx.initX;
            int y = ictx.initY;
            Graphics2D g = (Graphics2D) ictx.graphics;
            g.translate(ictx.orgX, ictx.orgY);
            Image src = ictx.src;
            AffineTransform tx = ictx.tx;
            if (ictx.animate) {
                if (ictx.touchSrc) {
                    Graphics srcG = src.getGraphics();
                    do {
                        tx.setTransform(1.0, 0.1, 0.1, 1.0, x, y);
                        srcG.fillRect(0, 0, 1, 1);
                        g.drawImage(src, tx, null);
                        if ((x -= 3) < 0) x += ictx.maxX;
                        if ((y -= 1) < 0) y += ictx.maxY;
                    } while (--numReps > 0);
                } else {
                    do {
                        tx.setTransform(1.0, 0.1, 0.1, 1.0, x, y);
                        g.drawImage(src, tx, null);
                        if ((x -= 3) < 0) x += ictx.maxX;
                        if ((y -= 1) < 0) y += ictx.maxY;
                    } while (--numReps > 0);
                }
            } else {
                tx.setTransform(1.0, 0.1, 0.1, 1.0, x, y);
                if (ictx.touchSrc) {
                    Graphics srcG = src.getGraphics();
                    do {
                        srcG.fillRect(0, 0, 1, 1);
                        g.drawImage(src, tx, null);
                    } while (--numReps > 0);
                } else {
                    do {
                        g.drawImage(src, tx, null);
                    } while (--numReps > 0);
                }
            }
            g.translate(-ictx.orgX, -ictx.orgY);
        }
    }

    private static abstract class ImageOpTests extends ImageTests {
        ImageOpTests(Group parent, String nodeName, String desc) {
            super(parent, nodeName, desc,
                  new Modifier.Filter() {
                      public boolean isCompatible(Object val) {
                          // Filter out all non-BufferedImage sources
                          DrawableImage di = (DrawableImage) val;
                          Group imgtype = di.getParent();
                          return
                              !(imgtype instanceof VolatileImg) &&
                              !(imgtype instanceof OffScreen);
                      }
                  });
            addDependencies(imageOpOptRoot, true);
        }

        private static class Context extends ImageTests.Context {
            BufferedImageOp bufImgOp;
            BufferedImage   bufSrc;
            BufferedImage   bufDst;

            RasterOp        rasterOp;
            Raster          rasSrc;
            WritableRaster  rasDst;
        }

        public GraphicsTests.Context createContext() {
            return new ImageOpTests.Context();
        }

        public void initContext(TestEnvironment env,
                                GraphicsTests.Context ctx)
        {
            super.initContext(env, ctx);
            ImageOpTests.Context ictx = (ImageOpTests.Context)ctx;

            // Note: We filter out all non-BufferedImage sources in the
            // ImageOpTests constructor above, so the following is safe...
            ictx.bufSrc = (BufferedImage)ictx.src;

            String op = (String)env.getModifier(opList);
            if (op.startsWith("convolve")) {
                Kernel kernel;
                if (op.startsWith("convolve3x3")) {
                    // 3x3 blur
                    float[] data = {
                        0.1f, 0.1f, 0.1f,
                        0.1f, 0.2f, 0.1f,
                        0.1f, 0.1f, 0.1f,
                    };
                    kernel = new Kernel(3, 3, data);
                } else { // (op.startsWith("convolve5x5"))
                    // 5x5 edge
                    float[] data = {
                        -1.0f, -1.0f, -1.0f, -1.0f, -1.0f,
                        -1.0f, -1.0f, -1.0f, -1.0f, -1.0f,
                        -1.0f, -1.0f, 24.0f, -1.0f, -1.0f,
                        -1.0f, -1.0f, -1.0f, -1.0f, -1.0f,
                        -1.0f, -1.0f, -1.0f, -1.0f, -1.0f,
                    };
                    kernel = new Kernel(5, 5, data);
                }
                int edge = op.endsWith("zero") ?
                    ConvolveOp.EDGE_ZERO_FILL : ConvolveOp.EDGE_NO_OP;
                ictx.bufImgOp = new ConvolveOp(kernel, edge, null);
            } else if (op.startsWith("lookup")) {
                if (op.endsWith("byte")) {
                    byte invert[] = new byte[256];
                    byte ordered[] = new byte[256];
                    for (int j = 0; j < 256 ; j++) {
                        invert[j] = (byte)(255-j);
                        ordered[j] = (byte)j;
                    }
                    if (op.equals("lookup1byte")) {
                        ictx.bufImgOp =
                            new LookupOp(new ByteLookupTable(0, invert),
                                         null);
                    } else { // (op.equals("lookup3byte"))
                        byte[][] yellowInvert =
                            new byte[][] { invert, invert, ordered };
                        ictx.bufImgOp =
                            new LookupOp(new ByteLookupTable(0, yellowInvert),
                                         null);
                    }
                } else { // (op.endsWith("short"))
                    short invert[] = new short[256];
                    short ordered[] = new short[256];
                    for (int j = 0; j < 256 ; j++) {
                        invert[j] = (short)((255-j) * 255);
                        ordered[j] = (short)(j * 255);
                    }
                    if (op.equals("lookup1short")) {
                        ictx.bufImgOp =
                            new LookupOp(new ShortLookupTable(0, invert),
                                         null);
                    } else { // (op.equals("lookup3short"))
                        short[][] yellowInvert =
                            new short[][] { invert, invert, ordered };
                        ictx.bufImgOp =
                            new LookupOp(new ShortLookupTable(0, yellowInvert),
                                         null);
                    }
                }
            } else if (op.equals("rescale1band")) {
                ictx.bufImgOp = new RescaleOp(0.5f, 10.0f, null);
            } else if (op.equals("rescale3band")) {
                float[] scaleFactors = { 0.5f,  0.3f, 0.8f };
                float[] offsets      = { 5.0f, -7.5f, 1.0f };
                ictx.bufImgOp = new RescaleOp(scaleFactors, offsets, null);
            } else {
                throw new InternalError("Invalid image op");
            }

            ictx.rasterOp = (RasterOp)ictx.bufImgOp;
        }
    }

    private static class DrawImageOp extends ImageOpTests {
        DrawImageOp() {
            super(graphicsTestRoot, "drawimageop",
                  "drawImage(srcBufImg, op, x, y);");
        }

        public void runTest(Object ctx, int numReps) {
            ImageOpTests.Context ictx = (ImageOpTests.Context)ctx;
            int x = ictx.initX;
            int y = ictx.initY;
            BufferedImageOp op = ictx.bufImgOp;
            BufferedImage src = ictx.bufSrc;
            Graphics2D g2 = (Graphics2D)ictx.graphics;
            g2.translate(ictx.orgX, ictx.orgY);
            if (ictx.animate) {
                if (ictx.touchSrc) {
                    Graphics gSrc = src.getGraphics();
                    do {
                        gSrc.fillRect(0, 0, 1, 1);
                        g2.drawImage(src, op, x, y);
                        if ((x -= 3) < 0) x += ictx.maxX;
                        if ((y -= 1) < 0) y += ictx.maxY;
                    } while (--numReps > 0);
                } else {
                    do {
                        g2.drawImage(src, op, x, y);
                        if ((x -= 3) < 0) x += ictx.maxX;
                        if ((y -= 1) < 0) y += ictx.maxY;
                    } while (--numReps > 0);
                }
            } else {
                if (ictx.touchSrc) {
                    Graphics gSrc = src.getGraphics();
                    do {
                        gSrc.fillRect(0, 0, 1, 1);
                        g2.drawImage(src, op, x, y);
                    } while (--numReps > 0);
                } else {
                    do {
                        g2.drawImage(src, op, x, y);
                    } while (--numReps > 0);
                }
            }
            g2.translate(-ictx.orgX, -ictx.orgY);
        }
    }

    private static class BufImgOpFilter extends ImageOpTests {
        private boolean cached;

        BufImgOpFilter(boolean cached) {
            super(bufImgOpTestRoot,
                  "filter" + (cached ? "cached" : "null"),
                  "op.filter(srcBufImg, " +
                  (cached ? "cachedCompatibleDestImg" : "null") + ");");
            this.cached = cached;
        }

        public void initContext(TestEnvironment env,
                                GraphicsTests.Context ctx)
        {
            super.initContext(env, ctx);
            ImageOpTests.Context ictx = (ImageOpTests.Context)ctx;

            if (cached) {
                ictx.bufDst =
                    ictx.bufImgOp.createCompatibleDestImage(ictx.bufSrc, null);
            }
        }

        public void runTest(Object ctx, int numReps) {
            ImageOpTests.Context ictx = (ImageOpTests.Context)ctx;
            BufferedImageOp op = ictx.bufImgOp;
            BufferedImage src = ictx.bufSrc;
            BufferedImage dst = ictx.bufDst;
            if (ictx.touchSrc) {
                Graphics gSrc = src.getGraphics();
                do {
                    gSrc.fillRect(0, 0, 1, 1);
                    op.filter(src, dst);
                } while (--numReps > 0);
            } else {
                do {
                    op.filter(src, dst);
                } while (--numReps > 0);
            }
        }
    }

    private static class RasterOpFilter extends ImageOpTests {
        private boolean cached;

        RasterOpFilter(boolean cached) {
            super(rasterOpTestRoot,
                  "filter" + (cached ? "cached" : "null"),
                  "op.filter(srcRaster, " +
                  (cached ? "cachedCompatibleDestRaster" : "null") + ");");
            this.cached = cached;
        }

        public void initContext(TestEnvironment env,
                                GraphicsTests.Context ctx)
        {
            super.initContext(env, ctx);
            ImageOpTests.Context ictx = (ImageOpTests.Context)ctx;

            ictx.rasSrc = ictx.bufSrc.getRaster();
            if (cached) {
                ictx.bufDst =
                    ictx.bufImgOp.createCompatibleDestImage(ictx.bufSrc, null);
                ictx.rasDst = ictx.bufDst.getRaster();
            }
        }

        public void runTest(Object ctx, int numReps) {
            ImageOpTests.Context ictx = (ImageOpTests.Context)ctx;
            RasterOp op = ictx.rasterOp;
            Raster src = ictx.rasSrc;
            WritableRaster dst = ictx.rasDst;
            if (ictx.touchSrc) {
                Graphics gSrc = ictx.bufSrc.getGraphics();
                do {
                    gSrc.fillRect(0, 0, 1, 1);
                    op.filter(src, dst);
                } while (--numReps > 0);
            } else {
                do {
                    op.filter(src, dst);
                } while (--numReps > 0);
            }
        }
    }
}
