src/share/demo/java2d/J2DBench/src/j2dbench/tests/iio/OutputImageTests.java - toolchain/jdk/jdk9_jdk - Git at Google

 /*
  * 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.Graphics;
 import java.awt.image.BufferedImage;
 import java.io.BufferedOutputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.File;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.OutputStream;
 import java.util.ArrayList;
 import java.util.List;
 import javax.imageio.ImageIO;
 import javax.imageio.ImageWriter;
 import javax.imageio.event.IIOWriteProgressListener;
 import javax.imageio.spi.IIORegistry;
 import javax.imageio.spi.ImageWriterSpi;
 import javax.imageio.stream.ImageOutputStream;

 import j2dbench.Group;
 import j2dbench.Modifier;
 import j2dbench.Option;
 import j2dbench.Result;
 import j2dbench.Test;
 import j2dbench.TestEnvironment;

 abstract class OutputImageTests extends OutputTests {

     private static final int TEST_IMAGEIO     = 1;
     private static final int TEST_IMAGEWRITER = 2;

     private static Group imageRoot;

     private static Group imageioRoot;
     private static Group imageioOptRoot;
     private static ImageWriterSpi[] imageioWriterSpis;
     private static String[] imageioWriteFormatShortNames;
     private static Option imageioWriteFormatList;
     private static Group imageioTestRoot;

     private static Group imageWriterRoot;
     private static Group imageWriterOptRoot;
     private static Option installListenerTog;
     private static Group imageWriterTestRoot;

     public static void init() {
         imageRoot = new Group(outputRoot, "image", "Image Writing Benchmarks");
         imageRoot.setTabbed();

         // 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");
             initIIOWriteFormats();
             imageioWriteFormatList =
                 new Option.ObjectList(imageioOptRoot,
                                       "format", "Image Format",
                                       imageioWriteFormatShortNames,
                                       imageioWriterSpis,
                                       imageioWriteFormatShortNames,
                                       imageioWriteFormatShortNames,
                                       0x0);

             // Image I/O Tests
             imageioTestRoot = new Group(imageioRoot, "tests",
                                         "Image I/O Tests");
             new ImageIOWrite();

             // ImageWriter Options
             imageWriterRoot = new Group(imageioRoot, "writer",
                                         "ImageWriter Benchmarks");
             imageWriterOptRoot = new Group(imageWriterRoot, "opts",
                                            "ImageWriter Options");
             installListenerTog =
                 new Option.Toggle(imageWriterOptRoot,
                                   "installListener",
                                   "Install Progress Listener",
                                   Option.Toggle.Off);

             // ImageWriter Tests
             imageWriterTestRoot = new Group(imageWriterRoot, "tests",
                                             "ImageWriter Tests");
             new ImageWriterWrite();
         }
     }

     private static void initIIOWriteFormats() {
         List spis = new ArrayList();
         List shortNames = new ArrayList();

         ImageIO.scanForPlugins();
         IIORegistry registry = IIORegistry.getDefaultInstance();
         java.util.Iterator writerspis =
             registry.getServiceProviders(ImageWriterSpi.class, false);
         while (writerspis.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
             ImageWriterSpi spi = (ImageWriterSpi)writerspis.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);
         }

         imageioWriterSpis = new ImageWriterSpi[spis.size()];
         imageioWriterSpis = (ImageWriterSpi[])spis.toArray(imageioWriterSpis);
         imageioWriteFormatShortNames = new String[shortNames.size()];
         imageioWriteFormatShortNames =
             (String[])shortNames.toArray(imageioWriteFormatShortNames);
     }

     protected OutputImageTests(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 OutputTests.Context {
         String format;
         BufferedImage image;
         ImageWriter writer;

         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_IMAGEWRITER) {
                 ImageWriterSpi writerspi =
                     (ImageWriterSpi)env.getModifier(imageioWriteFormatList);
                 format = writerspi.getFileSuffixes()[0].toLowerCase();
                 if (testType == TEST_IMAGEWRITER) {
                     try {
                         writer = writerspi.createWriterInstance();
                     } catch (IOException e) {
                         System.err.println("error creating writer");
                         e.printStackTrace();
                     }
                     if (env.isEnabled(installListenerTog)) {
                         writer.addIIOWriteProgressListener(
                             new WriteProgressListener());
                     }
                 }
                 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 { // testType == TEST_JPEGCODEC
                 format = "jpeg";
             }

             initOutput();
         }

         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 (writer != null) {
                 writer.dispose();
                 writer = null;
             }
         }
     }

     private static class ImageIOWrite extends OutputImageTests {
         public ImageIOWrite() {
             super(imageioTestRoot,
                   "imageioWrite",
                   "ImageIO.write()");
             addDependency(generalDestRoot,
                 new Modifier.Filter() {
                     public boolean isCompatible(Object val) {
                         // ImageIO.write() handles FILE and ARRAY, but
                         // not FILECHANNEL (well, I suppose we could create
                         // an ImageOutputStream from a FileChannel source,
                         // but that's not a common use case; FileChannel is
                         // better handled by the ImageWriter tests below)
                         OutputType t = (OutputType)val;
                         return (t.getType() != OUTPUT_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 output = ictx.output;
             final BufferedImage image = ictx.image;
             final String format = ictx.format;
             final int outputType = ictx.outputType;
             switch (outputType) {
             case OUTPUT_FILE:
                 do {
                     try {
                         ImageIO.write(image, format, (File)output);
                     } catch (Exception e) {
                         e.printStackTrace();
                     }
                 } while (--numReps >= 0);
                 break;
             case OUTPUT_ARRAY:
                 do {
                     try {
                         ByteArrayOutputStream baos =
                             new ByteArrayOutputStream();
                         BufferedOutputStream bos =
                             new BufferedOutputStream(baos);
                         ImageIO.write(image, format, bos);
                         baos.close();
                     } catch (Exception e) {
                         e.printStackTrace();
                     }
                 } while (--numReps >= 0);
                 break;
             default:
                 throw new IllegalArgumentException("Invalid output type");
             }
         }
     }

     private static class ImageWriterWrite extends OutputImageTests {
         public ImageWriterWrite() {
             super(imageWriterTestRoot,
                   "write",
                   "ImageWriter.write()");
             addDependency(generalDestRoot);
             addDependencies(imageioGeneralOptRoot, true);
             addDependencies(imageioOptRoot, true);
             addDependencies(imageWriterOptRoot, true);
         }

         public Object initTest(TestEnvironment env, Result result) {
             return new Context(env, result, TEST_IMAGEWRITER);
         }

         public void runTest(Object ctx, int numReps) {
             final Context ictx = (Context)ctx;
             final ImageWriter writer = ictx.writer;
             final BufferedImage image = ictx.image;
             do {
                 try {
                     ImageOutputStream ios = ictx.createImageOutputStream();
                     writer.setOutput(ios);
                     writer.write(image);
                     writer.reset();
                     ios.close();
                     ictx.closeOriginalStream();
                 } catch (IOException e) {
                     e.printStackTrace();
                 }
             } while (--numReps >= 0);
         }
     }

     private static class WriteProgressListener
         implements IIOWriteProgressListener
     {
         public void imageStarted(ImageWriter source, int imageIndex) {}
         public void imageProgress(ImageWriter source,
                                   float percentageDone) {}
         public void imageComplete(ImageWriter source) {}
         public void thumbnailStarted(ImageWriter source,
                                      int imageIndex, int thumbnailIndex) {}
         public void thumbnailProgress(ImageWriter source,
                                       float percentageDone) {}
         public void thumbnailComplete(ImageWriter source) {}
         public void writeAborted(ImageWriter source) {}
     }
 }
	/*
	* 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.Graphics;
	import java.awt.image.BufferedImage;
	import java.io.BufferedOutputStream;
	import java.io.ByteArrayOutputStream;
	import java.io.File;
	import java.io.FileOutputStream;
	import java.io.IOException;
	import java.io.OutputStream;
	import java.util.ArrayList;
	import java.util.List;
	import javax.imageio.ImageIO;
	import javax.imageio.ImageWriter;
	import javax.imageio.event.IIOWriteProgressListener;
	import javax.imageio.spi.IIORegistry;
	import javax.imageio.spi.ImageWriterSpi;
	import javax.imageio.stream.ImageOutputStream;

	import j2dbench.Group;
	import j2dbench.Modifier;
	import j2dbench.Option;
	import j2dbench.Result;
	import j2dbench.Test;
	import j2dbench.TestEnvironment;

	abstract class OutputImageTests extends OutputTests {

	private static final int TEST_IMAGEIO = 1;
	private static final int TEST_IMAGEWRITER = 2;

	private static Group imageRoot;

	private static Group imageioRoot;
	private static Group imageioOptRoot;
	private static ImageWriterSpi[] imageioWriterSpis;
	private static String[] imageioWriteFormatShortNames;
	private static Option imageioWriteFormatList;
	private static Group imageioTestRoot;

	private static Group imageWriterRoot;
	private static Group imageWriterOptRoot;
	private static Option installListenerTog;
	private static Group imageWriterTestRoot;

	public static void init() {
	imageRoot = new Group(outputRoot, "image", "Image Writing Benchmarks");
	imageRoot.setTabbed();

	// 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");
	initIIOWriteFormats();
	imageioWriteFormatList =
	new Option.ObjectList(imageioOptRoot,
	"format", "Image Format",
	imageioWriteFormatShortNames,
	imageioWriterSpis,
	imageioWriteFormatShortNames,
	imageioWriteFormatShortNames,
	0x0);

	// Image I/O Tests
	imageioTestRoot = new Group(imageioRoot, "tests",
	"Image I/O Tests");
	new ImageIOWrite();

	// ImageWriter Options
	imageWriterRoot = new Group(imageioRoot, "writer",
	"ImageWriter Benchmarks");
	imageWriterOptRoot = new Group(imageWriterRoot, "opts",
	"ImageWriter Options");
	installListenerTog =
	new Option.Toggle(imageWriterOptRoot,
	"installListener",
	"Install Progress Listener",
	Option.Toggle.Off);

	// ImageWriter Tests
	imageWriterTestRoot = new Group(imageWriterRoot, "tests",
	"ImageWriter Tests");
	new ImageWriterWrite();
	}
	}

	private static void initIIOWriteFormats() {
	List spis = new ArrayList();
	List shortNames = new ArrayList();

	ImageIO.scanForPlugins();
	IIORegistry registry = IIORegistry.getDefaultInstance();
	java.util.Iterator writerspis =
	registry.getServiceProviders(ImageWriterSpi.class, false);
	while (writerspis.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
	ImageWriterSpi spi = (ImageWriterSpi)writerspis.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);
	}

	imageioWriterSpis = new ImageWriterSpi[spis.size()];
	imageioWriterSpis = (ImageWriterSpi[])spis.toArray(imageioWriterSpis);
	imageioWriteFormatShortNames = new String[shortNames.size()];
	imageioWriteFormatShortNames =
	(String[])shortNames.toArray(imageioWriteFormatShortNames);
	}

	protected OutputImageTests(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 OutputTests.Context {
	String format;
	BufferedImage image;
	ImageWriter writer;

	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_IMAGEWRITER) {
	ImageWriterSpi writerspi =
	(ImageWriterSpi)env.getModifier(imageioWriteFormatList);
	format = writerspi.getFileSuffixes()[0].toLowerCase();
	if (testType == TEST_IMAGEWRITER) {
	try {
	writer = writerspi.createWriterInstance();
	} catch (IOException e) {
	System.err.println("error creating writer");
	e.printStackTrace();
	}
	if (env.isEnabled(installListenerTog)) {
	writer.addIIOWriteProgressListener(
	new WriteProgressListener());
	}
	}
	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 { // testType == TEST_JPEGCODEC
	format = "jpeg";
	}

	initOutput();
	}

	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 (writer != null) {
	writer.dispose();
	writer = null;
	}
	}
	}

	private static class ImageIOWrite extends OutputImageTests {
	public ImageIOWrite() {
	super(imageioTestRoot,
	"imageioWrite",
	"ImageIO.write()");
	addDependency(generalDestRoot,
	new Modifier.Filter() {
	public boolean isCompatible(Object val) {
	// ImageIO.write() handles FILE and ARRAY, but
	// not FILECHANNEL (well, I suppose we could create
	// an ImageOutputStream from a FileChannel source,
	// but that's not a common use case; FileChannel is
	// better handled by the ImageWriter tests below)
	OutputType t = (OutputType)val;
	return (t.getType() != OUTPUT_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 output = ictx.output;
	final BufferedImage image = ictx.image;
	final String format = ictx.format;
	final int outputType = ictx.outputType;
	switch (outputType) {
	case OUTPUT_FILE:
	do {
	try {
	ImageIO.write(image, format, (File)output);
	} catch (Exception e) {
	e.printStackTrace();
	}
	} while (--numReps >= 0);
	break;
	case OUTPUT_ARRAY:
	do {
	try {
	ByteArrayOutputStream baos =
	new ByteArrayOutputStream();
	BufferedOutputStream bos =
	new BufferedOutputStream(baos);
	ImageIO.write(image, format, bos);
	baos.close();
	} catch (Exception e) {
	e.printStackTrace();
	}
	} while (--numReps >= 0);
	break;
	default:
	throw new IllegalArgumentException("Invalid output type");
	}
	}
	}

	private static class ImageWriterWrite extends OutputImageTests {
	public ImageWriterWrite() {
	super(imageWriterTestRoot,
	"write",
	"ImageWriter.write()");
	addDependency(generalDestRoot);
	addDependencies(imageioGeneralOptRoot, true);
	addDependencies(imageioOptRoot, true);
	addDependencies(imageWriterOptRoot, true);
	}

	public Object initTest(TestEnvironment env, Result result) {
	return new Context(env, result, TEST_IMAGEWRITER);
	}

	public void runTest(Object ctx, int numReps) {
	final Context ictx = (Context)ctx;
	final ImageWriter writer = ictx.writer;
	final BufferedImage image = ictx.image;
	do {
	try {
	ImageOutputStream ios = ictx.createImageOutputStream();
	writer.setOutput(ios);
	writer.write(image);
	writer.reset();
	ios.close();
	ictx.closeOriginalStream();
	} catch (IOException e) {
	e.printStackTrace();
	}
	} while (--numReps >= 0);
	}
	}

	private static class WriteProgressListener
	implements IIOWriteProgressListener
	{
	public void imageStarted(ImageWriter source, int imageIndex) {}
	public void imageProgress(ImageWriter source,
	float percentageDone) {}
	public void imageComplete(ImageWriter source) {}
	public void thumbnailStarted(ImageWriter source,
	int imageIndex, int thumbnailIndex) {}
	public void thumbnailProgress(ImageWriter source,
	float percentageDone) {}
	public void thumbnailComplete(ImageWriter source) {}
	public void writeAborted(ImageWriter source) {}
	}
	}