/*
* 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.
*/
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.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 imageOpRoot;
static Group imageOpOptRoot;
static Group imageOpTestRoot;
static Group graphicsTestRoot;
static Group bufImgOpTestRoot;
static Group rasterOpTestRoot;
static Option opList;
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);
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 BmByteIndexBufImg();
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 {
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);
}
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();
}
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 static String Descriptions[] = {
"Default Compatible Image",
"Opaque Compatible Image",
"Bitmask Compatible Image",
"Translucent Compatible Image",
};
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;
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) {
super(bufimgsrcroot,
Destinations.BufImg.ShortNames[type],
Destinations.BufImg.Descriptions[type],
Transparencies[type]);
this.type = type;
}
public Image makeImage(TestEnvironment env, int w, int h) {
return new BufferedImage(w, h, type);
}
}
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) {
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 {
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) {
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 {
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) {
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 {
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) {
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);
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) {
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 {
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;
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;
do {
op.filter(src, dst);
} while (--numReps > 0);
}
}
}