| /* |
| * Copyright (c) 2006, 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.iio; |
| |
| import java.awt.Component; |
| import java.awt.Graphics; |
| import java.awt.Image; |
| import java.awt.MediaTracker; |
| import java.awt.Toolkit; |
| import java.awt.image.BufferedImage; |
| import java.io.BufferedInputStream; |
| import java.io.ByteArrayInputStream; |
| import java.io.ByteArrayOutputStream; |
| import java.io.File; |
| import java.io.FileInputStream; |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.io.OutputStream; |
| import java.net.URL; |
| import java.util.ArrayList; |
| import java.util.List; |
| import javax.imageio.ImageIO; |
| import javax.imageio.ImageReader; |
| import javax.imageio.event.IIOReadProgressListener; |
| import javax.imageio.spi.IIORegistry; |
| import javax.imageio.spi.ImageReaderSpi; |
| import javax.imageio.stream.ImageInputStream; |
| |
| import j2dbench.Group; |
| import j2dbench.Modifier; |
| import j2dbench.Option; |
| import j2dbench.Result; |
| import j2dbench.Test; |
| import j2dbench.TestEnvironment; |
| |
| abstract class InputImageTests extends InputTests { |
| |
| private static final int TEST_TOOLKIT = 1; |
| private static final int TEST_IMAGEIO = 2; |
| private static final int TEST_IMAGEREADER = 3; |
| |
| private static Group imageRoot; |
| |
| private static Group toolkitRoot; |
| private static Group toolkitOptRoot; |
| private static Option toolkitReadFormatList; |
| private static Group toolkitTestRoot; |
| |
| private static Group imageioRoot; |
| private static Group imageioOptRoot; |
| private static ImageReaderSpi[] imageioReaderSpis; |
| private static String[] imageioReadFormatShortNames; |
| private static Option imageioReadFormatList; |
| private static Group imageioTestRoot; |
| |
| private static Group imageReaderRoot; |
| private static Group imageReaderOptRoot; |
| private static Option seekForwardOnlyTog; |
| private static Option ignoreMetadataTog; |
| private static Option installListenerTog; |
| private static Group imageReaderTestRoot; |
| |
| public static void init() { |
| imageRoot = new Group(inputRoot, "image", "Image Reading Benchmarks"); |
| imageRoot.setTabbed(); |
| |
| // Toolkit Benchmarks |
| toolkitRoot = new Group(imageRoot, "toolkit", "Toolkit"); |
| |
| toolkitOptRoot = new Group(toolkitRoot, "opts", "Toolkit Options"); |
| String[] tkFormats = new String[] {"gif", "jpg", "png"}; |
| toolkitReadFormatList = |
| new Option.ObjectList(toolkitOptRoot, |
| "format", "Image Format", |
| tkFormats, tkFormats, |
| tkFormats, tkFormats, |
| 0x0); |
| |
| toolkitTestRoot = new Group(toolkitRoot, "tests", "Toolkit Tests"); |
| new ToolkitCreateImage(); |
| |
| // Image I/O Benchmarks |
| if (hasImageIO) { |
| imageioRoot = new Group(imageRoot, "imageio", "Image I/O"); |
| |
| // Image I/O Options |
| imageioOptRoot = new Group(imageioRoot, "opts", |
| "Image I/O Options"); |
| initIIOReadFormats(); |
| imageioReadFormatList = |
| new Option.ObjectList(imageioOptRoot, |
| "format", "Image Format", |
| imageioReadFormatShortNames, |
| imageioReaderSpis, |
| imageioReadFormatShortNames, |
| imageioReadFormatShortNames, |
| 0x0); |
| |
| // Image I/O Tests |
| imageioTestRoot = new Group(imageioRoot, "tests", |
| "Image I/O Tests"); |
| new ImageIORead(); |
| |
| // ImageReader Options |
| imageReaderRoot = new Group(imageioRoot, "reader", |
| "ImageReader Benchmarks"); |
| imageReaderOptRoot = new Group(imageReaderRoot, "opts", |
| "ImageReader Options"); |
| seekForwardOnlyTog = |
| new Option.Toggle(imageReaderOptRoot, |
| "seekForwardOnly", |
| "Seek Forward Only", |
| Option.Toggle.On); |
| ignoreMetadataTog = |
| new Option.Toggle(imageReaderOptRoot, |
| "ignoreMetadata", |
| "Ignore Metadata", |
| Option.Toggle.On); |
| installListenerTog = |
| new Option.Toggle(imageReaderOptRoot, |
| "installListener", |
| "Install Progress Listener", |
| Option.Toggle.Off); |
| |
| // ImageReader Tests |
| imageReaderTestRoot = new Group(imageReaderRoot, "tests", |
| "ImageReader Tests"); |
| new ImageReaderRead(); |
| new ImageReaderGetImageMetadata(); |
| } |
| } |
| |
| private static void initIIOReadFormats() { |
| List spis = new ArrayList(); |
| List shortNames = new ArrayList(); |
| |
| ImageIO.scanForPlugins(); |
| IIORegistry registry = IIORegistry.getDefaultInstance(); |
| java.util.Iterator readerspis = |
| registry.getServiceProviders(ImageReaderSpi.class, false); |
| while (readerspis.hasNext()) { |
| // REMIND: there could be more than one non-core plugin for |
| // a particular format, as is the case for JPEG2000 in the JAI |
| // IIO Tools package, so we should support that somehow |
| ImageReaderSpi spi = (ImageReaderSpi)readerspis.next(); |
| String klass = spi.getClass().getName(); |
| String format = spi.getFormatNames()[0].toLowerCase(); |
| String suffix = spi.getFileSuffixes()[0].toLowerCase(); |
| if (suffix == null || suffix.equals("")) { |
| suffix = format; |
| } |
| String shortName; |
| if (klass.startsWith("com.sun.imageio.plugins")) { |
| shortName = "core-" + suffix; |
| } else { |
| shortName = "ext-" + suffix; |
| } |
| spis.add(spi); |
| shortNames.add(shortName); |
| } |
| |
| imageioReaderSpis = new ImageReaderSpi[spis.size()]; |
| imageioReaderSpis = (ImageReaderSpi[])spis.toArray(imageioReaderSpis); |
| imageioReadFormatShortNames = new String[shortNames.size()]; |
| imageioReadFormatShortNames = |
| (String[])shortNames.toArray(imageioReadFormatShortNames); |
| } |
| |
| protected InputImageTests(Group parent, |
| String nodeName, String description) |
| { |
| super(parent, nodeName, description); |
| } |
| |
| public void cleanupTest(TestEnvironment env, Object ctx) { |
| Context iioctx = (Context)ctx; |
| iioctx.cleanup(env); |
| } |
| |
| private static class Context extends InputTests.Context { |
| String format; |
| BufferedImage image; |
| ImageReader reader; |
| boolean seekForwardOnly; |
| boolean ignoreMetadata; |
| |
| Context(TestEnvironment env, Result result, int testType) { |
| super(env, result); |
| |
| String content = (String)env.getModifier(contentList); |
| if (content == null) { |
| content = CONTENT_BLANK; |
| } |
| // REMIND: add option for non-opaque images |
| image = createBufferedImage(size, size, content, false); |
| |
| result.setUnits(size*size); |
| result.setUnitName("pixel"); |
| |
| if (testType == TEST_IMAGEIO || testType == TEST_IMAGEREADER) { |
| ImageReaderSpi readerspi = |
| (ImageReaderSpi)env.getModifier(imageioReadFormatList); |
| format = readerspi.getFileSuffixes()[0].toLowerCase(); |
| if (testType == TEST_IMAGEREADER) { |
| seekForwardOnly = env.isEnabled(seekForwardOnlyTog); |
| ignoreMetadata = env.isEnabled(ignoreMetadataTog); |
| try { |
| reader = readerspi.createReaderInstance(); |
| } catch (IOException e) { |
| System.err.println("error creating reader"); |
| e.printStackTrace(); |
| } |
| if (env.isEnabled(installListenerTog)) { |
| reader.addIIOReadProgressListener( |
| new ReadProgressListener()); |
| } |
| } |
| if (format.equals("wbmp")) { |
| // REMIND: this is a hack to create an image that the |
| // WBMPImageWriter can handle (a better approach |
| // would involve checking the ImageTypeSpecifier |
| // of the writer's default image param) |
| BufferedImage newimg = |
| new BufferedImage(size, size, |
| BufferedImage.TYPE_BYTE_BINARY); |
| Graphics g = newimg.createGraphics(); |
| g.drawImage(image, 0, 0, null); |
| g.dispose(); |
| image = newimg; |
| } |
| } else if (testType == TEST_TOOLKIT) { |
| format = (String)env.getModifier(toolkitReadFormatList); |
| } else { // testType == TEST_JPEGCODEC |
| format = "jpeg"; |
| } |
| |
| initInput(); |
| } |
| |
| void initContents(File f) throws IOException { |
| ImageIO.write(image, format, f); |
| } |
| |
| void initContents(OutputStream out) throws IOException { |
| ImageIO.write(image, format, out); |
| } |
| |
| void cleanup(TestEnvironment env) { |
| super.cleanup(env); |
| if (reader != null) { |
| reader.dispose(); |
| reader = null; |
| } |
| } |
| } |
| |
| private static class ToolkitCreateImage extends InputImageTests { |
| private static final Component canvas = new Component() {}; |
| |
| public ToolkitCreateImage() { |
| super(toolkitTestRoot, |
| "createImage", |
| "Toolkit.createImage()"); |
| addDependency(generalSourceRoot, |
| new Modifier.Filter() { |
| public boolean isCompatible(Object val) { |
| // Toolkit handles FILE, URL, and ARRAY, but |
| // not FILECHANNEL |
| InputType t = (InputType)val; |
| return (t.getType() != INPUT_FILECHANNEL); |
| } |
| }); |
| addDependencies(toolkitOptRoot, true); |
| } |
| |
| public Object initTest(TestEnvironment env, Result result) { |
| return new Context(env, result, TEST_TOOLKIT); |
| } |
| |
| public void runTest(Object ctx, int numReps) { |
| final Context ictx = (Context)ctx; |
| final Object input = ictx.input; |
| final int inputType = ictx.inputType; |
| final Toolkit tk = Toolkit.getDefaultToolkit(); |
| final MediaTracker mt = new MediaTracker(canvas); |
| switch (inputType) { |
| case INPUT_FILE: |
| String filename = ((File)input).getAbsolutePath(); |
| do { |
| try { |
| Image img = tk.createImage(filename); |
| mt.addImage(img, 0); |
| mt.waitForID(0, 0); |
| mt.removeImage(img, 0); |
| } catch (Exception e) { |
| e.printStackTrace(); |
| } |
| } while (--numReps >= 0); |
| break; |
| case INPUT_URL: |
| do { |
| try { |
| Image img = tk.createImage((URL)input); |
| mt.addImage(img, 0); |
| mt.waitForID(0, 0); |
| mt.removeImage(img, 0); |
| } catch (Exception e) { |
| e.printStackTrace(); |
| } |
| } while (--numReps >= 0); |
| break; |
| case INPUT_ARRAY: |
| do { |
| try { |
| Image img = tk.createImage((byte[])input); |
| mt.addImage(img, 0); |
| mt.waitForID(0, 0); |
| mt.removeImage(img, 0); |
| } catch (Exception e) { |
| e.printStackTrace(); |
| } |
| } while (--numReps >= 0); |
| break; |
| default: |
| throw new IllegalArgumentException("Invalid input type"); |
| } |
| } |
| } |
| |
| private static class ImageIORead extends InputImageTests { |
| public ImageIORead() { |
| super(imageioTestRoot, |
| "imageioRead", |
| "ImageIO.read()"); |
| addDependency(generalSourceRoot, |
| new Modifier.Filter() { |
| public boolean isCompatible(Object val) { |
| // ImageIO.read() handles FILE, URL, and ARRAY, but |
| // not FILECHANNEL (well, I suppose we could create |
| // an ImageInputStream from a FileChannel source, |
| // but that's not a common use case; FileChannel is |
| // better handled by the ImageReader tests below) |
| InputType t = (InputType)val; |
| return (t.getType() != INPUT_FILECHANNEL); |
| } |
| }); |
| addDependencies(imageioOptRoot, true); |
| } |
| |
| public Object initTest(TestEnvironment env, Result result) { |
| return new Context(env, result, TEST_IMAGEIO); |
| } |
| |
| public void runTest(Object ctx, int numReps) { |
| final Context ictx = (Context)ctx; |
| final Object input = ictx.input; |
| final int inputType = ictx.inputType; |
| switch (inputType) { |
| case INPUT_FILE: |
| do { |
| try { |
| ImageIO.read((File)input); |
| } catch (Exception e) { |
| e.printStackTrace(); |
| } |
| } while (--numReps >= 0); |
| break; |
| case INPUT_URL: |
| do { |
| try { |
| ImageIO.read((URL)input); |
| } catch (Exception e) { |
| e.printStackTrace(); |
| } |
| } while (--numReps >= 0); |
| break; |
| case INPUT_ARRAY: |
| do { |
| try { |
| ByteArrayInputStream bais = |
| new ByteArrayInputStream((byte[])input); |
| BufferedInputStream bis = |
| new BufferedInputStream(bais); |
| ImageIO.read(bis); |
| bais.close(); |
| } catch (Exception e) { |
| e.printStackTrace(); |
| } |
| } while (--numReps >= 0); |
| break; |
| default: |
| throw new IllegalArgumentException("Invalid input type"); |
| } |
| } |
| } |
| |
| private static class ImageReaderRead extends InputImageTests { |
| public ImageReaderRead() { |
| super(imageReaderTestRoot, |
| "read", |
| "ImageReader.read()"); |
| addDependency(generalSourceRoot); |
| addDependencies(imageioGeneralOptRoot, true); |
| addDependencies(imageioOptRoot, true); |
| addDependencies(imageReaderOptRoot, true); |
| } |
| |
| public Object initTest(TestEnvironment env, Result result) { |
| return new Context(env, result, TEST_IMAGEREADER); |
| } |
| |
| public void runTest(Object ctx, int numReps) { |
| final Context ictx = (Context)ctx; |
| final ImageReader reader = ictx.reader; |
| final boolean seekForwardOnly = ictx.seekForwardOnly; |
| final boolean ignoreMetadata = ictx.ignoreMetadata; |
| do { |
| try { |
| ImageInputStream iis = ictx.createImageInputStream(); |
| reader.setInput(iis, seekForwardOnly, ignoreMetadata); |
| reader.read(0); |
| reader.reset(); |
| iis.close(); |
| ictx.closeOriginalStream(); |
| } catch (IOException e) { |
| e.printStackTrace(); |
| } |
| } while (--numReps >= 0); |
| } |
| } |
| |
| private static class ImageReaderGetImageMetadata extends InputImageTests { |
| public ImageReaderGetImageMetadata() { |
| super(imageReaderTestRoot, |
| "getImageMetadata", |
| "ImageReader.getImageMetadata()"); |
| addDependency(generalSourceRoot); |
| addDependencies(imageioGeneralOptRoot, true); |
| addDependencies(imageioOptRoot, true); |
| addDependencies(imageReaderOptRoot, true); |
| } |
| |
| public Object initTest(TestEnvironment env, Result result) { |
| Context ctx = new Context(env, result, TEST_IMAGEREADER); |
| // override units since this test doesn't read "pixels" |
| result.setUnits(1); |
| result.setUnitName("image"); |
| return ctx; |
| } |
| |
| public void runTest(Object ctx, int numReps) { |
| final Context ictx = (Context)ctx; |
| final ImageReader reader = ictx.reader; |
| final boolean seekForwardOnly = ictx.seekForwardOnly; |
| final boolean ignoreMetadata = ictx.ignoreMetadata; |
| do { |
| try { |
| ImageInputStream iis = ictx.createImageInputStream(); |
| reader.setInput(iis, seekForwardOnly, ignoreMetadata); |
| reader.getImageMetadata(0); |
| reader.reset(); |
| iis.close(); |
| ictx.closeOriginalStream(); |
| } catch (IOException e) { |
| e.printStackTrace(); |
| } |
| } while (--numReps >= 0); |
| } |
| } |
| |
| private static class ReadProgressListener |
| implements IIOReadProgressListener |
| { |
| public void sequenceStarted(ImageReader source, int minIndex) {} |
| public void sequenceComplete(ImageReader source) {} |
| public void imageStarted(ImageReader source, int imageIndex) {} |
| public void imageProgress(ImageReader source, float percentageDone) {} |
| public void imageComplete(ImageReader source) {} |
| public void thumbnailStarted(ImageReader source, |
| int imageIndex, int thumbnailIndex) {} |
| public void thumbnailProgress(ImageReader source, |
| float percentageDone) {} |
| public void thumbnailComplete(ImageReader source) {} |
| public void readAborted(ImageReader source) {} |
| } |
| } |
