1 |
/* ImageWriter.java -- Encodes raster images. |
/* ImageWriter.java -- Encodes raster images. |
2 |
Copyright (C) 2004 Free Software Foundation, Inc. |
Copyright (C) 2004, 2005 Free Software Foundation, Inc. |
3 |
|
|
4 |
This file is part of GNU Classpath. |
This file is part of GNU Classpath. |
5 |
|
|
39 |
package javax.imageio; |
package javax.imageio; |
40 |
|
|
41 |
import java.awt.Dimension; |
import java.awt.Dimension; |
42 |
|
import java.awt.Rectangle; |
43 |
|
import java.awt.image.Raster; |
44 |
|
import java.awt.image.RenderedImage; |
45 |
import java.io.IOException; |
import java.io.IOException; |
46 |
import java.util.ArrayList; |
import java.util.ArrayList; |
47 |
import java.util.Iterator; |
import java.util.Iterator; |
48 |
import java.util.List; |
import java.util.List; |
49 |
import java.util.Locale; |
import java.util.Locale; |
50 |
|
import java.util.ResourceBundle; |
51 |
|
import java.util.MissingResourceException; |
52 |
|
|
53 |
import javax.imageio.event.IIOWriteProgressListener; |
import javax.imageio.event.IIOWriteProgressListener; |
54 |
import javax.imageio.event.IIOWriteWarningListener; |
import javax.imageio.event.IIOWriteWarningListener; |
56 |
|
|
57 |
import javax.imageio.spi.ImageWriterSpi; |
import javax.imageio.spi.ImageWriterSpi; |
58 |
|
|
59 |
|
/** |
60 |
|
* A class for encoding images within the ImageIO framework. |
61 |
|
* |
62 |
|
* An ImageWriter for a given format is instantiated by an |
63 |
|
* ImageWriterSpi for that format. ImageWriterSpis are registered |
64 |
|
* with the IIORegistry. |
65 |
|
* |
66 |
|
* The ImageWriter API supports writing animated images that may have |
67 |
|
* multiple frames; to support such images many methods take an index |
68 |
|
* parameter. |
69 |
|
* |
70 |
|
* Images may also be written in multiple passes, where each |
71 |
|
* successive pass increases the level of detail in the destination |
72 |
|
* image. |
73 |
|
*/ |
74 |
public abstract class ImageWriter |
public abstract class ImageWriter |
75 |
implements ImageTranscoder |
implements ImageTranscoder |
76 |
{ |
{ |
77 |
private boolean aborted; |
private boolean aborted; |
78 |
|
|
79 |
protected Locale[] availableLocales; |
/** |
80 |
protected Locale locale; |
* All locales available for localization of warning messages, or |
81 |
protected ImageWriterSpi originatingProvider; |
* null if localization is not supported. |
82 |
protected Object output; |
*/ |
83 |
protected List progressListeners = new ArrayList(); |
protected Locale[] availableLocales = null; |
84 |
protected List warningListeners = new ArrayList(); |
|
85 |
protected List warningLocales = new ArrayList(); |
/** |
86 |
|
* The current locale used to localize warning messages, or null if |
87 |
|
* no locale has been set. |
88 |
|
*/ |
89 |
|
protected Locale locale = null; |
90 |
|
|
91 |
|
/** |
92 |
|
* The image writer SPI that instantiated this writer. |
93 |
|
*/ |
94 |
|
protected ImageWriterSpi originatingProvider = null; |
95 |
|
|
96 |
|
/** |
97 |
|
* An ImageInputStream to which image data is written. |
98 |
|
*/ |
99 |
|
protected Object output = null; |
100 |
|
|
101 |
|
/** |
102 |
|
* A list of installed progress listeners. Initially null, meaning |
103 |
|
* no installed listeners. |
104 |
|
*/ |
105 |
|
protected List progressListeners = null; |
106 |
|
|
107 |
|
/** |
108 |
|
* A list of installed warning listeners. Initially null, meaning |
109 |
|
* no installed listeners. |
110 |
|
*/ |
111 |
|
protected List warningListeners = null; |
112 |
|
|
113 |
|
/** |
114 |
|
* A list of warning locales corresponding with the list of |
115 |
|
* installed warning listeners. Initially null, meaning no locales. |
116 |
|
*/ |
117 |
|
protected List warningLocales = null; |
118 |
|
|
119 |
|
/** |
120 |
|
* Construct an image writer. |
121 |
|
* |
122 |
|
* @param originatingProvider the provider that is constructing this |
123 |
|
* image writer, or null |
124 |
|
*/ |
125 |
protected ImageWriter(ImageWriterSpi originatingProvider) |
protected ImageWriter(ImageWriterSpi originatingProvider) |
126 |
{ |
{ |
127 |
this.originatingProvider = originatingProvider; |
this.originatingProvider = originatingProvider; |
128 |
} |
} |
129 |
|
|
130 |
|
/** |
131 |
|
* Throw an IllegalStateException if output is null. |
132 |
|
* |
133 |
|
* @exception IllegalStateException if output is null |
134 |
|
*/ |
135 |
private void checkOutputSet() |
private void checkOutputSet() |
136 |
{ |
{ |
137 |
if (output == null) |
if (output == null) |
138 |
throw new IllegalStateException("no output set"); |
throw new IllegalStateException("no output set"); |
139 |
} |
} |
140 |
|
|
141 |
|
/** |
142 |
|
* Request that writing be aborted. The unwritten portions of the |
143 |
|
* destination image will be undefined. |
144 |
|
* |
145 |
|
* Writers should clear the abort flag before starting a write |
146 |
|
* operation, then poll it periodically during the write operation. |
147 |
|
*/ |
148 |
public void abort() |
public void abort() |
149 |
{ |
{ |
150 |
aborted = true; |
aborted = true; |
151 |
} |
} |
152 |
|
|
153 |
|
/** |
154 |
|
* Check if the abort flag is set. |
155 |
|
* |
156 |
|
* @return true if the current write operation should be aborted, |
157 |
|
* false otherwise |
158 |
|
*/ |
159 |
protected boolean abortRequested() |
protected boolean abortRequested() |
160 |
{ |
{ |
161 |
return aborted; |
return aborted; |
162 |
} |
} |
163 |
|
|
164 |
|
/** |
165 |
|
* Install a write progress listener. This method will return |
166 |
|
* immediately if listener is null. |
167 |
|
* |
168 |
|
* @param listener a write progress listener or null |
169 |
|
*/ |
170 |
public void addIIOWriteProgressListener(IIOWriteProgressListener listener) |
public void addIIOWriteProgressListener(IIOWriteProgressListener listener) |
171 |
{ |
{ |
172 |
if (listener == null) |
if (listener == null) |
173 |
return; |
return; |
174 |
|
if (progressListeners == null) |
175 |
|
progressListeners = new ArrayList (); |
176 |
progressListeners.add(listener); |
progressListeners.add(listener); |
177 |
} |
} |
178 |
|
|
179 |
|
/** |
180 |
|
* Install a write warning listener. This method will return |
181 |
|
* immediately if listener is null. Warning messages sent to this |
182 |
|
* listener will be localized using the current locale. If the |
183 |
|
* current locale is null then this writer will select a sensible |
184 |
|
* default. |
185 |
|
* |
186 |
|
* @param listener a write warning listener |
187 |
|
*/ |
188 |
public void addIIOWriteWarningListener (IIOWriteWarningListener listener) |
public void addIIOWriteWarningListener (IIOWriteWarningListener listener) |
189 |
{ |
{ |
190 |
if (listener == null) |
if (listener == null) |
191 |
return; |
return; |
192 |
|
if (warningListeners == null) |
193 |
|
warningListeners = new ArrayList (); |
194 |
warningListeners.add(listener); |
warningListeners.add(listener); |
195 |
} |
} |
196 |
|
|
197 |
|
/** |
198 |
|
* Check whether a new empty image can be inserted at the given |
199 |
|
* frame index. Pixel values may be filled in later using the |
200 |
|
* replacePixels methods. Indices greater than the insertion index |
201 |
|
* will be incremented. If imageIndex is -1, the image will be |
202 |
|
* appended at the end of the current image list. |
203 |
|
* |
204 |
|
* @param imageIndex the frame index |
205 |
|
* |
206 |
|
* @return true if an empty image can be inserted at imageIndex, |
207 |
|
* false otherwise |
208 |
|
* |
209 |
|
* @exception IllegalStateException if output is null |
210 |
|
* @exception IndexOutOfBoundsException if imageIndex is less than |
211 |
|
* -1 or greater than the last index in the current image list |
212 |
|
* @exception IOException if a write error occurs |
213 |
|
*/ |
214 |
public boolean canInsertEmpty(int imageIndex) |
public boolean canInsertEmpty(int imageIndex) |
215 |
throws IOException |
throws IOException |
216 |
{ |
{ |
218 |
return false; |
return false; |
219 |
} |
} |
220 |
|
|
221 |
|
/** |
222 |
|
* Check whether an image can be inserted at the given frame index. |
223 |
|
* Indices greater than the insertion index will be incremented. If |
224 |
|
* imageIndex is -1, the image will be appended at the end of the |
225 |
|
* current image list. |
226 |
|
* |
227 |
|
* @param imageIndex the frame index |
228 |
|
* |
229 |
|
* @return true if an image can be inserted at imageIndex, false |
230 |
|
* otherwise |
231 |
|
* |
232 |
|
* @exception IllegalStateException if output is null |
233 |
|
* @exception IndexOutOfBoundsException if imageIndex is less than |
234 |
|
* -1 or greater than the last index in the current image list |
235 |
|
* @exception IOException if a write error occurs |
236 |
|
*/ |
237 |
public boolean canInsertImage(int imageIndex) |
public boolean canInsertImage(int imageIndex) |
238 |
throws IOException |
throws IOException |
239 |
{ |
{ |
241 |
return false; |
return false; |
242 |
} |
} |
243 |
|
|
244 |
|
/** |
245 |
|
* Check whether an image can be removed from the given frame index. |
246 |
|
* Indices greater than the removal index will be decremented. |
247 |
|
* |
248 |
|
* @param imageIndex the frame index |
249 |
|
* |
250 |
|
* @return true if an image can be removed from imageIndex, false |
251 |
|
* otherwise |
252 |
|
* |
253 |
|
* @exception IllegalStateException if output is null |
254 |
|
* @exception IndexOutOfBoundsException if imageIndex is less than 0 |
255 |
|
* or greater than the last index in the current image list |
256 |
|
* @exception IOException if a write error occurs |
257 |
|
*/ |
258 |
public boolean canRemoveImage(int imageIndex) |
public boolean canRemoveImage(int imageIndex) |
259 |
throws IOException |
throws IOException |
260 |
{ |
{ |
262 |
return false; |
return false; |
263 |
} |
} |
264 |
|
|
265 |
|
/** |
266 |
|
* Check whether the metadata associated the image at the given |
267 |
|
* frame index can be replaced. |
268 |
|
* |
269 |
|
* @param imageIndex the frame index |
270 |
|
* |
271 |
|
* @return true if the metadata associated with the image at |
272 |
|
* imageIndex can be replaced, false otherwise |
273 |
|
* |
274 |
|
* @exception IllegalStateException if output is null |
275 |
|
* @exception IndexOutOfBoundsException if imageIndex is less than 0 |
276 |
|
* or greater than the last index in the current image list |
277 |
|
* @exception IOException if a write error occurs |
278 |
|
*/ |
279 |
public boolean canReplaceImageMetadata(int imageIndex) |
public boolean canReplaceImageMetadata(int imageIndex) |
280 |
throws IOException |
throws IOException |
281 |
{ |
{ |
283 |
return false; |
return false; |
284 |
} |
} |
285 |
|
|
286 |
|
/** |
287 |
|
* Check whether the pixels within the image at the given index can |
288 |
|
* be replaced. |
289 |
|
* |
290 |
|
* @param imageIndex the frame index |
291 |
|
* |
292 |
|
* @return true if the pixels in the image at imageIndex can be |
293 |
|
* replaced, false otherwise |
294 |
|
* |
295 |
|
* @exception IllegalStateException if output is null |
296 |
|
* @exception IndexOutOfBoundsException if imageIndex is less than 0 |
297 |
|
* or greater than the last index in the current image list |
298 |
|
* @exception IOException if a write error occurs |
299 |
|
*/ |
300 |
public boolean canReplacePixels(int imageIndex) |
public boolean canReplacePixels(int imageIndex) |
301 |
throws IOException |
throws IOException |
302 |
{ |
{ |
304 |
return false; |
return false; |
305 |
} |
} |
306 |
|
|
307 |
|
/** |
308 |
|
* Check whether the metadata associated the entire image stream can |
309 |
|
* be replaced. |
310 |
|
* |
311 |
|
* @return true if the stream metadata can be replaced, false |
312 |
|
* otherwise |
313 |
|
* |
314 |
|
* @exception IllegalStateException if output is null |
315 |
|
* @exception IOException if a write error occurs |
316 |
|
*/ |
317 |
public boolean canReplaceStreamMetadata() |
public boolean canReplaceStreamMetadata() |
318 |
throws IOException |
throws IOException |
319 |
{ |
{ |
321 |
return false; |
return false; |
322 |
} |
} |
323 |
|
|
324 |
|
/** |
325 |
|
* Check whether an entire empty image, including empty metadata and |
326 |
|
* empty thumbnails, can be written to the output stream, leaving |
327 |
|
* pixel values to be filled in later using the replacePixels |
328 |
|
* methods. |
329 |
|
* |
330 |
|
* @return true if an entire empty image can be written before its |
331 |
|
* contents are filled in, false otherwise |
332 |
|
* |
333 |
|
* @exception IllegalStateException if output is null |
334 |
|
* @exception IOException if a write error occurs |
335 |
|
*/ |
336 |
public boolean canWriteEmpty() |
public boolean canWriteEmpty() |
337 |
throws IOException |
throws IOException |
338 |
{ |
{ |
340 |
return false; |
return false; |
341 |
} |
} |
342 |
|
|
343 |
|
/** |
344 |
|
* Check if IIOImages containing raster data are supported. |
345 |
|
* |
346 |
|
* @return true if raster IIOImages are supported, false otherwise |
347 |
|
*/ |
348 |
public boolean canWriteRasters() |
public boolean canWriteRasters() |
349 |
{ |
{ |
350 |
return false; |
return false; |
351 |
} |
} |
352 |
|
|
353 |
|
/** |
354 |
|
* Check if an image can be appended at the end of the current list |
355 |
|
* of images even if prior images have already been written. |
356 |
|
* |
357 |
|
* @return true if sequences of images can be written, false |
358 |
|
* otherwise |
359 |
|
*/ |
360 |
public boolean canWriteSequence() |
public boolean canWriteSequence() |
361 |
{ |
{ |
362 |
return false; |
return false; |
363 |
} |
} |
364 |
|
|
365 |
|
/** |
366 |
|
* Clear the abort flag. |
367 |
|
*/ |
368 |
protected void clearAbortRequest() |
protected void clearAbortRequest() |
369 |
{ |
{ |
370 |
aborted = false; |
aborted = false; |
371 |
} |
} |
372 |
|
|
373 |
|
/** |
374 |
|
* Convert IIOMetadata from an input reader format, returning an |
375 |
|
* IIOMetadata suitable for use by an image writer. |
376 |
|
* |
377 |
|
* The ImageTypeSpecifier specifies the destination image type. |
378 |
|
* |
379 |
|
* An optional ImageWriteParam argument is available in case the |
380 |
|
* image writing parameters affect the metadata conversion. |
381 |
|
* |
382 |
|
* @param inData the metadata coming from an image reader |
383 |
|
* @param imageType the output image type of the writer |
384 |
|
* @param param the image writing parameters or null |
385 |
|
* |
386 |
|
* @return the converted metadata that should be used by the image |
387 |
|
* writer, or null if this ImageTranscoder has no knowledge of the |
388 |
|
* input metadata |
389 |
|
* |
390 |
|
* @exception IllegalArgumentException if either inData or imageType |
391 |
|
* is null |
392 |
|
*/ |
393 |
public abstract IIOMetadata convertImageMetadata (IIOMetadata inData, |
public abstract IIOMetadata convertImageMetadata (IIOMetadata inData, |
394 |
ImageTypeSpecifier imageType, |
ImageTypeSpecifier imageType, |
395 |
ImageWriteParam param); |
ImageWriteParam param); |
396 |
|
|
397 |
|
/** |
398 |
|
* Convert IIOMetadata from an input stream format, returning an |
399 |
|
* IIOMetadata suitable for use by an image writer. |
400 |
|
* |
401 |
|
* An optional ImageWriteParam argument is available in case the |
402 |
|
* image writing parameters affect the metadata conversion. |
403 |
|
* |
404 |
|
* @param inData the metadata coming from an input image stream |
405 |
|
* @param param the image writing parameters or null |
406 |
|
* |
407 |
|
* @return the converted metadata that should be used by the image |
408 |
|
* writer, or null if this ImageTranscoder has no knowledge of the |
409 |
|
* input metadata |
410 |
|
* |
411 |
|
* @exception IllegalArgumentException if inData is null |
412 |
|
*/ |
413 |
public abstract IIOMetadata convertStreamMetadata (IIOMetadata inData, |
public abstract IIOMetadata convertStreamMetadata (IIOMetadata inData, |
414 |
ImageWriteParam param); |
ImageWriteParam param); |
415 |
|
|
416 |
|
/** |
417 |
|
* Releases any resources allocated to this object. Subsequent |
418 |
|
* calls to methods on this object will produce undefined results. |
419 |
|
* |
420 |
|
* The default implementation does nothing; subclasses should use |
421 |
|
* this method ensure that native resources are released. |
422 |
|
*/ |
423 |
public void dispose() |
public void dispose() |
424 |
{ |
{ |
425 |
// The default implementation is empty. Subclasses have to overwrite it. |
// The default implementation is empty. Subclasses have to overwrite it. |
426 |
} |
} |
427 |
|
|
428 |
|
/** |
429 |
|
* Retrieve the available locales. Return null if no locales are |
430 |
|
* available or a clone of availableLocales. |
431 |
|
* |
432 |
|
* @return an array of locales or null |
433 |
|
*/ |
434 |
public Locale[] getAvailableLocales() |
public Locale[] getAvailableLocales() |
435 |
{ |
{ |
436 |
return availableLocales; |
return availableLocales; |
437 |
} |
} |
438 |
|
|
439 |
|
/** |
440 |
|
* Get a metadata object appropriate for encoding an image specified |
441 |
|
* by the given image type specifier and optional image write |
442 |
|
* parameters. |
443 |
|
* |
444 |
|
* @param imageType an image type specifier |
445 |
|
* @param param image writing parameters, or null |
446 |
|
* |
447 |
|
* @return a metadata object appropriate for encoding an image of |
448 |
|
* the given type with the given parameters |
449 |
|
*/ |
450 |
public abstract IIOMetadata getDefaultImageMetadata (ImageTypeSpecifier imageType, ImageWriteParam param); |
public abstract IIOMetadata getDefaultImageMetadata (ImageTypeSpecifier imageType, ImageWriteParam param); |
451 |
|
|
452 |
|
/** |
453 |
|
* Get a metadata object appropriate for encoding the default image |
454 |
|
* type handled by this writer, optionally considering image write |
455 |
|
* parameters. |
456 |
|
* |
457 |
|
* @param param image writing parameters, or null |
458 |
|
* |
459 |
|
* @return a metadata object appropriate for encoding an image of |
460 |
|
* the default type with the given parameters |
461 |
|
*/ |
462 |
public abstract IIOMetadata getDefaultStreamMetadata (ImageWriteParam param); |
public abstract IIOMetadata getDefaultStreamMetadata (ImageWriteParam param); |
463 |
|
|
464 |
|
/** |
465 |
|
* Retrieve the default write parameters for this writer's image |
466 |
|
* format. |
467 |
|
* |
468 |
|
* The default implementation returns new ImageWriteParam(). |
469 |
|
* |
470 |
|
* @return image writing parameters |
471 |
|
*/ |
472 |
public ImageWriteParam getDefaultWriteParam() |
public ImageWriteParam getDefaultWriteParam() |
473 |
{ |
{ |
474 |
return new ImageWriteParam(getLocale()); |
return new ImageWriteParam(getLocale()); |
475 |
} |
} |
476 |
|
|
477 |
|
/** |
478 |
|
* Get this writer's locale. null is returned if the locale has not |
479 |
|
* been set. |
480 |
|
* |
481 |
|
* @return this writer's locale, or null |
482 |
|
*/ |
483 |
public Locale getLocale() |
public Locale getLocale() |
484 |
{ |
{ |
485 |
return locale; |
return locale; |
486 |
} |
} |
487 |
|
|
488 |
public int getNumThumbnailsSupported (ImageTypeSpecifier imageType, ImageWriteParam param, |
/** |
489 |
IIOMetadata streamMetadata, IIOMetadata imageMetadata) |
* Get the number of thumbnails supported by this image writer, |
490 |
|
* based on the given image type, image writing parameters, and |
491 |
|
* stream and image metadata. The image writing parameters are |
492 |
|
* optional, in case they affect the number of thumbnails supported. |
493 |
|
* |
494 |
|
* @param imageType an image type specifier, or null |
495 |
|
* @param param image writing parameters, or null |
496 |
|
* @param streamMetadata the metadata associated with this stream, |
497 |
|
* or null |
498 |
|
* @param imageMetadata the metadata associated with this image, or |
499 |
|
* null |
500 |
|
* |
501 |
|
* @return the number of thumbnails that this writer supports |
502 |
|
* writing or -1 if the given information is insufficient |
503 |
|
*/ |
504 |
|
public int getNumThumbnailsSupported (ImageTypeSpecifier imageType, |
505 |
|
ImageWriteParam param, |
506 |
|
IIOMetadata streamMetadata, |
507 |
|
IIOMetadata imageMetadata) |
508 |
{ |
{ |
509 |
return 0; |
return 0; |
510 |
} |
} |
511 |
|
|
512 |
|
/** |
513 |
|
* Get the ImageWriterSpi that created this writer or null. |
514 |
|
* |
515 |
|
* @return an ImageWriterSpi, or null |
516 |
|
*/ |
517 |
public ImageWriterSpi getOriginatingProvider() |
public ImageWriterSpi getOriginatingProvider() |
518 |
{ |
{ |
519 |
return originatingProvider; |
return originatingProvider; |
520 |
} |
} |
521 |
|
|
522 |
|
/** |
523 |
|
* Get this reader's image output destination. null is returned if |
524 |
|
* the image destination has not been set. |
525 |
|
* |
526 |
|
* @return an image output destination object, or null |
527 |
|
*/ |
528 |
public Object getOutput() |
public Object getOutput() |
529 |
{ |
{ |
530 |
return output; |
return output; |
531 |
} |
} |
532 |
|
|
533 |
|
/** |
534 |
|
* Get the preferred sizes for thumbnails based on the given image |
535 |
|
* type, image writing parameters, and stream and image metadata. |
536 |
|
* The preferred sizes are returned in pairs of dimension values; |
537 |
|
* the first value in the array is a dimension object representing |
538 |
|
* the minimum thumbnail size, the second value is a dimension |
539 |
|
* object representing a maximum thumbnail size. The writer can |
540 |
|
* select a size within the range given by each pair, or it can |
541 |
|
* ignore these size hints. |
542 |
|
* |
543 |
|
* @param imageType an image type specifier, or null |
544 |
|
* @param param image writing parameters, or null |
545 |
|
* @param streamMetadata the metadata associated with this stream, |
546 |
|
* or null |
547 |
|
* @param imageMetadata the metadata associated with this image, or |
548 |
|
* null |
549 |
|
* |
550 |
|
* @return an array of dimension pairs whose length is a multiple of |
551 |
|
* 2, or null if there is no preferred size (any size is allowed) or |
552 |
|
* if the size is unknown (insufficient information was provided) |
553 |
|
*/ |
554 |
public Dimension[] getPreferredThumbnailSizes (ImageTypeSpecifier imageType, |
public Dimension[] getPreferredThumbnailSizes (ImageTypeSpecifier imageType, |
555 |
ImageWriteParam param, |
ImageWriteParam param, |
556 |
IIOMetadata streamMetadata, |
IIOMetadata streamMetadata, |
559 |
return null; |
return null; |
560 |
} |
} |
561 |
|
|
562 |
|
/** |
563 |
|
* Notifies all installed write progress listeners that image |
564 |
|
* loading has completed by calling their imageComplete methods. |
565 |
|
*/ |
566 |
protected void processImageComplete() |
protected void processImageComplete() |
567 |
{ |
{ |
568 |
Iterator it = progressListeners.iterator(); |
if (progressListeners != null) |
|
|
|
|
while (it.hasNext()) |
|
569 |
{ |
{ |
570 |
IIOWriteProgressListener listener = (IIOWriteProgressListener) it.next(); |
Iterator it = progressListeners.iterator(); |
571 |
listener.imageComplete(this); |
|
572 |
|
while (it.hasNext()) |
573 |
|
{ |
574 |
|
IIOWriteProgressListener listener = |
575 |
|
(IIOWriteProgressListener) it.next(); |
576 |
|
listener.imageComplete(this); |
577 |
|
} |
578 |
} |
} |
579 |
} |
} |
580 |
|
|
581 |
|
/** |
582 |
|
* Notifies all installed write progress listeners that a certain |
583 |
|
* percentage of the image has been loaded, by calling their |
584 |
|
* imageProgress methods. |
585 |
|
* |
586 |
|
* @param percentageDone the percentage of image data that has been |
587 |
|
* loaded |
588 |
|
*/ |
589 |
protected void processImageProgress(float percentageDone) |
protected void processImageProgress(float percentageDone) |
590 |
{ |
{ |
591 |
Iterator it = progressListeners.iterator(); |
if (progressListeners != null) |
|
|
|
|
while (it.hasNext()) |
|
592 |
{ |
{ |
593 |
IIOWriteProgressListener listener = (IIOWriteProgressListener) it.next(); |
Iterator it = progressListeners.iterator(); |
594 |
listener.imageProgress(this, percentageDone); |
|
595 |
|
while (it.hasNext()) |
596 |
|
{ |
597 |
|
IIOWriteProgressListener listener = |
598 |
|
(IIOWriteProgressListener) it.next(); |
599 |
|
listener.imageProgress(this, percentageDone); |
600 |
|
} |
601 |
} |
} |
602 |
} |
} |
603 |
|
|
604 |
|
/** |
605 |
|
* Notifies all installed write progress listeners, by calling their |
606 |
|
* imageStarted methods, that image loading has started on the given |
607 |
|
* image. |
608 |
|
* |
609 |
|
* @param imageIndex the frame index of the image that has started |
610 |
|
* loading |
611 |
|
*/ |
612 |
protected void processImageStarted(int imageIndex) |
protected void processImageStarted(int imageIndex) |
613 |
{ |
{ |
614 |
Iterator it = progressListeners.iterator(); |
if (progressListeners != null) |
|
|
|
|
while (it.hasNext()) |
|
615 |
{ |
{ |
616 |
IIOWriteProgressListener listener = (IIOWriteProgressListener) it.next(); |
Iterator it = progressListeners.iterator(); |
617 |
listener.imageStarted(this, imageIndex); |
|
618 |
|
while (it.hasNext()) |
619 |
|
{ |
620 |
|
IIOWriteProgressListener listener = |
621 |
|
(IIOWriteProgressListener) it.next(); |
622 |
|
listener.imageStarted(this, imageIndex); |
623 |
|
} |
624 |
} |
} |
625 |
} |
} |
626 |
|
|
627 |
|
/** |
628 |
|
* Notifies all installed write progress listeners, by calling their |
629 |
|
* thumbnailComplete methods, that a thumbnail has completed |
630 |
|
* loading. |
631 |
|
*/ |
632 |
protected void processThumbnailComplete() |
protected void processThumbnailComplete() |
633 |
{ |
{ |
634 |
Iterator it = progressListeners.iterator(); |
if (progressListeners != null) |
|
|
|
|
while (it.hasNext()) |
|
635 |
{ |
{ |
636 |
IIOWriteProgressListener listener = (IIOWriteProgressListener) it.next(); |
Iterator it = progressListeners.iterator(); |
637 |
listener.thumbnailComplete(this); |
|
638 |
|
while (it.hasNext()) |
639 |
|
{ |
640 |
|
IIOWriteProgressListener listener = |
641 |
|
(IIOWriteProgressListener) it.next(); |
642 |
|
listener.thumbnailComplete(this); |
643 |
|
} |
644 |
} |
} |
645 |
} |
} |
646 |
|
|
647 |
|
/** |
648 |
|
* Notifies all installed write progress listeners that a certain |
649 |
|
* percentage of a thumbnail has been loaded, by calling their |
650 |
|
* thumbnailProgress methods. |
651 |
|
* |
652 |
|
* @param percentageDone the percentage of thumbnail data that has |
653 |
|
* been loaded |
654 |
|
*/ |
655 |
protected void processThumbnailProgress(float percentageDone) |
protected void processThumbnailProgress(float percentageDone) |
656 |
{ |
{ |
657 |
Iterator it = progressListeners.iterator(); |
if (progressListeners != null) |
|
|
|
|
while (it.hasNext()) |
|
658 |
{ |
{ |
659 |
IIOWriteProgressListener listener = (IIOWriteProgressListener) it.next(); |
Iterator it = progressListeners.iterator(); |
660 |
listener.thumbnailProgress(this, percentageDone); |
|
661 |
|
while (it.hasNext()) |
662 |
|
{ |
663 |
|
IIOWriteProgressListener listener = |
664 |
|
(IIOWriteProgressListener) it.next(); |
665 |
|
listener.thumbnailProgress(this, percentageDone); |
666 |
|
} |
667 |
} |
} |
668 |
} |
} |
669 |
|
|
670 |
|
/** |
671 |
|
* Notifies all installed write progress listeners, by calling their |
672 |
|
* imageStarted methods, that thumbnail loading has started on the |
673 |
|
* given thumbnail of the given image. |
674 |
|
* |
675 |
|
* @param imageIndex the frame index of the image one of who's |
676 |
|
* thumbnails has started loading |
677 |
|
* @param thumbnailIndex the index of the thumbnail that has started |
678 |
|
* loading |
679 |
|
*/ |
680 |
protected void processThumbnailStarted(int imageIndex, int thumbnailIndex) |
protected void processThumbnailStarted(int imageIndex, int thumbnailIndex) |
681 |
{ |
{ |
682 |
Iterator it = progressListeners.iterator(); |
if (progressListeners != null) |
|
|
|
|
while (it.hasNext()) |
|
683 |
{ |
{ |
684 |
IIOWriteProgressListener listener = (IIOWriteProgressListener) it.next(); |
Iterator it = progressListeners.iterator(); |
685 |
listener.thumbnailStarted(this, imageIndex, thumbnailIndex); |
|
686 |
|
while (it.hasNext()) |
687 |
|
{ |
688 |
|
IIOWriteProgressListener listener = |
689 |
|
(IIOWriteProgressListener) it.next(); |
690 |
|
listener.thumbnailStarted(this, imageIndex, thumbnailIndex); |
691 |
|
} |
692 |
} |
} |
693 |
} |
} |
694 |
|
|
695 |
|
/** |
696 |
|
* Notifies all installed warning listeners, by calling their |
697 |
|
* warningOccurred methods, that a warning message has been raised. |
698 |
|
* |
699 |
|
* @param imageIndex the index of the image that was being written |
700 |
|
* when the warning was raised |
701 |
|
* @param warning the warning message |
702 |
|
* |
703 |
|
* @exception IllegalArgumentException if warning is null |
704 |
|
*/ |
705 |
protected void processWarningOccurred(int imageIndex, String warning) |
protected void processWarningOccurred(int imageIndex, String warning) |
706 |
{ |
{ |
707 |
Iterator it = warningListeners.iterator(); |
if (warningListeners != null) |
708 |
|
{ |
709 |
|
Iterator it = warningListeners.iterator(); |
710 |
|
|
711 |
|
while (it.hasNext()) |
712 |
|
{ |
713 |
|
IIOWriteWarningListener listener = |
714 |
|
(IIOWriteWarningListener) it.next(); |
715 |
|
listener.warningOccurred(this, imageIndex, warning); |
716 |
|
} |
717 |
|
} |
718 |
|
} |
719 |
|
|
720 |
|
/** |
721 |
|
* Notify all installed warning listeners, by calling their |
722 |
|
* warningOccurred methods, that a warning message has been raised. |
723 |
|
* The warning message is retrieved from a resource bundle, using |
724 |
|
* the given basename and keyword. |
725 |
|
* |
726 |
|
* @param imageIndex the index of the image that was being written |
727 |
|
* when the warning was raised |
728 |
|
* @param baseName the basename of the resource from which to |
729 |
|
* retrieve the warning message |
730 |
|
* @param keyword the keyword used to retrieve the warning from the |
731 |
|
* resource bundle |
732 |
|
* |
733 |
|
* @exception IllegalArgumentException if either baseName or keyword |
734 |
|
* is null |
735 |
|
* @exception IllegalArgumentException if no resource bundle is |
736 |
|
* found using baseName |
737 |
|
* @exception IllegalArgumentException if the given keyword produces |
738 |
|
* no results from the resource bundle |
739 |
|
* @exception IllegalArgumentException if the retrieved object is |
740 |
|
* not a String |
741 |
|
*/ |
742 |
|
protected void processWarningOccurred(int imageIndex, |
743 |
|
String baseName, |
744 |
|
String keyword) |
745 |
|
{ |
746 |
|
if (baseName == null || keyword == null) |
747 |
|
throw new IllegalArgumentException ("null argument"); |
748 |
|
|
749 |
|
ResourceBundle b = null; |
750 |
|
|
751 |
|
try |
752 |
|
{ |
753 |
|
b = ResourceBundle.getBundle(baseName, getLocale()); |
754 |
|
} |
755 |
|
catch (MissingResourceException e) |
756 |
|
{ |
757 |
|
throw new IllegalArgumentException ("no resource bundle found"); |
758 |
|
} |
759 |
|
|
760 |
|
Object str = null; |
761 |
|
|
762 |
|
try |
763 |
|
{ |
764 |
|
str = b.getObject(keyword); |
765 |
|
} |
766 |
|
catch (MissingResourceException e) |
767 |
|
{ |
768 |
|
throw new IllegalArgumentException ("no results found for keyword"); |
769 |
|
} |
770 |
|
|
771 |
while (it.hasNext()) |
if (! (str instanceof String)) |
772 |
|
throw new IllegalArgumentException ("retrieved object not a String"); |
773 |
|
|
774 |
|
String warning = (String) str; |
775 |
|
|
776 |
|
if (warningListeners != null) |
777 |
{ |
{ |
778 |
IIOWriteWarningListener listener = (IIOWriteWarningListener) it.next(); |
Iterator it = warningListeners.iterator(); |
779 |
listener.warningOccurred(this, imageIndex, warning); |
|
780 |
|
while (it.hasNext()) |
781 |
|
{ |
782 |
|
IIOWriteWarningListener listener = |
783 |
|
(IIOWriteWarningListener) it.next(); |
784 |
|
listener.warningOccurred(this, imageIndex, warning); |
785 |
|
} |
786 |
} |
} |
787 |
} |
} |
788 |
|
|
789 |
|
/** |
790 |
|
* Notifies all installed write progress listeners that image |
791 |
|
* loading has been aborted by calling their writeAborted methods. |
792 |
|
*/ |
793 |
protected void processWriteAborted() |
protected void processWriteAborted() |
794 |
{ |
{ |
795 |
Iterator it = progressListeners.iterator(); |
if (progressListeners != null) |
|
|
|
|
while (it.hasNext()) |
|
796 |
{ |
{ |
797 |
IIOWriteProgressListener listener = (IIOWriteProgressListener) it.next(); |
Iterator it = progressListeners.iterator(); |
798 |
listener.writeAborted(this); |
|
799 |
|
while (it.hasNext()) |
800 |
|
{ |
801 |
|
IIOWriteProgressListener listener = |
802 |
|
(IIOWriteProgressListener) it.next(); |
803 |
|
listener.writeAborted(this); |
804 |
|
} |
805 |
} |
} |
806 |
} |
} |
807 |
|
|
808 |
|
/** |
809 |
|
* Uninstall all write progress listeners. |
810 |
|
*/ |
811 |
public void removeAllIIOWriteProgressListeners() |
public void removeAllIIOWriteProgressListeners() |
812 |
{ |
{ |
813 |
progressListeners.clear(); |
if (progressListeners != null) |
814 |
|
{ |
815 |
|
progressListeners.clear(); |
816 |
|
} |
817 |
} |
} |
818 |
|
|
819 |
|
/** |
820 |
|
* Uninstall all write warning listeners. |
821 |
|
*/ |
822 |
public void removeAllIIOWriteWarningListeners() |
public void removeAllIIOWriteWarningListeners() |
823 |
{ |
{ |
824 |
progressListeners.clear(); |
if (progressListeners != null) |
825 |
|
{ |
826 |
|
progressListeners.clear(); |
827 |
|
} |
828 |
} |
} |
829 |
|
|
830 |
public void removeIIOWriteProgressListener (IIOWriteProgressListener listener) |
/** |
831 |
|
* Uninstall the given write progress listener. |
832 |
|
* |
833 |
|
* @param listener the listener to remove |
834 |
|
*/ |
835 |
|
public void removeIIOWriteProgressListener (IIOWriteProgressListener listener) |
836 |
{ |
{ |
837 |
if (listener == null) |
if (listener == null) |
838 |
return; |
return; |
839 |
|
if (progressListeners != null) |
840 |
progressListeners.remove(listener); |
{ |
841 |
|
progressListeners.remove(listener); |
842 |
|
} |
843 |
} |
} |
844 |
|
/** |
845 |
|
* Uninstall the given write warning listener. |
846 |
|
* |
847 |
|
* @param listener the listener to remove |
848 |
|
*/ |
849 |
public void removeIIOWriteWarningListener (IIOWriteWarningListener listener) |
public void removeIIOWriteWarningListener (IIOWriteWarningListener listener) |
850 |
{ |
{ |
851 |
if (listener == null) |
if (listener == null) |
852 |
return; |
return; |
853 |
|
if (warningListeners != null) |
854 |
warningListeners.remove(listener); |
{ |
855 |
|
warningListeners.remove(listener); |
856 |
|
} |
857 |
} |
} |
858 |
|
/** |
859 |
|
* Reset this writer's internal state. |
860 |
|
*/ |
861 |
public void reset() |
public void reset() |
862 |
{ |
{ |
863 |
setOutput(null); |
setOutput(null); |
867 |
clearAbortRequest(); |
clearAbortRequest(); |
868 |
} |
} |
869 |
|
|
870 |
|
/** |
871 |
|
* Set the current locale or use the default locale. |
872 |
|
* |
873 |
|
* @param locale the locale to set, or null |
874 |
|
*/ |
875 |
public void setLocale(Locale locale) |
public void setLocale(Locale locale) |
876 |
{ |
{ |
877 |
if (locale != null) |
if (locale != null) |
891 |
this.locale = locale; |
this.locale = locale; |
892 |
} |
} |
893 |
|
|
894 |
|
/** |
895 |
|
* Set the output destination of the given object. The output |
896 |
|
* destination must be set before many methods can be called on this |
897 |
|
* writer. (see all ImageWriter methods that throw |
898 |
|
* IllegalStateException). If input is null then the current input |
899 |
|
* source will be removed. |
900 |
|
* |
901 |
|
* @param input the output destination object |
902 |
|
* |
903 |
|
* @exception IllegalArgumentException if input is not a valid input |
904 |
|
* source for this writer and is not an ImageInputStream |
905 |
|
*/ |
906 |
public void setOutput(Object output) |
public void setOutput(Object output) |
907 |
{ |
{ |
908 |
if (output != null) |
if (output != null) |
926 |
this.output = output; |
this.output = output; |
927 |
} |
} |
928 |
|
|
929 |
|
/** |
930 |
|
* Write an image stream, including thumbnails and metadata to the |
931 |
|
* output stream. The output must have been set prior to this |
932 |
|
* method being called. Metadata associated with the stream may be |
933 |
|
* supplied, or it can be left null. IIOImage may contain raster |
934 |
|
* data if this writer supports rasters, or it will contain a |
935 |
|
* rendered image. Thumbnails are resized if need be. Image |
936 |
|
* writing parameters may be specified to affect writing, or may be |
937 |
|
* left null. |
938 |
|
* |
939 |
|
* @param streamMetadata metadata associated with this stream, or |
940 |
|
* null |
941 |
|
* @param image an IIOImage containing image data, metadata and |
942 |
|
* thumbnails to be written |
943 |
|
* @param param image writing parameters, or null |
944 |
|
* |
945 |
|
* @exception IllegalStateException if output is null |
946 |
|
* @exception UnsupportedOperationException if image contains raster |
947 |
|
* data but this writer does not support rasters |
948 |
|
* @exception IllegalArgumentException if image is null |
949 |
|
* @exception IOException if a write error occurs |
950 |
|
*/ |
951 |
public abstract void write (IIOMetadata streamMetadata, IIOImage image, ImageWriteParam param) |
public abstract void write (IIOMetadata streamMetadata, IIOImage image, ImageWriteParam param) |
952 |
throws IOException; |
throws IOException; |
953 |
|
|
954 |
|
/** |
955 |
|
* Complete inserting an empty image in the output stream. |
956 |
|
* |
957 |
|
* @exception IllegalStateException if output is null |
958 |
|
* @exception UnsupportedOperationException if inserting empty |
959 |
|
* images is not supported |
960 |
|
* @exception IllegalArgumentException if a call to |
961 |
|
* prepareInsertEmpty was not called previous to this method being |
962 |
|
* called (a sequence of prepareInsertEmpty calls must be terminated |
963 |
|
* by a call to endInsertEmpty) |
964 |
|
* @exception IllegalArgumentException if prepareWriteEmpty was |
965 |
|
* called before this method being called (without a terminating |
966 |
|
* call to endWriteEmpty) |
967 |
|
* @exception IllegalArgumentException if prepareReplacePixels was |
968 |
|
* called before this method being called (without a terminating |
969 |
|
* call to endReplacePixels) |
970 |
|
* @exception IOException if a write error occurs |
971 |
|
*/ |
972 |
|
public void endInsertEmpty () |
973 |
|
throws IOException |
974 |
|
{ |
975 |
|
if (!canInsertEmpty(0)) |
976 |
|
throw new UnsupportedOperationException(); |
977 |
|
} |
978 |
|
|
979 |
|
/** |
980 |
|
* Complete replacing pixels in an image in the output stream. |
981 |
|
* |
982 |
|
* @exception IllegalStateException if output is null |
983 |
|
* @exception UnsupportedOperationException if replacing pixels is |
984 |
|
* not supported by this writer |
985 |
|
* @exception IllegalArgumentException if prepareReplacePixels was |
986 |
|
* not called before this method being called |
987 |
|
* @exception IOException if a write error occurs |
988 |
|
*/ |
989 |
|
public void endReplacePixels () |
990 |
|
throws IOException |
991 |
|
{ |
992 |
|
if (!canReplacePixels(0)) |
993 |
|
throw new UnsupportedOperationException(); |
994 |
|
} |
995 |
|
|
996 |
|
/** |
997 |
|
* Complete writing an empty image to the image output stream. |
998 |
|
* |
999 |
|
* @exception IllegalStateException if output is null |
1000 |
|
* @exception UnsupportedOperationException if writing empty images |
1001 |
|
* is not supported |
1002 |
|
* @exception IllegalArgumentException if a call to |
1003 |
|
* prepareWriteEmpty was not called previous to this method being |
1004 |
|
* called (a sequence of prepareWriteEmpty calls must be terminated |
1005 |
|
* by a call to endWriteEmpty) |
1006 |
|
* @exception IllegalArgumentException if prepareInsertEmpty was |
1007 |
|
* called before this method being called (without a terminating |
1008 |
|
* call to endInsertEmpty) |
1009 |
|
* @exception IllegalArgumentException if prepareReplacePixels was |
1010 |
|
* called before this method being called (without a terminating |
1011 |
|
* call to endReplacePixels) |
1012 |
|
* @exception IOException if a write error occurs |
1013 |
|
*/ |
1014 |
|
public void endWriteEmpty () |
1015 |
|
throws IOException |
1016 |
|
{ |
1017 |
|
if (!canWriteEmpty()) |
1018 |
|
throw new UnsupportedOperationException(); |
1019 |
|
} |
1020 |
|
|
1021 |
|
/** |
1022 |
|
* Complete writing a sequence of images to the output stream. This |
1023 |
|
* method may patch header data and write out footer data. |
1024 |
|
* |
1025 |
|
* @exception IllegalStateException if output is null |
1026 |
|
* @exception IllegalStateException if prepareWriteSequence has not |
1027 |
|
* been called |
1028 |
|
* @exception UnsupportedOperationException if writing a sequence of |
1029 |
|
* images is not supported |
1030 |
|
* @exception IOException if a write error occurs |
1031 |
|
*/ |
1032 |
|
public void endWriteSequence () |
1033 |
|
throws IOException |
1034 |
|
{ |
1035 |
|
checkOutputSet(); |
1036 |
|
if (!canWriteSequence()) |
1037 |
|
throw new UnsupportedOperationException(); |
1038 |
|
} |
1039 |
|
|
1040 |
|
/** |
1041 |
|
* Start inserting an empty image in the image output stream. All |
1042 |
|
* indices after the specified index are incremented. An index of |
1043 |
|
* -1 implies that the empty image should be appended to the end of |
1044 |
|
* the current image list. |
1045 |
|
* |
1046 |
|
* The insertion that this method call starts is not complete until |
1047 |
|
* endInsertEmpty is called. prepareInsertEmpty cannot be called |
1048 |
|
* again until endInsertEmpty is called and calls to |
1049 |
|
* prepareWriteEmpty and prepareInsertEmpty may not be intersperced. |
1050 |
|
* |
1051 |
|
* @param imageIndex the image index |
1052 |
|
* @param imageType the image type specifier |
1053 |
|
* @param width the image width |
1054 |
|
* @param height the image height |
1055 |
|
* @param imageMetadata the image metadata, or null |
1056 |
|
* @param thumbnails a list of thumbnails, or null |
1057 |
|
* @param param image write parameters, or null |
1058 |
|
* |
1059 |
|
* @exception IllegalStateException if output is null |
1060 |
|
* @exception UnsupportedOperationException if inserting empty |
1061 |
|
* images is not supported |
1062 |
|
* @exception IndexOutOfBoundsException if imageIndex is less than |
1063 |
|
* -1 or greater than the last index in the current image list |
1064 |
|
* @exception IllegalStateException if a previous call to |
1065 |
|
* prepareInsertEmpty was made (without a terminating call to |
1066 |
|
* endInsertEmpty) |
1067 |
|
* @exception IllegalStateException if a previous call to |
1068 |
|
* prepareWriteEmpty was made (without a terminating call to |
1069 |
|
* endWriteEmpty) |
1070 |
|
* @exception IllegalArgumentException if imageType is null or |
1071 |
|
* thumbnails contain non-BufferedImage objects |
1072 |
|
* @exception IllegalArgumentException if either width or height is |
1073 |
|
* less than 1 |
1074 |
|
* @exception IOException if a write error occurs |
1075 |
|
*/ |
1076 |
|
public void prepareInsertEmpty (int imageIndex, ImageTypeSpecifier imageType, |
1077 |
|
int width, int height, |
1078 |
|
IIOMetadata imageMetadata, |
1079 |
|
List thumbnails, |
1080 |
|
ImageWriteParam param) |
1081 |
|
throws IOException |
1082 |
|
{ |
1083 |
|
if (!canInsertEmpty(imageIndex)) |
1084 |
|
throw new UnsupportedOperationException(); |
1085 |
|
} |
1086 |
|
|
1087 |
|
/** |
1088 |
|
* Start the replacement of pixels within an image in the output |
1089 |
|
* stream. Output pixels will be clipped to lie within region. |
1090 |
|
* |
1091 |
|
* @param imageIndex the index of the image in which pixels are |
1092 |
|
* being replaced |
1093 |
|
* @param region the rectangle to which to limit pixel replacement |
1094 |
|
* |
1095 |
|
* @exception IllegalStateException if output is null |
1096 |
|
* @exception UnsupportedOperationException if replacing pixels is |
1097 |
|
* not supported |
1098 |
|
* @exception IndexOutOfBoundsException if imageIndex is less than 0 |
1099 |
|
* or greater than the last index in the current image list |
1100 |
|
* @exception IllegalStateException if a previous call to |
1101 |
|
* prepareReplacePixels was made (without a terminating call to |
1102 |
|
* endReplacePixels) |
1103 |
|
* @exception IllegalArgumentException if either region.width or |
1104 |
|
* region.height is less than 1, or if region is null |
1105 |
|
* @exception IOException if a write error occurs |
1106 |
|
*/ |
1107 |
|
public void prepareReplacePixels (int imageIndex, Rectangle region) |
1108 |
|
throws IOException |
1109 |
|
{ |
1110 |
|
if (canReplacePixels(imageIndex)) |
1111 |
|
throw new UnsupportedOperationException(); |
1112 |
|
} |
1113 |
|
|
1114 |
|
/** |
1115 |
|
* Start writing an empty image to the end of the image output |
1116 |
|
* stream. |
1117 |
|
* |
1118 |
|
* The writing that this method call starts is not complete until |
1119 |
|
* endWriteEmpty is called. prepareWritetEmpty cannot be called |
1120 |
|
* again until endWriteEmpty is called and calls to |
1121 |
|
* prepareWriteEmpty and prepareInsertEmpty may not be intersperced. |
1122 |
|
* |
1123 |
|
* @param streamMetadata metadata associated with the stream, or null |
1124 |
|
* @param imageType the image type specifier |
1125 |
|
* @param width the image width |
1126 |
|
* @param height the image height |
1127 |
|
* @param imageMetadata the image metadata, or null |
1128 |
|
* @param thumbnails a list of thumbnails, or null |
1129 |
|
* @param param image write parameters, or null |
1130 |
|
* |
1131 |
|
* @exception IllegalStateException if output is null |
1132 |
|
* @exception UnsupportedOperationException if writing empty images |
1133 |
|
* is not supported |
1134 |
|
* @exception IndexOutOfBoundsException if imageIndex is less than |
1135 |
|
* -1 or greater than the last index in the current image list |
1136 |
|
* @exception IllegalStateException if a previous call to |
1137 |
|
* prepareInsertEmpty was made (without a terminating call to |
1138 |
|
* endInsertEmpty) |
1139 |
|
* @exception IllegalStateException if a previous call to |
1140 |
|
* prepareWriteEmpty was made (without a terminating call to |
1141 |
|
* endWriteEmpty) |
1142 |
|
* @exception IllegalArgumentException if imageType is null or |
1143 |
|
* thumbnails contain non-BufferedImage objects |
1144 |
|
* @exception IllegalArgumentException if either width or height is |
1145 |
|
* less than 1 |
1146 |
|
* @exception IOException if a write error occurs |
1147 |
|
*/ |
1148 |
|
public void prepareWriteEmpty (IIOMetadata streamMetadata, |
1149 |
|
ImageTypeSpecifier imageType, |
1150 |
|
int width, int height, |
1151 |
|
IIOMetadata imageMetadata, |
1152 |
|
List thumbnails, |
1153 |
|
ImageWriteParam param) |
1154 |
|
throws IOException |
1155 |
|
{ |
1156 |
|
if (!canWriteEmpty()) |
1157 |
|
throw new UnsupportedOperationException(); |
1158 |
|
} |
1159 |
|
|
1160 |
|
/** |
1161 |
|
* Start the writing of a sequence of images. |
1162 |
|
* |
1163 |
|
* @param streamMetadata the stream metadata, or null |
1164 |
|
* |
1165 |
|
* @exception IllegalStateException if output is null |
1166 |
|
* @exception UnsupportedOperationException if writing sequences of |
1167 |
|
* images is not supported |
1168 |
|
* @exception IOException if a write error occurs |
1169 |
|
*/ |
1170 |
|
public void prepareWriteSequence (IIOMetadata streamMetadata) |
1171 |
|
throws IOException |
1172 |
|
{ |
1173 |
|
checkOutputSet(); |
1174 |
|
if (!canWriteSequence()) |
1175 |
|
throw new UnsupportedOperationException(); |
1176 |
|
} |
1177 |
|
|
1178 |
|
/** |
1179 |
|
* Remove the image at the specified index from the output stream. |
1180 |
|
* |
1181 |
|
* @param imageIndex the frame index from which to remove the image |
1182 |
|
* |
1183 |
|
* @exception IllegalStateException if output is null |
1184 |
|
* @exception UnsupportedOperationException if removing this image |
1185 |
|
* is not supported |
1186 |
|
* @exception IndexOutOfBoundsException if imageIndex is less than 0 |
1187 |
|
* or greater than the last index in the current image list |
1188 |
|
* @exception IOException if a write error occurs |
1189 |
|
*/ |
1190 |
|
public void removeImage (int imageIndex) |
1191 |
|
throws IOException |
1192 |
|
{ |
1193 |
|
if (!canRemoveImage(imageIndex)) |
1194 |
|
throw new UnsupportedOperationException(); |
1195 |
|
} |
1196 |
|
|
1197 |
|
/** |
1198 |
|
* Replace the metadata associated with the image at the given |
1199 |
|
* index. |
1200 |
|
* |
1201 |
|
* @param imageIndex the index of the image whose metadata should be |
1202 |
|
* replaced |
1203 |
|
* @param imageMetadata the metadata, or null |
1204 |
|
* |
1205 |
|
* @exception IllegalStateException if output is null |
1206 |
|
* @exception UnsupportedOperationException if replacing this |
1207 |
|
* image's metadata is not supported |
1208 |
|
* @exception IndexOutOfBoundsException if imageIndex is less than 0 |
1209 |
|
* or greater than the last index in the current image list |
1210 |
|
* @exception IOException if a write error occurs |
1211 |
|
*/ |
1212 |
|
public void replaceImageMetadata (int imageIndex, IIOMetadata imageMetadata) |
1213 |
|
throws IOException |
1214 |
|
{ |
1215 |
|
if (!canReplaceImageMetadata(imageIndex)) |
1216 |
|
throw new UnsupportedOperationException(); |
1217 |
|
} |
1218 |
|
|
1219 |
|
/** |
1220 |
|
* Replace a region of an image in the output stream with a portion |
1221 |
|
* of the given rendered image. The image data must be of the same |
1222 |
|
* type as that in the output stream. The destination region is |
1223 |
|
* given by the image writing parameters and the source region is |
1224 |
|
* the one given to prepareReplacePixels. |
1225 |
|
* |
1226 |
|
* @param image the rendered image with which to overwrite the image |
1227 |
|
* region in the stream |
1228 |
|
* @param param the image writing parameters |
1229 |
|
* |
1230 |
|
* @exception IllegalStateException if output is null |
1231 |
|
* @exception UnsupportedOperationException if replacing pixels is |
1232 |
|
* not supported |
1233 |
|
* @exception IllegalStateException if prepareReplacePixels was not |
1234 |
|
* called before this method was called |
1235 |
|
* @exception IllegalArgumentException if image is null or if param |
1236 |
|
* is null or if the overlap of the source and destination regions |
1237 |
|
* contains no pixels or if the image types differ and no conversion |
1238 |
|
* is possible |
1239 |
|
* @exception IOException if a write error occurs |
1240 |
|
*/ |
1241 |
|
public void replacePixels (RenderedImage image, |
1242 |
|
ImageWriteParam param) |
1243 |
|
throws IOException |
1244 |
|
{ |
1245 |
|
if (!canReplacePixels(0)) |
1246 |
|
throw new UnsupportedOperationException(); |
1247 |
|
} |
1248 |
|
|
1249 |
|
/** |
1250 |
|
* Replace a region of an image in the output stream with a portion |
1251 |
|
* of the given raster data. The image data must be of the same |
1252 |
|
* type as that in the output stream. The destination region is |
1253 |
|
* given by the image writing parameters and the source region is |
1254 |
|
* the one given to prepareReplacePixels. |
1255 |
|
* |
1256 |
|
* @param raster the raster data with which to overwrite the image |
1257 |
|
* region in the stream |
1258 |
|
* @param param the image writing parameters |
1259 |
|
* |
1260 |
|
* @exception IllegalStateException if output is null |
1261 |
|
* @exception UnsupportedOperationException if replacing pixels is |
1262 |
|
* not supported |
1263 |
|
* @exception IllegalStateException if prepareReplacePixels was not |
1264 |
|
* called before this method was called |
1265 |
|
* @exception UnsupportedOperationException if raster data is not |
1266 |
|
* supported |
1267 |
|
* @exception IllegalArgumentException if raster is null or if param |
1268 |
|
* is null or if the overlap of the source and destination regions |
1269 |
|
* contains no pixels or if the image types differ and no conversion |
1270 |
|
* is possible |
1271 |
|
* @exception IOException if a write error occurs |
1272 |
|
*/ |
1273 |
|
public void replacePixels (Raster raster, ImageWriteParam param) |
1274 |
|
throws IOException |
1275 |
|
{ |
1276 |
|
if (!canReplacePixels(0)) |
1277 |
|
throw new UnsupportedOperationException(); |
1278 |
|
} |
1279 |
|
|
1280 |
|
/** |
1281 |
|
* Replace the metadata associated with this image stream. |
1282 |
|
* |
1283 |
|
* @param streamMetadata the stream metadata, or null |
1284 |
|
* |
1285 |
|
* @exception IllegalStateException if output is null |
1286 |
|
* @exception UnsupportedOperationException if replacing the stream |
1287 |
|
* metadata is not supported |
1288 |
|
* @exception IOException if a write error occurs |
1289 |
|
*/ |
1290 |
|
public void replaceStreamMetadata (IIOMetadata streamMetadata) |
1291 |
|
throws IOException |
1292 |
|
{ |
1293 |
|
if (!canReplaceStreamMetadata()) |
1294 |
|
throw new UnsupportedOperationException(); |
1295 |
|
} |
1296 |
|
|
1297 |
|
/** |
1298 |
|
* Write a rendered image to the output stream. |
1299 |
|
* |
1300 |
|
* @param image a rendered image containing image data to be written |
1301 |
|
* |
1302 |
|
* @exception IllegalStateException if output is null |
1303 |
|
* @exception IllegalArgumentException if image is null |
1304 |
|
* @exception IOException if a write error occurs |
1305 |
|
*/ |
1306 |
|
public void write (RenderedImage image) |
1307 |
|
throws IOException |
1308 |
|
{ |
1309 |
|
checkOutputSet(); |
1310 |
|
write (null, new IIOImage(image, null, null), null); |
1311 |
|
} |
1312 |
|
|
1313 |
|
/** |
1314 |
|
* Write a image data, metadata and thumbnails to the output stream. |
1315 |
|
* |
1316 |
|
* @param image image data, metadata and thumbnails to be written |
1317 |
|
* |
1318 |
|
* @exception IllegalStateException if output is null |
1319 |
|
* @exception UnsupportedOperationException if image contains raster |
1320 |
|
* data but this writer does not support rasters |
1321 |
|
* @exception IllegalArgumentException if image is null |
1322 |
|
* @exception IOException if a write error occurs |
1323 |
|
*/ |
1324 |
|
public void write (IIOImage image) |
1325 |
|
throws IOException |
1326 |
|
{ |
1327 |
|
checkOutputSet(); |
1328 |
|
write (null, image, null); |
1329 |
|
} |
1330 |
|
|
1331 |
|
/** |
1332 |
|
* Insert an image into the output stream. Indices greater than the |
1333 |
|
* specified index are incremented accordingly. Specifying an index |
1334 |
|
* of -1 causes the image to be appended at the end of the current |
1335 |
|
* image list. |
1336 |
|
* |
1337 |
|
* @param imageIndex the frame index at which to insert the image |
1338 |
|
* @param image the image data, metadata and thumbnails to be |
1339 |
|
* inserted |
1340 |
|
* @param the image write parameters, or null |
1341 |
|
* |
1342 |
|
* @exception IllegalStateException if output is null |
1343 |
|
* @exception UnsupportedOperationException if image insertion is |
1344 |
|
* not supported |
1345 |
|
* @exception IllegalArgumentException if image is null |
1346 |
|
* @exception IndexOutOfBoundsException if imageIndex is less than |
1347 |
|
* -1 or greater than the last index in the current image list |
1348 |
|
* @exception UnsupportedOperationException if image contains raster |
1349 |
|
* data but this writer does not support rasters |
1350 |
|
* @exception IOException if a write error occurs |
1351 |
|
*/ |
1352 |
|
public void writeInsert (int imageIndex, IIOImage image, ImageWriteParam param) |
1353 |
|
throws IOException |
1354 |
|
{ |
1355 |
|
if (!canInsertImage(imageIndex)) |
1356 |
|
throw new UnsupportedOperationException(); |
1357 |
|
} |
1358 |
|
|
1359 |
|
/** |
1360 |
|
* Write a sequence of images, including thumbnails and metadata, to |
1361 |
|
* the output stream. The output must have been set prior to this |
1362 |
|
* method being called. Metadata associated with the stream may be |
1363 |
|
* supplied, or it can be left null. IIOImage may contain raster |
1364 |
|
* data if this writer supports rasters, or it will contain a |
1365 |
|
* rendered image. Thumbnails are resized if need be. Image |
1366 |
|
* writing parameters may be specified to affect writing, or may be |
1367 |
|
* left null. |
1368 |
|
* |
1369 |
|
* @param streamMetadata metadata associated with this stream, or |
1370 |
|
* null |
1371 |
|
* @param image an IIOImage containing image data, metadata and |
1372 |
|
* thumbnails to be written |
1373 |
|
* @param param image writing parameters, or null |
1374 |
|
* |
1375 |
|
* @exception IllegalStateException if output is null |
1376 |
|
* @exception UnsupportedOperationException if writing sequences of |
1377 |
|
* images is not supported |
1378 |
|
* @exception IllegalArgumentException if image is null |
1379 |
|
* @exception UnsupportedOperationException if image contains raster |
1380 |
|
* data but this writer does not support rasters |
1381 |
|
* @exception IOException if a write error occurs |
1382 |
|
*/ |
1383 |
|
public void writeToSequence (IIOImage image, ImageWriteParam param) |
1384 |
|
throws IOException |
1385 |
|
{ |
1386 |
|
if (!canWriteSequence()) |
1387 |
|
throw new UnsupportedOperationException(); |
1388 |
|
} |
1389 |
} |
} |