1:
37:
38:
39: package ;
40:
41: import ;
42: import ;
43: import ;
44: import ;
45: import ;
46: import ;
47: import ;
48:
49: import ;
50: import ;
51: import ;
52: import ;
53: import ;
54: import ;
55:
56: public abstract class ImageReader
57: {
58: private boolean aborted;
59:
60: protected Locale[] availableLocales;
61: protected boolean ignoreMetadata;
62: protected Object input;
63: protected Locale locale;
64: protected int minIndex;
65: protected ImageReaderSpi originatingProvider;
66: protected List progressListeners = new ArrayList();
67: protected boolean seekForwardOnly;
68: protected List updateListeners = new ArrayList();
69: protected List warningListeners = new ArrayList();
70: protected List warningLocales = new ArrayList();
71:
72: protected ImageReader(ImageReaderSpi originatingProvider)
73: {
74: this.originatingProvider = originatingProvider;
75: }
76:
77: public void abort()
78: {
79: aborted = true;
80: }
81:
82: protected boolean abortRequested()
83: {
84: return aborted;
85: }
86:
87: public void addIIOReadProgressListener(IIOReadProgressListener listener)
88: {
89: if (listener == null)
90: return;
91:
92: progressListeners.add(listener);
93: }
94:
95: public void addIIOReadUpdateListener(IIOReadUpdateListener listener)
96: {
97: if (listener == null)
98: return;
99:
100: updateListeners.add(listener);
101: }
102:
103: public void addIIOReadWarningListener(IIOReadWarningListener listener)
104: {
105: if (listener == null)
106: return;
107:
108: warningListeners.add(listener);
109: }
110:
111: public boolean canReadRaster()
112: {
113: return false;
114: }
115:
116: protected void clearAbortRequest()
117: {
118: aborted = false;
119: }
120:
121: public void dispose()
122: {
123:
124: }
125:
126: public float getAspectRatio(int imageIndex)
127: throws IOException
128: {
129: return (float) (getWidth(imageIndex) / getHeight(imageIndex));
130: }
131:
132: public Locale[] getAvailableLocales()
133: {
134: if (availableLocales == null)
135: return null;
136:
137: return (Locale[]) availableLocales.clone();
138: }
139:
140: public ImageReadParam getDefaultReadParam()
141: {
142: return new ImageReadParam();
143: }
144:
145: public String getFormatName()
146: throws IOException
147: {
148: return originatingProvider.getFormatNames()[0];
149: }
150:
151: public abstract int getHeight(int imageIndex)
152: throws IOException;
153:
154: public abstract IIOMetadata getImageMetadata(int imageIndex)
155: throws IOException;
156:
157: public abstract Iterator getImageTypes(int imageIndex)
158: throws IOException;
159:
160: public void setInput(Object input,
161: boolean seekForwardOnly,
162: boolean ignoreMetadata)
163: {
164: Class[] okClasses = originatingProvider.getInputTypes();
165: if (okClasses == null)
166: {
167: if (!(input instanceof ImageInputStream))
168: throw new IllegalArgumentException();
169: }
170: else
171: {
172: boolean classOk = false;
173: for (int i = 0; i < okClasses.length; ++i)
174: if (okClasses[i].isInstance(input))
175: classOk = true;
176: if (!classOk)
177: throw new IllegalArgumentException();
178: }
179:
180: this.input = input;
181: this.seekForwardOnly = seekForwardOnly;
182: this.ignoreMetadata = ignoreMetadata;
183: this.minIndex = 0;
184: }
185:
186: public void setInput(Object in, boolean seekForwardOnly)
187: {
188: setInput(in, seekForwardOnly, false);
189: }
190:
191: public void setInput(Object in)
192: {
193: setInput(in, false, false);
194: }
195:
196: public Object getInput()
197: {
198: return input;
199: }
200:
201: public Locale getLocale()
202: {
203: return locale;
204: }
205:
206: public abstract int getNumImages(boolean allowSearch)
207: throws IOException;
208:
209: public int getNumThumbnails(int imageIndex)
210: throws IOException
211: {
212: return 0;
213: }
214:
215: public ImageReaderSpi getOriginatingProvider()
216: {
217: return originatingProvider;
218: }
219:
220: public abstract IIOMetadata getStreamMetadata()
221: throws IOException;
222:
223: public int getThumbnailHeight(int imageIndex, int thumbnailIndex)
224: throws IOException
225: {
226: return readThumbnail(imageIndex, thumbnailIndex).getHeight();
227: }
228:
229: public int getThumbnailWidth(int imageIndex, int thumbnailIndex)
230: throws IOException
231: {
232: return readThumbnail(imageIndex, thumbnailIndex).getWidth();
233: }
234:
235: public int getTileGridXOffset(int imageIndex)
236: throws IOException
237: {
238: return 0;
239: }
240:
241: public int getTileGridYOffset(int imageIndex)
242: throws IOException
243: {
244: return 0;
245: }
246:
247: public int getTileHeight(int imageIndex)
248: throws IOException
249: {
250: return getHeight(imageIndex);
251: }
252:
253: public int getTileWidth(int imageIndex)
254: throws IOException
255: {
256: return getWidth(imageIndex);
257: }
258:
259: public abstract int getWidth(int imageIndex)
260: throws IOException;
261:
262: public boolean hasThumbnails(int imageIndex)
263: throws IOException
264: {
265: return getNumThumbnails(imageIndex) > 0;
266: }
267:
268: public boolean isIgnoringMetadata()
269: {
270: return ignoreMetadata;
271: }
272:
273: public boolean isImageTiled(int imageIndex)
274: throws IOException
275: {
276: return false;
277: }
278:
279: public boolean isRandomAccessEasy(int imageIndex)
280: throws IOException
281: {
282: return false;
283: }
284:
285: public boolean isSeekForwardOnly()
286: {
287: return seekForwardOnly;
288: }
289:
290: protected void processImageComplete()
291: {
292: Iterator it = progressListeners.iterator();
293:
294: while (it.hasNext())
295: {
296: IIOReadProgressListener listener = (IIOReadProgressListener) it.next();
297: listener.imageComplete (this);
298: }
299: }
300:
301: protected void processImageProgress(float percentageDone)
302: {
303: Iterator it = progressListeners.iterator();
304:
305: while (it.hasNext())
306: {
307: IIOReadProgressListener listener = (IIOReadProgressListener) it.next();
308: listener.imageProgress(this, percentageDone);
309: }
310: }
311:
312: protected void processImageStarted(int imageIndex)
313: {
314: Iterator it = progressListeners.iterator();
315:
316: while (it.hasNext())
317: {
318: IIOReadProgressListener listener = (IIOReadProgressListener) it.next();
319: listener.imageStarted(this, imageIndex);
320: }
321: }
322:
323: protected void processImageUpdate(BufferedImage image, int minX, int minY,
324: int width, int height, int periodX,
325: int periodY, int[] bands)
326: {
327: Iterator it = updateListeners.iterator();
328:
329: while (it.hasNext())
330: {
331: IIOReadUpdateListener listener = (IIOReadUpdateListener) it.next();
332: listener.imageUpdate(this, image, minX, minY, width, height, periodX,
333: periodY, bands);
334: }
335: }
336:
337: protected void processPassComplete(BufferedImage image)
338: {
339: Iterator it = updateListeners.iterator();
340:
341: while (it.hasNext())
342: {
343: IIOReadUpdateListener listener = (IIOReadUpdateListener) it.next();
344: listener.passComplete(this, image);
345: }
346: }
347:
348: protected void processPassStarted(BufferedImage image, int pass, int minPass,
349: int maxPass, int minX, int minY,
350: int periodX, int periodY, int[] bands)
351: {
352: Iterator it = updateListeners.iterator();
353:
354: while (it.hasNext())
355: {
356: IIOReadUpdateListener listener = (IIOReadUpdateListener) it.next();
357: listener.passStarted(this, image, pass, minPass, maxPass, minX, minY,
358: periodX, periodY, bands);
359: }
360: }
361:
362: protected void processReadAborted()
363: {
364: Iterator it = progressListeners.iterator();
365:
366: while (it.hasNext())
367: {
368: IIOReadProgressListener listener = (IIOReadProgressListener) it.next();
369: listener.readAborted(this);
370: }
371: }
372:
373: protected void processSequenceComplete()
374: {
375: Iterator it = progressListeners.iterator();
376:
377: while (it.hasNext())
378: {
379: IIOReadProgressListener listener = (IIOReadProgressListener) it.next();
380: listener.sequenceComplete(this);
381: }
382: }
383:
384: protected void processSequenceStarted(int minIndex)
385: {
386: Iterator it = progressListeners.iterator();
387:
388: while (it.hasNext())
389: {
390: IIOReadProgressListener listener = (IIOReadProgressListener) it.next();
391: listener.sequenceStarted(this, minIndex);
392: }
393: }
394:
395: protected void processThumbnailComplete()
396: {
397: Iterator it = progressListeners.iterator();
398:
399: while (it.hasNext())
400: {
401: IIOReadProgressListener listener = (IIOReadProgressListener) it.next();
402: listener.thumbnailComplete(this);
403: }
404: }
405:
406: protected void processThumbnailPassComplete(BufferedImage thumbnail)
407: {
408: Iterator it = updateListeners.iterator();
409:
410: while (it.hasNext())
411: {
412: IIOReadUpdateListener listener = (IIOReadUpdateListener) it.next();
413: listener.thumbnailPassComplete(this, thumbnail);
414: }
415: }
416:
417: protected void processThumbnailPassStarted(BufferedImage thumbnail, int pass,
418: int minPass, int maxPass, int minX,
419: int minY, int periodX, int periodY,
420: int[] bands)
421: {
422: Iterator it = updateListeners.iterator();
423:
424: while (it.hasNext())
425: {
426: IIOReadUpdateListener listener = (IIOReadUpdateListener) it.next();
427: listener.thumbnailPassStarted(this, thumbnail, pass, minPass, maxPass,
428: minX, minY, periodX, periodY, bands);
429: }
430: }
431:
432: protected void processThumbnailProgress(float percentageDone)
433: {
434: Iterator it = progressListeners.iterator();
435:
436: while (it.hasNext())
437: {
438: IIOReadProgressListener listener = (IIOReadProgressListener) it.next();
439: listener.thumbnailProgress(this, percentageDone);
440: }
441: }
442:
443: protected void processThumbnailStarted(int imageIndex, int thumbnailIndex)
444: {
445: Iterator it = progressListeners.iterator();
446:
447: while (it.hasNext())
448: {
449: IIOReadProgressListener listener = (IIOReadProgressListener) it.next();
450: listener.thumbnailStarted(this, imageIndex, thumbnailIndex);
451: }
452: }
453:
454: protected void processThumbnailUpdate(BufferedImage image, int minX, int minY,
455: int width, int height, int periodX,
456: int periodY, int[] bands)
457: {
458: Iterator it = updateListeners.iterator();
459:
460: while (it.hasNext())
461: {
462: IIOReadUpdateListener listener = (IIOReadUpdateListener) it.next();
463: listener.thumbnailUpdate(this, image, minX, minY, width, height,
464: periodX, periodY, bands);
465: }
466: }
467:
468: protected void processWarningOccurred(String warning)
469: {
470: Iterator it = warningListeners.iterator();
471:
472: while (it.hasNext())
473: {
474: IIOReadWarningListener listener = (IIOReadWarningListener) it.next();
475: listener.warningOccurred(this, warning);
476: }
477: }
478:
479: public abstract BufferedImage read(int imageIndex, ImageReadParam param)
480: throws IOException;
481:
482: public boolean readerSupportsThumbnails()
483: {
484: return false;
485: }
486:
487: public Raster readRaster(int imageIndex, ImageReadParam param)
488: throws IOException
489: {
490: throw new UnsupportedOperationException();
491: }
492:
493: public BufferedImage readThumbnail(int imageIndex, int thumbnailIndex)
494: throws IOException
495: {
496: throw new UnsupportedOperationException();
497: }
498:
499: public void removeAllIIOReadProgressListeners()
500: {
501: progressListeners.clear();
502: }
503:
504: public void removeAllIIOReadUpdateListeners()
505: {
506: updateListeners.clear();
507: }
508:
509: public void removeAllIIOReadWarningListeners()
510: {
511: warningListeners.clear();
512: }
513:
514: public void removeIIOReadProgressListener(IIOReadProgressListener listener)
515: {
516: if (listener == null)
517: return;
518:
519: progressListeners.remove(listener);
520: }
521:
522: public void removeIIOReadUpdateListener(IIOReadUpdateListener listener)
523: {
524: if (listener == null)
525: return;
526:
527: updateListeners.remove(listener);
528: }
529:
530: public void removeIIOReadWarningListener(IIOReadWarningListener listener)
531: {
532: if (listener == null)
533: return;
534:
535: warningListeners.remove(listener);
536: }
537:
538: public void setLocale(Locale locale)
539: {
540: if (locale != null)
541: {
542:
543: boolean found = false;
544:
545: if (availableLocales != null)
546: for (int i = availableLocales.length - 1; i >= 0; --i)
547: if (availableLocales[i].equals(locale))
548: found = true;
549:
550: if (! found)
551: throw new IllegalArgumentException("looale not available");
552: }
553:
554: this.locale = locale;
555: }
556: }