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
41package j2dbench.tests.iio;
42
43import java.io.BufferedOutputStream;
44import java.io.ByteArrayOutputStream;
45import java.io.File;
46import java.io.FileOutputStream;
47import java.io.IOException;
48import java.io.OutputStream;
49import javax.imageio.ImageIO;
50import javax.imageio.spi.IIORegistry;
51import javax.imageio.spi.ImageOutputStreamSpi;
52import javax.imageio.stream.FileCacheImageOutputStream;
53import javax.imageio.stream.FileImageOutputStream;
54import javax.imageio.stream.ImageOutputStream;
55import javax.imageio.stream.MemoryCacheImageOutputStream;
56
57import j2dbench.Group;
58import j2dbench.Option;
59import j2dbench.Result;
60import j2dbench.TestEnvironment;
61
62abstract class OutputTests extends IIOTests {
63
64    protected static final int OUTPUT_FILE        = 1;
65    protected static final int OUTPUT_ARRAY       = 2;
66    protected static final int OUTPUT_FILECHANNEL = 3;
67
68    protected static ImageOutputStreamSpi fileChannelIOSSpi;
69    static {
70        if (hasImageIO) {
71            ImageIO.scanForPlugins();
72            IIORegistry registry = IIORegistry.getDefaultInstance();
73            java.util.Iterator spis =
74                registry.getServiceProviders(ImageOutputStreamSpi.class,
75                                             false);
76            while (spis.hasNext()) {
77                ImageOutputStreamSpi spi = (ImageOutputStreamSpi)spis.next();
78                String klass = spi.getClass().getName();
79                if (klass.endsWith("ChannelImageOutputStreamSpi")) {
80                    fileChannelIOSSpi = spi;
81                    break;
82                }
83            }
84        }
85    }
86
87    protected static Group outputRoot;
88    protected static Group outputOptRoot;
89
90    protected static Group generalOptRoot;
91    protected static Group.EnableSet generalDestRoot;
92    protected static Option destFileOpt;
93    protected static Option destByteArrayOpt;
94
95    protected static Group imageioGeneralOptRoot;
96    protected static Option destFileChannelOpt;
97    protected static Option useCacheTog;
98
99    public static void init() {
100        outputRoot = new Group(iioRoot, "output", "Output Benchmarks");
101        outputRoot.setTabbed();
102
103        // Options
104        outputOptRoot = new Group(outputRoot, "opts", "Options");
105
106        // General Options
107        generalOptRoot = new Group(outputOptRoot,
108                                   "general", "General Options");
109        generalDestRoot = new Group.EnableSet(generalOptRoot,
110                                              "dest", "Destintations");
111        destFileOpt = new OutputType("file", "File", OUTPUT_FILE);
112        destByteArrayOpt = new OutputType("byteArray", "byte[]", OUTPUT_ARRAY);
113
114        if (hasImageIO) {
115            // Image I/O Options
116            imageioGeneralOptRoot = new Group(outputOptRoot,
117                                              "imageio", "Image I/O Options");
118            if (fileChannelIOSSpi != null) {
119                destFileChannelOpt =
120                    new OutputType("fileChannel", "FileChannel",
121                                   OUTPUT_FILECHANNEL);
122            }
123            useCacheTog = new Option.Toggle(imageioGeneralOptRoot, "useCache",
124                                            "ImageIO.setUseCache()",
125                                            Option.Toggle.Off);
126        }
127
128        OutputImageTests.init();
129        if (hasImageIO) {
130            OutputStreamTests.init();
131        }
132    }
133
134    protected OutputTests(Group parent, String nodeName, String description) {
135        super(parent, nodeName, description);
136    }
137
138    protected static class OutputType extends Option.Enable {
139        private int type;
140
141        public OutputType(String nodeName, String description, int type) {
142            super(generalDestRoot, nodeName, description, false);
143            this.type = type;
144        }
145
146        public int getType() {
147            return type;
148        }
149
150        public String getAbbreviatedModifierDescription(Object value) {
151            return getModifierValueName(value);
152        }
153
154        public String getModifierValueName(Object val) {
155            return getNodeName();
156        }
157    }
158
159    protected abstract static class Context {
160        int size;
161        Object output;
162        int outputType;
163        OutputStream origStream;
164
165        Context(TestEnvironment env, Result result) {
166            size = env.getIntValue(sizeList);
167            if (hasImageIO) {
168                if (env.getModifier(useCacheTog) != null) {
169                    ImageIO.setUseCache(env.isEnabled(useCacheTog));
170                }
171            }
172
173            OutputType t = (OutputType)env.getModifier(generalDestRoot);
174            outputType = t.getType();
175        }
176
177        void initOutput() {
178            if ((outputType == OUTPUT_FILE) ||
179                (outputType == OUTPUT_FILECHANNEL))
180            {
181                try {
182                    File outputfile = File.createTempFile("iio", ".tmp");
183                    outputfile.deleteOnExit();
184                    output = outputfile;
185                } catch (IOException e) {
186                    System.err.println("error creating temp file");
187                    e.printStackTrace();
188                }
189            }
190        }
191
192        ImageOutputStream createImageOutputStream() throws IOException {
193            ImageOutputStream ios;
194            switch (outputType) {
195            case OUTPUT_FILE:
196                ios = new FileImageOutputStream((File)output);
197                break;
198            case OUTPUT_ARRAY:
199                ByteArrayOutputStream baos = new ByteArrayOutputStream();
200                BufferedOutputStream bos = new BufferedOutputStream(baos);
201                if (ImageIO.getUseCache()) {
202                    ios = new FileCacheImageOutputStream(bos, null);
203                } else {
204                    ios = new MemoryCacheImageOutputStream(bos);
205                }
206                break;
207            case OUTPUT_FILECHANNEL:
208                FileOutputStream fos = new FileOutputStream((File)output);
209                origStream = fos;
210                java.nio.channels.FileChannel fc = fos.getChannel();
211                ios = fileChannelIOSSpi.createOutputStreamInstance(fc, false,
212                                                                   null);
213                break;
214            default:
215                ios = null;
216                break;
217            }
218            return ios;
219        }
220
221        void closeOriginalStream() throws IOException {
222            if (origStream != null) {
223                origStream.close();
224                origStream = null;
225            }
226        }
227
228        void cleanup(TestEnvironment env) {
229        }
230    }
231}
232