/*
* 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;
import javax.imageio.spi.ImageReaderSpi;
import javax.imageio.stream.ImageInputStream;
import javax.imageio.metadata.IIOMetadata;
import javax.imageio.event.IIOReadWarningListener;
import javax.imageio.event.IIOReadProgressListener;
import javax.imageio.event.IIOReadUpdateListener;
import java.util.Locale;
import java.util.List;
import java.util.Iterator;
import java.util.Set;
import java.io.IOException;
import java.awt.image.BufferedImage;
import java.awt.image.Raster;
import java.awt.image.RenderedImage;
import java.awt.*;
/**
* The ImageReader class is an abstract class for decoding images. ImageReader
* objects are instantiated by the service provider interface, ImageReaderSpi
* class, for the specific format. ImageReaderSpi class should be registered
* with the IIORegistry, which uses them for format recognition and presentation
* of available format readers and writers.
*
* @since Android 1.0
*/
public abstract class ImageReader {
/**
* The originating provider.
*/
protected ImageReaderSpi originatingProvider;
/**
* The input object such as ImageInputStream.
*/
protected Object input;
/**
* The seek forward only.
*/
protected boolean seekForwardOnly;
/**
* The ignore metadata flag indicates whether current input source has been
* marked as metadata is allowed to be ignored by setInput.
*/
protected boolean ignoreMetadata;
/**
* The minimum index.
*/
protected int minIndex;
/**
* The available locales.
*/
protected Locale[] availableLocales;
/**
* The locale.
*/
protected Locale locale;
/**
* The list of warning listeners.
*/
protected List<IIOReadWarningListener> warningListeners;
/**
* The list of warning locales.
*/
protected List<Locale> warningLocales;
/**
* The list of progress listeners.
*/
protected List<IIOReadProgressListener> progressListeners;
/**
* The list of update listeners.
*/
protected List<IIOReadUpdateListener> updateListeners;
/**
* Instantiates a new ImageReader.
*
* @param originatingProvider
* the ImageReaderSpi which instantiates this ImageReader.
*/
protected ImageReader(ImageReaderSpi originatingProvider) {
this.originatingProvider = originatingProvider;
}
/**
* Gets the format name of this input source.
*
* @return the format name of this input source.
* @throws IOException
* if an I/O exception has occurred.
*/
public String getFormatName() throws IOException {
return originatingProvider.getFormatNames()[0];
}
/**
* Gets the ImageReaderSpi which instantiated this ImageReader.
*
* @return the ImageReaderSpi.
*/
public ImageReaderSpi getOriginatingProvider() {
return originatingProvider;
}
/**
* Sets the specified Object as the input source of this ImageReader.
*
* @param input
* the input source, it can be an ImageInputStream or other
* supported objects.
* @param seekForwardOnly
* indicates whether the stream must be read sequentially from
* its current starting point.
* @param ignoreMetadata
* parameter which indicates if metadata may be ignored during
* reads or not.
*/
public void setInput(Object input, boolean seekForwardOnly, boolean ignoreMetadata) {
if (input != null) {
if (!isSupported(input) && !(input instanceof ImageInputStream)) {
throw new IllegalArgumentException("input " + input + " is not supported");
}
}
this.minIndex = 0;
this.seekForwardOnly = seekForwardOnly;
this.ignoreMetadata = ignoreMetadata;
this.input = input;
}
/**
* Checks if is supported.
*
* @param input
* the input.
* @return true, if is supported.
*/
private boolean isSupported(Object input) {
ImageReaderSpi spi = getOriginatingProvider();
if (null != spi) {
Class[] outTypes = spi.getInputTypes();
for (Class<?> element : outTypes) {
if (element.isInstance(input)) {
return true;
}
}
}
return false;
}
/**
* Sets the specified Object as the input source of this ImageReader.
* Metadata is not ignored.
*
* @param input
* the input source, it can be an ImageInputStream or other
* supported objects.
* @param seekForwardOnly
* indicates whether the stream must be read sequentially from
* its current starting point.
*/
public void setInput(Object input, boolean seekForwardOnly) {
setInput(input, seekForwardOnly, false);
}
/**
* Sets the specified Object as the input source of this ImageReader.
* Metadata is not ignored and forward seeking is not required.
*
* @param input
* the input source, it can be ImageInputStream or other objects.
*/
public void setInput(Object input) {
setInput(input, false, false);
}
/**
* Gets the input source object of this ImageReader, or returns null.
*
* @return the input source object such as ImageInputStream, or null.
*/
public Object getInput() {
return input;
}
/**
* Checks if the input source supports only forward reading, or not.
*
* @return true, if the input source supports only forward reading, false
* otherwise.
*/
public boolean isSeekForwardOnly() {
return seekForwardOnly;
}
/**
* Returns true if the current input source allows to metadata to be ignored
* by passing true as the ignoreMetadata argument to the setInput method.
*
* @return true, if the current input source allows to metadata to be
* ignored by passing true as the ignoreMetadata argument to the
* setInput method.
*/
public boolean isIgnoringMetadata() {
return ignoreMetadata;
}
/**
* Gets the minimum valid index for reading an image, thumbnail, or image
* metadata.
*
* @return the minimum valid index for reading an image, thumbnail, or image
* metadata.
*/
public int getMinIndex() {
return minIndex;
}
/**
* Gets the available locales.
*
* @return an array of the available locales.
*/
public Locale[] getAvailableLocales() {
return availableLocales;
}
/**
* Sets the locale to this ImageReader.
*
* @param locale
* the Locale.
*/
public void setLocale(Locale locale) {
throw new UnsupportedOperationException("Not implemented yet");
}
/**
* Gets the locale of this ImageReader.
*
* @return the locale of this ImageReader.
*/
public Locale getLocale() {
return locale;
}
/**
* Gets the number of images available in the current input source.
*
* @param allowSearch
* the parameter which indicates what a search is required; if
* false, the reader may return -1 without searching.
* @return the number of images.
* @throws IOException
* if an I/O exception has occurred.
*/
public abstract int getNumImages(boolean allowSearch) throws IOException;
/**
* Gets the width of the specified image in input source.
*
* @param imageIndex
* the image index.
* @return the width in pixels.
* @throws IOException
* if an I/O exception has occurred.
*/
public abstract int getWidth(int imageIndex) throws IOException;
/**
* Gets the height of the specified image in input source.
*
* @param imageIndex
* the image index.
* @return the height in pixels.
* @throws IOException
* if an I/O exception has occurred.
*/
public abstract int getHeight(int imageIndex) throws IOException;
/**
* Checks if the storage format of the specified image places an impediment
* on random pixels access or not.
*
* @param imageIndex
* the image's index.
* @return true, if the storage format of the specified image places an
* impediment on random pixels access, false otherwise.
* @throws IOException
* if an I/O exception has occurred.
*/
public boolean isRandomAccessEasy(int imageIndex) throws IOException {
return false; // def
}
/**
* Gets the aspect ratio (width devided by height) of the image.
*
* @param imageIndex
* the image index.
* @return the aspect ratio of the image.
* @throws IOException
* if an I/O exception has occurred.
*/
public float getAspectRatio(int imageIndex) throws IOException {
return (float)getWidth(imageIndex) / getHeight(imageIndex);
}
/**
* Gets an ImageTypeSpecifier which indicates the type of the specified
* image.
*
* @param imageIndex
* the image's index.
* @return the ImageTypeSpecifier.
* @throws IOException
* if an I/O exception has occurred.
*/
public ImageTypeSpecifier getRawImageType(int imageIndex) throws IOException {
throw new UnsupportedOperationException("Not implemented yet");
}
/**
* Gets an Iterator of ImageTypeSpecifier objects which are associated with
* image types that may be used when decoding specified image.
*
* @param imageIndex
* the image index.
* @return an Iterator of ImageTypeSpecifier objects.
* @throws IOException
* if an I/O exception has occurred.
*/
public abstract Iterator<ImageTypeSpecifier> getImageTypes(int imageIndex) throws IOException;
/**
* Gets the default ImageReadParam object.
*
* @return the ImageReadParam object.
*/
public ImageReadParam getDefaultReadParam() {
throw new UnsupportedOperationException("Not implemented yet");
}
/**
* Gets an IIOMetadata object for this input source.
*
* @return the IIOMetadata.
* @throws IOException
* if an I/O exception has occurred.
*/
public abstract IIOMetadata getStreamMetadata() throws IOException;
/**
* Gets an IIOMetadata object for this input source.
*
* @param formatName
* the desired metadata format to be used in the returned
* IIOMetadata object.
* @param nodeNames
* the node names of the document.
* @return the IIOMetadata.
* @throws IOException
* if an I/O exception has occurred.
*/
public IIOMetadata getStreamMetadata(String formatName, Set<String> nodeNames)
throws IOException {
throw new UnsupportedOperationException("Not implemented yet");
}
/**
* Gets the image metadata of the specified image in input source.
*
* @param imageIndex
* the image index.
* @return the IIOMetadata.
* @throws IOException
* if an I/O exception has occurred.
*/
public abstract IIOMetadata getImageMetadata(int imageIndex) throws IOException;
/**
* Gets the image metadata of the specified image input source.
*
* @param imageIndex
* the image index.
* @param formatName
* the desired metadata format to be used in the returned
* IIOMetadata object.
* @param nodeNames
* the node names which can be contained in the document.
* @return the IIOMetadata.
* @throws IOException
* if an I/O exception has occurred.
*/
public IIOMetadata getImageMetadata(int imageIndex, String formatName, Set<String> nodeNames)
throws IOException {
throw new UnsupportedOperationException("Not implemented yet");
}
/**
* Reads the specified image and returns it as a BufferedImage using the
* default ImageReadParam.
*
* @param imageIndex
* the image index.
* @return the BufferedImage.
* @throws IOException
* if an I/O exception has occurred.
*/
public BufferedImage read(int imageIndex) throws IOException {
return read(imageIndex, null);
}
/**
* Reads the specified image and returns it as a BufferedImage using the
* specified ImageReadParam.
*
* @param imageIndex
* the image index.
* @param param
* the ImageReadParam.
* @return the BufferedImage.
* @throws IOException
* if an I/O exception has occurred.
*/
public abstract BufferedImage read(int imageIndex, ImageReadParam param) throws IOException;
/**
* Reads the specified image and returns an IIOImage with this image,
* thumbnails, and metadata for this image, using the specified
* ImageReadParam.
*
* @param imageIndex
* the image index.
* @param param
* the ImageReadParam.
* @return the IIOImage.
* @throws IOException
* if an I/O exception has occurred.
*/
public IIOImage readAll(int imageIndex, ImageReadParam param) throws IOException {
throw new UnsupportedOperationException("Not implemented yet");
}
/**
* Returns an Iterator of IIOImages from the input source.
*
* @param params
* the Iterator of ImageReadParam objects.
* @return the iterator of IIOImages.
* @throws IOException
* if an I/O exception has occurred.
*/
public Iterator<IIOImage> readAll(Iterator<? extends ImageReadParam> params) throws IOException {
throw new UnsupportedOperationException("Not implemented yet");
}
/**
* Checks whether or not this plug-in supports reading a Raster.
*
* @return true, if this plug-in supports reading a Raster, false otherwise.
*/
public boolean canReadRaster() {
return false; // def
}
/**
* Reads a new Raster object which contains the raw pixel data from the
* image.
*
* @param imageIndex
* the image index.
* @param param
* the ImageReadParam.
* @return the Raster.
* @throws IOException
* if an I/O exception has occurred.
*/
public Raster readRaster(int imageIndex, ImageReadParam param) throws IOException {
throw new UnsupportedOperationException("Unsupported");
}
/**
* Checks if the specified image has tiles or not.
*
* @param imageIndex
* the image's index.
* @return true, if the specified image has tiles, false otherwise.
* @throws IOException
* if an I/O exception has occurred.
*/
public boolean isImageTiled(int imageIndex) throws IOException {
return false; // def
}
/**
* Gets the tile width in the specified image.
*
* @param imageIndex
* the image's index.
* @return the tile width.
* @throws IOException
* if an I/O exception has occurred.
*/
public int getTileWidth(int imageIndex) throws IOException {
return getWidth(imageIndex); // def
}
/**
* Gets the tile height in the specified image.
*
* @param imageIndex
* the image's index.
* @return the tile height.
* @throws IOException
* if an I/O exception has occurred.
*/
public int getTileHeight(int imageIndex) throws IOException {
return getHeight(imageIndex); // def
}
/**
* Gets the X coordinate of the upper left corner of the tile grid in the
* specified image.
*
* @param imageIndex
* the image's index.
* @return the X coordinate of the upper left corner of the tile grid.
* @throws IOException
* if an I/O exception has occurred.
*/
public int getTileGridXOffset(int imageIndex) throws IOException {
return 0; // def
}
/**
* Gets the Y coordinate of the upper left corner of the tile grid in the
* specified image.
*
* @param imageIndex
* the image's index.
* @return the Y coordinate of the upper left corner of the tile grid.
* @throws IOException
* if an I/O exception has occurred.
*/
public int getTileGridYOffset(int imageIndex) throws IOException {
return 0; // def
}
/**
* Reads the tile specified by the tileX and tileY parameters of the
* specified image and returns it as a BufferedImage.
*
* @param imageIndex
* the image index.
* @param tileX
* the X index of tile.
* @param tileY
* the Y index of tile.
* @return the BufferedImage.
* @throws IOException
* if an I/O exception has occurred.
*/
public BufferedImage readTile(int imageIndex, int tileX, int tileY) throws IOException {
throw new UnsupportedOperationException("Not implemented yet");
}
/**
* Reads the tile specified by the tileX and tileY parameters of the
* specified image and returns it as a Raster.
*
* @param imageIndex
* the image index.
* @param tileX
* the X index of tile.
* @param tileY
* the Y index of tile.
* @return the Raster.
* @throws IOException
* if an I/O exception has occurred.
*/
public Raster readTileRaster(int imageIndex, int tileX, int tileY) throws IOException {
throw new UnsupportedOperationException("Not implemented yet");
}
/**
* Reads the specified image using the specified ImageReadParam and returns
* it as a RenderedImage.
*
* @param imageIndex
* the image index.
* @param param
* the ImageReadParam.
* @return the RenderedImage.
* @throws IOException
* if an I/O exception has occurred.
*/
public RenderedImage readAsRenderedImage(int imageIndex, ImageReadParam param)
throws IOException {
return read(imageIndex, param);
}
/**
* Returns true if the image format supported by this reader supports
* thumbnail preview images.
*
* @return true, if the image format supported by this reader supports
* thumbnail preview images, false otherwise.
*/
public boolean readerSupportsThumbnails() {
return false; // def
}
/**
* Checks if the specified image has thumbnails or not.
*
* @param imageIndex
* the image's index.
* @return true, if the specified image has thumbnails, false otherwise.
* @throws IOException
* if an I/O exception has occurred.
*/
public boolean hasThumbnails(int imageIndex) throws IOException {
return getNumThumbnails(imageIndex) > 0; // def
}
/**
* Gets the number of thumbnails for the specified image.
*
* @param imageIndex
* the image's index.
* @return the number of thumbnails.
* @throws IOException
* if an I/O exception has occurred.
*/
public int getNumThumbnails(int imageIndex) throws IOException {
return 0; // def
}
/**
* Gets the width of the specified thumbnail for the specified image.
*
* @param imageIndex
* the image's index.
* @param thumbnailIndex
* the thumbnail's index.
* @return the thumbnail width.
* @throws IOException
* if an I/O exception has occurred.
*/
public int getThumbnailWidth(int imageIndex, int thumbnailIndex) throws IOException {
return readThumbnail(imageIndex, thumbnailIndex).getWidth(); // def
}
/**
* Gets the height of the specified thumbnail for the specified image.
*
* @param imageIndex
* the image's index.
* @param thumbnailIndex
* the thumbnail's index.
* @return the thumbnail height.
* @throws IOException
* if an I/O exception has occurred.
*/
public int getThumbnailHeight(int imageIndex, int thumbnailIndex) throws IOException {
return readThumbnail(imageIndex, thumbnailIndex).getHeight(); // def
}
/**
* Reads the thumbnail image for the specified image as a BufferedImage.
*
* @param imageIndex
* the image index.
* @param thumbnailIndex
* the thumbnail index.
* @return the BufferedImage.
* @throws IOException
* if an I/O exception has occurred.
*/
public BufferedImage readThumbnail(int imageIndex, int thumbnailIndex) throws IOException {
throw new UnsupportedOperationException("Unsupported"); // def
}
/**
* Requests an abort operation for current reading operation.
*/
public void abort() {
throw new UnsupportedOperationException("Not implemented yet");
}
/**
* Checks whether or not a request to abort the current read operation has
* been made successfully.
*
* @return true, if the request to abort the current read operation has been
* made successfully, false otherwise.
*/
protected boolean abortRequested() {
throw new UnsupportedOperationException("Not implemented yet");
}
/**
* Clears all previous abort request, and abortRequested returns false after
* calling this method.
*/
protected void clearAbortRequest() {
throw new UnsupportedOperationException("Not implemented yet");
}
/**
* Adds the IIOReadWarningListener.
*
* @param listener
* the IIOReadWarningListener.
*/
public void addIIOReadWarningListener(IIOReadWarningListener listener) {
throw new UnsupportedOperationException("Not implemented yet");
}
/**
* Removes the specified IIOReadWarningListener.
*
* @param listener
* the IIOReadWarningListener to be removed.
*/
public void removeIIOReadWarningListener(IIOReadWarningListener listener) {
throw new UnsupportedOperationException("Not implemented yet");
}
/**
* Removes all registered IIOReadWarningListeners.
*/
public void removeAllIIOReadWarningListeners() {
throw new UnsupportedOperationException("Not implemented yet");
}
/**
* Adds the IIOReadProgressListener.
*
* @param listener
* the IIOReadProgressListener.
*/
public void addIIOReadProgressListener(IIOReadProgressListener listener) {
throw new UnsupportedOperationException("Not implemented yet");
}
/**
* Removes the specified IIOReadProgressListener.
*
* @param listener
* the IIOReadProgressListener to be removed.
*/
public void removeIIOReadProgressListener(IIOReadProgressListener listener) {
throw new UnsupportedOperationException("Not implemented yet");
}
/**
* Removes registered IIOReadProgressListeners.
*/
public void removeAllIIOReadProgressListeners() {
throw new UnsupportedOperationException("Not implemented yet");
}
/**
* Adds the IIOReadUpdateListener.
*
* @param listener
* the IIOReadUpdateListener.
*/
public void addIIOReadUpdateListener(IIOReadUpdateListener listener) {
throw new UnsupportedOperationException("Not implemented yet");
}
/**
* Removes the specified IIOReadUpdateListener.
*
* @param listener
* the IIOReadUpdateListener to be removed.
*/
public void removeIIOReadUpdateListener(IIOReadUpdateListener listener) {
throw new UnsupportedOperationException("Not implemented yet");
}
/**
* Removes registered IIOReadUpdateListeners.
*/
public void removeAllIIOReadUpdateListeners() {
throw new UnsupportedOperationException("Not implemented yet");
}
/**
* Processes the start of an sequence of image reads by calling the
* sequenceStarted method on all registered IIOReadProgressListeners.
*
* @param minIndex
* the minimum index.
*/
protected void processSequenceStarted(int minIndex) {
throw new UnsupportedOperationException("Not implemented yet");
}
/**
* Processes the completion of an sequence of image reads by calling
* sequenceComplete method on all registered IIOReadProgressListeners.
*/
protected void processSequenceComplete() {
throw new UnsupportedOperationException("Not implemented yet");
}
/**
* Processes the start of an image read by calling the imageStarted method
* on all registered IIOReadProgressListeners.
*
* @param imageIndex
* the image index.
*/
protected void processImageStarted(int imageIndex) {
throw new UnsupportedOperationException("Not implemented yet");
}
/**
* Processes the current percentage of image completion by calling the
* imageProgress method on all registered IIOReadProgressListeners.
*
* @param percentageDone
* the percentage done.
*/
protected void processImageProgress(float percentageDone) {
throw new UnsupportedOperationException("Not implemented yet");
}
/**
* Processes image completion by calling the imageComplete method on all
* registered IIOReadProgressListeners.
*/
protected void processImageComplete() {
throw new UnsupportedOperationException("Not implemented yet");
}
/**
* Processes the start of a thumbnail read by calling the thumbnailStarted
* method on all registered IIOReadProgressListeners.
*
* @param imageIndex
* the image index.
* @param thumbnailIndex
* the thumbnail index.
*/
protected void processThumbnailStarted(int imageIndex, int thumbnailIndex) {
throw new UnsupportedOperationException("Not implemented yet");
}
/**
* Processes the current percentage of thumbnail completion by calling the
* thumbnailProgress method on all registered IIOReadProgressListeners.
*
* @param percentageDone
* the percentage done.
*/
protected void processThumbnailProgress(float percentageDone) {
throw new UnsupportedOperationException("Not implemented yet");
}
/**
* Processes the completion of a thumbnail read by calling the
* thumbnailComplete method on all registered IIOReadProgressListeners.
*/
protected void processThumbnailComplete() {
throw new UnsupportedOperationException("Not implemented yet");
}
/**
* Processes a read aborted event by calling the readAborted method on all
* registered IIOReadProgressListeners.
*/
protected void processReadAborted() {
throw new UnsupportedOperationException("Not implemented yet");
}
/**
* Processes the beginning of a progressive pass by calling the passStarted
* method on all registered IIOReadUpdateListeners.
*
* @param theImage
* the image to be updated.
* @param pass
* the current pass index.
* @param minPass
* the minimum pass index.
* @param maxPass
* the maximum pass index.
* @param minX
* the X coordinate of of the upper left pixel.
* @param minY
* the Y coordinate of of the upper left pixel.
* @param periodX
* the horizontal separation between pixels.
* @param periodY
* the vertical separation between pixels.
* @param bands
* the number of affected bands.
*/
protected void processPassStarted(BufferedImage theImage, int pass, int minPass, int maxPass,
int minX, int minY, int periodX, int periodY, int[] bands) {
throw new UnsupportedOperationException("Not implemented yet");
}
/**
* Processes the update of a set of samples by calling the imageUpdate
* method on all registered IIOReadUpdateListeners.
*
* @param theImage
* the image to be updated.
* @param minX
* the X coordinate of the upper left pixel.
* @param minY
* the Y coordinate of the upper left pixel.
* @param width
* the width of updated area.
* @param height
* the height of updated area.
* @param periodX
* the horizontal separation between pixels.
* @param periodY
* the vertical separation between pixels.
* @param bands
* the number of affected bands.
*/
protected void processImageUpdate(BufferedImage theImage, int minX, int minY, int width,
int height, int periodX, int periodY, int[] bands) {
throw new UnsupportedOperationException("Not implemented yet");
}
/**
* Processes the end of a progressive pass by calling passComplete method of
* registered IIOReadUpdateListeners.
*
* @param theImage
* the image to be updated.
*/
protected void processPassComplete(BufferedImage theImage) {
throw new UnsupportedOperationException("Not implemented yet");
}
/**
* Processes the beginning of a thumbnail progressive pass by calling the
* thumbnailPassStarted method on all registered IIOReadUpdateListeners.
*
* @param theThumbnail
* the thumbnail to be updated.
* @param pass
* the current pass index.
* @param minPass
* the minimum pass index.
* @param maxPass
* the maximum pass index.
* @param minX
* the X coordinate of the upper left pixel.
* @param minY
* the Y coordinate of the upper left pixel.
* @param periodX
* the horizontal separation between pixels.
* @param periodY
* the vertical separation between pixels.
* @param bands
* the number of affected bands.
*/
protected void processThumbnailPassStarted(BufferedImage theThumbnail, int pass, int minPass,
int maxPass, int minX, int minY, int periodX, int periodY, int[] bands) {
throw new UnsupportedOperationException("Not implemented yet");
}
/**
* Processes the update of a set of samples in a thumbnail image by calling
* the thumbnailUpdate method on all registered IIOReadUpdateListeners.
*
* @param theThumbnail
* the thumbnail to be updated.
* @param minX
* the X coordinate of the upper left pixel.
* @param minY
* the Y coordinate of the upper left pixel.
* @param width
* the total width of the updated area.
* @param height
* the total height of the updated area.
* @param periodX
* the horizontal separation between pixels.
* @param periodY
* the vertical separation between pixels.
* @param bands
* the number of affected bands.
*/
protected void processThumbnailUpdate(BufferedImage theThumbnail, int minX, int minY,
int width, int height, int periodX, int periodY, int[] bands) {
throw new UnsupportedOperationException("Not implemented yet");
}
/**
* Processes the end of a thumbnail progressive pass by calling the
* thumbnailPassComplete method on all registered IIOReadUpdateListeners.
*
* @param theThumbnail
* the thumbnail to be updated.
*/
protected void processThumbnailPassComplete(BufferedImage theThumbnail) {
throw new UnsupportedOperationException("Not implemented yet");
}
/**
* Processes a warning message by calling warningOccurred method of
* registered IIOReadWarningListeners.
*
* @param warning
* the warning.
*/
protected void processWarningOccurred(String warning) {
throw new UnsupportedOperationException("Not implemented yet");
}
/**
* Processes a warning by calling the warningOccurred method of on all
* registered IIOReadWarningListeners.
*
* @param baseName
* the base name of ResourceBundles.
* @param keyword
* the keyword to index the warning among ResourceBundles.
*/
protected void processWarningOccurred(String baseName, String keyword) {
throw new UnsupportedOperationException("Not implemented yet");
}
/**
* Resets this ImageReader.
*/
public void reset() {
// def
setInput(null, false);
setLocale(null);
removeAllIIOReadUpdateListeners();
removeAllIIOReadWarningListeners();
removeAllIIOReadProgressListeners();
clearAbortRequest();
}
/**
* Disposes of any resources.
*/
public void dispose() {
// do nothing by def
}
/**
* Gets the region of source image that should be read with the specified
* width, height and ImageReadParam.
*
* @param param
* the ImageReadParam object, or null.
* @param srcWidth
* the source image's width.
* @param srcHeight
* the source image's height.
* @return the Rectangle of source region.
*/
protected static Rectangle getSourceRegion(ImageReadParam param, int srcWidth, int srcHeight) {
throw new UnsupportedOperationException("Not implemented yet");
}
/**
* Computes the specified source region and the specified destination region
* with the specified the width and height of the source image, an optional
* destination image, and an ImageReadParam.
*
* @param param
* the an ImageReadParam object, or null.
* @param srcWidth
* the source image's width.
* @param srcHeight
* the source image's height.
* @param image
* the destination image.
* @param srcRegion
* the source region.
* @param destRegion
* the destination region.
*/
protected static void computeRegions(ImageReadParam param, int srcWidth, int srcHeight,
BufferedImage image, Rectangle srcRegion, Rectangle destRegion) {
throw new UnsupportedOperationException("Not implemented yet");
}
/**
* Checks the validity of the source and destination band and is called when
* the reader knows the number of bands of the source image and the number
* of bands of the destination image.
*
* @param param
* the ImageReadParam for reading the Image.
* @param numSrcBands
* the number of bands in the source.
* @param numDstBands
* the number of bands in the destination.
*/
protected static void checkReadParamBandSettings(ImageReadParam param, int numSrcBands,
int numDstBands) {
throw new UnsupportedOperationException("Not implemented yet");
}
/**
* Gets the destination image where the decoded data is written.
*
* @param param
* the ImageReadParam.
* @param imageTypes
* the iterator of ImageTypeSpecifier objects.
* @param width
* the width of the image being decoded.
* @param height
* the height of the image being decoded.
* @return the BufferedImage where decoded pixels should be written.
* @throws IIOException
* the IIOException is thrown if there is no suitable
* ImageTypeSpecifier.
*/
protected static BufferedImage getDestination(ImageReadParam param,
Iterator<ImageTypeSpecifier> imageTypes, int width, int height) throws IIOException {
throw new UnsupportedOperationException("Not implemented yet");
}
}