awt/javax/imageio/ImageReader.java

/*
 *  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");
    }
}