1 /*
   2  * Copyright (c) 2006, 2011, Oracle and/or its affiliates. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  *
   8  *   - Redistributions of source code must retain the above copyright
   9  *     notice, this list of conditions and the following disclaimer.
  10  *
  11  *   - Redistributions in binary form must reproduce the above copyright
  12  *     notice, this list of conditions and the following disclaimer in the
  13  *     documentation and/or other materials provided with the distribution.
  14  *
  15  *   - Neither the name of Oracle nor the names of its
  16  *     contributors may be used to endorse or promote products derived
  17  *     from this software without specific prior written permission.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
  20  * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
  21  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  22  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
  23  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  24  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  25  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  26  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  27  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  28  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  29  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  30  */
  31 
  32 /*
  33  * This source code is provided to illustrate the usage of a given feature
  34  * or technique and has been deliberately simplified. Additional steps
  35  * required for a production-quality application, such as security checks,
  36  * input validation and proper error handling, might not be present in
  37  * this sample code.
  38  */
  39 
  40 
  41 package j2dbench.tests.iio;
  42 
  43 import java.io.BufferedInputStream;
  44 import java.io.ByteArrayInputStream;
  45 import java.io.ByteArrayOutputStream;
  46 import java.io.File;
  47 import java.io.FileInputStream;
  48 import java.io.IOException;
  49 import java.io.InputStream;
  50 import java.io.OutputStream;
  51 import java.net.URL;
  52 import javax.imageio.ImageIO;
  53 import javax.imageio.spi.IIORegistry;
  54 import javax.imageio.spi.ImageInputStreamSpi;
  55 import javax.imageio.stream.FileCacheImageInputStream;
  56 import javax.imageio.stream.FileImageInputStream;
  57 import javax.imageio.stream.ImageInputStream;
  58 import javax.imageio.stream.MemoryCacheImageInputStream;
  59 
  60 import j2dbench.Group;
  61 import j2dbench.Option;
  62 import j2dbench.Result;
  63 import j2dbench.TestEnvironment;
  64 
  65 abstract class InputTests extends IIOTests {
  66 
  67     protected static final int INPUT_FILE        = 1;
  68     protected static final int INPUT_URL         = 2;
  69     protected static final int INPUT_ARRAY       = 3;
  70     protected static final int INPUT_FILECHANNEL = 4;
  71 
  72     protected static ImageInputStreamSpi fileChannelIISSpi;
  73     static {
  74         if (hasImageIO) {
  75             ImageIO.scanForPlugins();
  76             IIORegistry registry = IIORegistry.getDefaultInstance();
  77             java.util.Iterator spis =
  78                 registry.getServiceProviders(ImageInputStreamSpi.class, false);
  79             while (spis.hasNext()) {
  80                 ImageInputStreamSpi spi = (ImageInputStreamSpi)spis.next();
  81                 String klass = spi.getClass().getName();
  82                 if (klass.endsWith("ChannelImageInputStreamSpi")) {
  83                     fileChannelIISSpi = spi;
  84                     break;
  85                 }
  86             }
  87         }
  88     }
  89 
  90     protected static Group inputRoot;
  91     protected static Group inputOptRoot;
  92 
  93     protected static Group generalOptRoot;
  94     protected static Group.EnableSet generalSourceRoot;
  95     protected static Option sourceFileOpt;
  96     protected static Option sourceUrlOpt;
  97     protected static Option sourceByteArrayOpt;
  98 
  99     protected static Group imageioGeneralOptRoot;
 100     protected static Option sourceFileChannelOpt;
 101     protected static Option useCacheTog;
 102 
 103     public static void init() {
 104         inputRoot = new Group(iioRoot, "input", "Input Benchmarks");
 105         inputRoot.setTabbed();
 106 
 107         // Options
 108         inputOptRoot = new Group(inputRoot, "opts", "Options");
 109 
 110         // General Options
 111         generalOptRoot = new Group(inputOptRoot,
 112                                    "general", "General Options");
 113         generalSourceRoot = new Group.EnableSet(generalOptRoot,
 114                                                 "source", "Sources");
 115         sourceFileOpt = new InputType("file", "File", INPUT_FILE);
 116         sourceUrlOpt = new InputType("url", "URL", INPUT_URL);
 117         sourceByteArrayOpt = new InputType("byteArray", "byte[]", INPUT_ARRAY);
 118 
 119         if (hasImageIO) {
 120             // Image I/O Options
 121             imageioGeneralOptRoot = new Group(inputOptRoot,
 122                                               "imageio", "Image I/O Options");
 123             if (fileChannelIISSpi != null) {
 124                 sourceFileChannelOpt =
 125                     new InputType("fileChannel", "FileChannel",
 126                                   INPUT_FILECHANNEL);
 127             }
 128             useCacheTog = new Option.Toggle(imageioGeneralOptRoot, "useCache",
 129                                             "ImageIO.setUseCache()",
 130                                             Option.Toggle.Off);
 131         }
 132 
 133         InputImageTests.init();
 134         if (hasImageIO) {
 135             InputStreamTests.init();
 136         }
 137     }
 138 
 139     protected InputTests(Group parent, String nodeName, String description) {
 140         super(parent, nodeName, description);
 141     }
 142 
 143     protected static class InputType extends Option.Enable {
 144         private int type;
 145 
 146         public InputType(String nodeName, String description, int type) {
 147             super(generalSourceRoot, nodeName, description, false);
 148             this.type = type;
 149         }
 150 
 151         public int getType() {
 152             return type;
 153         }
 154 
 155         public String getAbbreviatedModifierDescription(Object value) {
 156             return getModifierValueName(value);
 157         }
 158 
 159         public String getModifierValueName(Object val) {
 160             return getNodeName();
 161         }
 162     }
 163 
 164     protected abstract static class Context {
 165         int size;
 166         Object input;
 167         int inputType;
 168         InputStream origStream;
 169 
 170         Context(TestEnvironment env, Result result) {
 171             size = env.getIntValue(sizeList);
 172             if (hasImageIO) {
 173                 if (env.getModifier(useCacheTog) != null) {
 174                     ImageIO.setUseCache(env.isEnabled(useCacheTog));
 175                 }
 176             }
 177 
 178             InputType t = (InputType)env.getModifier(generalSourceRoot);
 179             inputType = t.getType();
 180         }
 181 
 182         void initInput() {
 183             if ((inputType == INPUT_FILE) ||
 184                 (inputType == INPUT_URL) ||
 185                 (inputType == INPUT_FILECHANNEL))
 186             {
 187                 try {
 188                     // REMIND: this approach will fail for GIF on pre-1.6 VM's
 189                     //         (since earlier releases do not include a
 190                     //         GIFImageWriter in the core JDK)
 191                     File inputfile = File.createTempFile("iio", ".tmp");
 192                     inputfile.deleteOnExit();
 193                     initContents(inputfile);
 194                     if (inputType == INPUT_FILE) {
 195                         input = inputfile;
 196                     } else if (inputType == INPUT_FILECHANNEL) {
 197                         input = inputfile;
 198                     } else { // inputType == INPUT_URL
 199                         try {
 200                             input = inputfile.toURI().toURL();
 201                         } catch (Exception e) {
 202                             System.err.println("error creating URL");
 203                         }
 204                     }
 205                 } catch (IOException e) {
 206                     System.err.println("error creating image file");
 207                     e.printStackTrace();
 208                 }
 209             } else {
 210                 ByteArrayOutputStream out;
 211                 try {
 212                     out = new ByteArrayOutputStream();
 213                     initContents(out);
 214                 } catch (IOException e) {
 215                     System.err.println("error creating image array");
 216                     e.printStackTrace();
 217                     return;
 218                 }
 219                 input = out.toByteArray();
 220             }
 221         }
 222 
 223         abstract void initContents(File f) throws IOException;
 224         abstract void initContents(OutputStream out) throws IOException;
 225 
 226         ImageInputStream createImageInputStream() throws IOException {
 227             ImageInputStream iis;
 228             BufferedInputStream bis;
 229             switch (inputType) {
 230             case INPUT_FILE:
 231                 iis = new FileImageInputStream((File)input);
 232                 break;
 233             case INPUT_URL:
 234                 origStream = ((URL)input).openStream();
 235                 bis = new BufferedInputStream(origStream);
 236                 if (ImageIO.getUseCache()) {
 237                     iis = new FileCacheImageInputStream(bis, null);
 238                 } else {
 239                     iis = new MemoryCacheImageInputStream(bis);
 240                 }
 241                 break;
 242             case INPUT_ARRAY:
 243                 origStream = new ByteArrayInputStream((byte[])input);
 244                 bis = new BufferedInputStream(origStream);
 245                 if (ImageIO.getUseCache()) {
 246                     iis = new FileCacheImageInputStream(bis, null);
 247                 } else {
 248                     iis = new MemoryCacheImageInputStream(bis);
 249                 }
 250                 break;
 251             case INPUT_FILECHANNEL:
 252                 FileInputStream fis = new FileInputStream((File)input);
 253                 origStream = fis;
 254                 java.nio.channels.FileChannel fc = fis.getChannel();
 255                 iis = fileChannelIISSpi.createInputStreamInstance(fc, false,
 256                                                                   null);
 257                 break;
 258             default:
 259                 iis = null;
 260                 break;
 261             }
 262             return iis;
 263         }
 264 
 265         void closeOriginalStream() throws IOException {
 266             if (origStream != null) {
 267                 origStream.close();
 268                 origStream = null;
 269             }
 270         }
 271 
 272         void cleanup(TestEnvironment env) {
 273         }
 274     }
 275 }