1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
|
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @author Rustem V. Rafikov
* @version $Revision: 1.3 $
*/
package javax.imageio.spi;
import javax.imageio.stream.ImageInputStream;
import javax.imageio.ImageTypeSpecifier;
import javax.imageio.ImageWriter;
import java.awt.image.RenderedImage;
import java.io.IOException;
/**
* The ImageWriterSpi abstract class is a service provider
* interface (SPI) for ImageWriters.
*/
public abstract class ImageWriterSpi extends ImageReaderWriterSpi {
/** The STANDARD_OUTPUT_TYPE contains ImageInputStream.class. */
public static final Class[] STANDARD_OUTPUT_TYPE = new Class[] {ImageInputStream.class};
/** The output types. */
protected Class[] outputTypes;
/** The reader spi names. */
protected String[] readerSpiNames;
/**
* Instantiates a new ImageWriterSpi.
*/
protected ImageWriterSpi() {
throw new UnsupportedOperationException("Not supported yet");
}
/**
* Instantiates a new ImageWriterSpi with the specified parameters.
*
* @param vendorName the vendor name.
* @param version the version.
* @param names the format names.
* @param suffixes the array of strings representing the file suffixes.
* @param MIMETypes the an array of strings representing MIME types.
* @param pluginClassName the plugin class name.
* @param outputTypes the output types.
* @param readerSpiNames the array of strings with class names of all
* associated ImageReaders.
* @param supportsStandardStreamMetadataFormat the value indicating
* if stream metadata can be described by standard metadata format.
* @param nativeStreamMetadataFormatName the native stream metadata
* format name, returned by getNativeStreamMetadataFormatName.
* @param nativeStreamMetadataFormatClassName the native stream
* metadata format class name, returned by getNativeStreamMetadataFormat.
* @param extraStreamMetadataFormatNames the extra stream metadata
* format names, returned by getExtraStreamMetadataFormatNames.
* @param extraStreamMetadataFormatClassNames the extra stream metadata
* format class names, returned by getStreamMetadataFormat.
* @param supportsStandardImageMetadataFormat the value indicating
* if image metadata can be described by standard metadata format.
* @param nativeImageMetadataFormatName the native image metadata
* format name, returned by getNativeImageMetadataFormatName.
* @param nativeImageMetadataFormatClassName the native image
* metadata format class name, returned by getNativeImageMetadataFormat.
* @param extraImageMetadataFormatNames the extra image metadata
* format names, returned by getExtraImageMetadataFormatNames.
* @param extraImageMetadataFormatClassNames the extra image metadata
* format class names, returned by getImageMetadataFormat.
*/
public ImageWriterSpi(String vendorName, String version, String[] names,
String[] suffixes, String[] MIMETypes,
String pluginClassName,
Class[] outputTypes, String[] readerSpiNames,
boolean supportsStandardStreamMetadataFormat,
String nativeStreamMetadataFormatName,
String nativeStreamMetadataFormatClassName,
String[] extraStreamMetadataFormatNames,
String[] extraStreamMetadataFormatClassNames,
boolean supportsStandardImageMetadataFormat,
String nativeImageMetadataFormatName,
String nativeImageMetadataFormatClassName,
String[] extraImageMetadataFormatNames,
String[] extraImageMetadataFormatClassNames) {
super(vendorName, version, names, suffixes, MIMETypes, pluginClassName,
supportsStandardStreamMetadataFormat, nativeStreamMetadataFormatName,
nativeStreamMetadataFormatClassName, extraStreamMetadataFormatNames,
extraStreamMetadataFormatClassNames, supportsStandardImageMetadataFormat,
nativeImageMetadataFormatName, nativeImageMetadataFormatClassName,
extraImageMetadataFormatNames, extraImageMetadataFormatClassNames);
if (outputTypes == null || outputTypes.length == 0) {
throw new NullPointerException("output types array cannot be NULL or empty");
}
this.outputTypes = outputTypes;
this.readerSpiNames = readerSpiNames;
}
/**
* Returns true if the format of the writer's output is lossless.
* The default implementation returns true.
*
* @return true, if a format is lossless, false otherwise.
*/
public boolean isFormatLossless() {
return true;
}
/**
* Gets an array of Class objects whose types
* can be used as output for this writer.
*
* @return the output types.
*/
public Class[] getOutputTypes() {
return outputTypes;
}
/**
* Checks whether or not the ImageWriter implementation associated
* with this service provider can encode an image with
* the specified type.
*
* @param type the ImageTypeSpecifier.
*
* @return true, if an image with the specified type can be
* encoded, false otherwise.
*/
public abstract boolean canEncodeImage(ImageTypeSpecifier type);
/**
* Checks whether or not the ImageWriter implementation associated
* with this service provider can encode the specified RenderedImage.
*
* @param im the RenderedImage.
*
* @return true, if RenderedImage can be encoded,
* false otherwise.
*/
public boolean canEncodeImage(RenderedImage im) {
return canEncodeImage(ImageTypeSpecifier.createFromRenderedImage(im));
}
/**
* Returns an instance of the ImageWriter implementation for
* this service provider.
*
* @return the ImageWriter.
*
* @throws IOException Signals that an I/O exception has occurred.
*/
public ImageWriter createWriterInstance() throws IOException {
return createWriterInstance(null);
}
/**
* Returns an instance of the ImageWriter implementation for
* this service provider.
*
* @param extension the a plugin specific extension object, or null.
*
* @return the ImageWriter.
*
* @throws IOException Signals that an I/O exception has occurred.
*/
public abstract ImageWriter createWriterInstance(Object extension) throws IOException;
/**
* Checks whether or not the specified ImageWriter object
* is an instance of the ImageWriter associated with this
* service provider or not.
*
* @param writer the ImageWriter.
*
* @return true, if the specified ImageWriter object
* is an instance of the ImageWriter associated with this
* service provider, false otherwise.
*/
public boolean isOwnWriter(ImageWriter writer) {
throw new UnsupportedOperationException("Not supported yet");
}
/**
* Gets an array of strings with names of the ImageReaderSpi
* classes that support the internal metadata representation
* used by the ImageWriter of this service provider, or null if
* there are no such ImageReaders.
*
* @return an array of strings with names of the ImageWriterSpi
* classes.
*/
public String[] getImageReaderSpiNames() {
return readerSpiNames;
}
}
|
