mirror of
https://github.com/openjdk/jdk.git
synced 2026-02-24 17:20:06 +00:00
510 lines
19 KiB
Java
510 lines
19 KiB
Java
/*
|
|
* Copyright (c) 1999, 2014, Oracle and/or its affiliates. All rights reserved.
|
|
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
*
|
|
* This code is free software; you can redistribute it and/or modify it
|
|
* under the terms of the GNU General Public License version 2 only, as
|
|
* published by the Free Software Foundation. Oracle designates this
|
|
* particular file as subject to the "Classpath" exception as provided
|
|
* by Oracle in the LICENSE file that accompanied this code.
|
|
*
|
|
* This code is distributed in the hope that it will be useful, but WITHOUT
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
* version 2 for more details (a copy is included in the LICENSE file that
|
|
* accompanied this code).
|
|
*
|
|
* You should have received a copy of the GNU General Public License version
|
|
* 2 along with this work; if not, write to the Free Software Foundation,
|
|
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
*
|
|
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
|
* or visit www.oracle.com if you need additional information or have any
|
|
* questions.
|
|
*/
|
|
|
|
package javax.imageio;
|
|
|
|
import java.awt.Dimension;
|
|
import java.awt.image.BufferedImage;
|
|
|
|
/**
|
|
* A class describing how a stream is to be decoded. Instances of
|
|
* this class or its subclasses are used to supply prescriptive
|
|
* "how-to" information to instances of {@code ImageReader}.
|
|
*
|
|
* <p> An image encoded as part of a file or stream may be thought of
|
|
* extending out in multiple dimensions: the spatial dimensions of
|
|
* width and height, a number of bands, and a number of progressive
|
|
* decoding passes. This class allows a contiguous (hyper)rectangular
|
|
* subarea of the image in all of these dimensions to be selected for
|
|
* decoding. Additionally, the spatial dimensions may be subsampled
|
|
* discontinuously. Finally, color and format conversions may be
|
|
* specified by controlling the {@code ColorModel} and
|
|
* {@code SampleModel} of the destination image, either by
|
|
* providing a {@code BufferedImage} or by using an
|
|
* {@code ImageTypeSpecifier}.
|
|
*
|
|
* <p> An {@code ImageReadParam} object is used to specify how an
|
|
* image, or a set of images, will be converted on input from
|
|
* a stream in the context of the Java Image I/O framework. A plug-in for a
|
|
* specific image format will return instances of
|
|
* {@code ImageReadParam} from the
|
|
* {@code getDefaultReadParam} method of its
|
|
* {@code ImageReader} implementation.
|
|
*
|
|
* <p> The state maintained by an instance of
|
|
* {@code ImageReadParam} is independent of any particular image
|
|
* being decoded. When actual decoding takes place, the values set in
|
|
* the read param are combined with the actual properties of the image
|
|
* being decoded from the stream and the destination
|
|
* {@code BufferedImage} that will receive the decoded pixel
|
|
* data. For example, the source region set using
|
|
* {@code setSourceRegion} will first be intersected with the
|
|
* actual valid source area. The result will be translated by the
|
|
* value returned by {@code getDestinationOffset}, and the
|
|
* resulting rectangle intersected with the actual valid destination
|
|
* area to yield the destination area that will be written.
|
|
*
|
|
* <p> The parameters specified by an {@code ImageReadParam} are
|
|
* applied to an image as follows. First, if a rendering size has
|
|
* been set by {@code setSourceRenderSize}, the entire decoded
|
|
* image is rendered at the size given by
|
|
* {@code getSourceRenderSize}. Otherwise, the image has its
|
|
* natural size given by {@code ImageReader.getWidth} and
|
|
* {@code ImageReader.getHeight}.
|
|
*
|
|
* <p> Next, the image is clipped against the source region
|
|
* specified by {@code getSourceXOffset}, {@code getSourceYOffset},
|
|
* {@code getSourceWidth}, and {@code getSourceHeight}.
|
|
*
|
|
* <p> The resulting region is then subsampled according to the
|
|
* factors given in {@link IIOParam#setSourceSubsampling
|
|
* IIOParam.setSourceSubsampling}. The first pixel,
|
|
* the number of pixels per row, and the number of rows all depend
|
|
* on the subsampling settings.
|
|
* Call the minimum X and Y coordinates of the resulting rectangle
|
|
* ({@code minX}, {@code minY}), its width {@code w}
|
|
* and its height {@code h}.
|
|
*
|
|
* <p> This rectangle is offset by
|
|
* ({@code getDestinationOffset().x},
|
|
* {@code getDestinationOffset().y}) and clipped against the
|
|
* destination bounds. If no destination image has been set, the
|
|
* destination is defined to have a width of
|
|
* {@code getDestinationOffset().x} + {@code w}, and a
|
|
* height of {@code getDestinationOffset().y} + {@code h} so
|
|
* that all pixels of the source region may be written to the
|
|
* destination.
|
|
*
|
|
* <p> Pixels that land, after subsampling, within the destination
|
|
* image, and that are written in one of the progressive passes
|
|
* specified by {@code getSourceMinProgressivePass} and
|
|
* {@code getSourceNumProgressivePasses} are passed along to the
|
|
* next step.
|
|
*
|
|
* <p> Finally, the source samples of each pixel are mapped into
|
|
* destination bands according to the algorithm described in the
|
|
* comment for {@code setDestinationBands}.
|
|
*
|
|
* <p> Plug-in writers may extend the functionality of
|
|
* {@code ImageReadParam} by providing a subclass that implements
|
|
* additional, plug-in specific interfaces. It is up to the plug-in
|
|
* to document what interfaces are available and how they are to be
|
|
* used. Readers will silently ignore any extended features of an
|
|
* {@code ImageReadParam} subclass of which they are not aware.
|
|
* Also, they may ignore any optional features that they normally
|
|
* disable when creating their own {@code ImageReadParam}
|
|
* instances via {@code getDefaultReadParam}.
|
|
*
|
|
* <p> Note that unless a query method exists for a capability, it must
|
|
* be supported by all {@code ImageReader} implementations
|
|
* (<i>e.g.</i> source render size is optional, but subsampling must be
|
|
* supported).
|
|
*
|
|
*
|
|
* @see ImageReader
|
|
* @see ImageWriter
|
|
* @see ImageWriteParam
|
|
*/
|
|
public class ImageReadParam extends IIOParam {
|
|
|
|
/**
|
|
* {@code true} if this {@code ImageReadParam} allows
|
|
* the source rendering dimensions to be set. By default, the
|
|
* value is {@code false}. Subclasses must set this value
|
|
* manually.
|
|
*
|
|
* <p> {@code ImageReader}s that do not support setting of
|
|
* the source render size should set this value to
|
|
* {@code false}.
|
|
*/
|
|
protected boolean canSetSourceRenderSize = false;
|
|
|
|
/**
|
|
* The desired rendering width and height of the source, if
|
|
* {@code canSetSourceRenderSize} is {@code true}, or
|
|
* {@code null}.
|
|
*
|
|
* <p> {@code ImageReader}s that do not support setting of
|
|
* the source render size may ignore this value.
|
|
*/
|
|
protected Dimension sourceRenderSize = null;
|
|
|
|
/**
|
|
* The current destination {@code BufferedImage}, or
|
|
* {@code null} if none has been set. By default, the value
|
|
* is {@code null}.
|
|
*/
|
|
protected BufferedImage destination = null;
|
|
|
|
/**
|
|
* The set of destination bands to be used, as an array of
|
|
* {@code int}s. By default, the value is {@code null},
|
|
* indicating all destination bands should be written in order.
|
|
*/
|
|
protected int[] destinationBands = null;
|
|
|
|
/**
|
|
* The minimum index of a progressive pass to read from the
|
|
* source. By default, the value is set to 0, which indicates
|
|
* that passes starting with the first available pass should be
|
|
* decoded.
|
|
*
|
|
* <p> Subclasses should ensure that this value is
|
|
* non-negative.
|
|
*/
|
|
protected int minProgressivePass = 0;
|
|
|
|
/**
|
|
* The maximum number of progressive passes to read from the
|
|
* source. By default, the value is set to
|
|
* {@code Integer.MAX_VALUE}, which indicates that passes up
|
|
* to and including the last available pass should be decoded.
|
|
*
|
|
* <p> Subclasses should ensure that this value is positive.
|
|
* Additionally, if the value is not
|
|
* {@code Integer.MAX_VALUE}, then
|
|
* {@code minProgressivePass + numProgressivePasses - 1}
|
|
* should not exceed
|
|
* {@code Integer.MAX_VALUE}.
|
|
*/
|
|
protected int numProgressivePasses = Integer.MAX_VALUE;
|
|
|
|
/**
|
|
* Constructs an {@code ImageReadParam}.
|
|
*/
|
|
public ImageReadParam() {}
|
|
|
|
// Comment inherited
|
|
public void setDestinationType(ImageTypeSpecifier destinationType) {
|
|
super.setDestinationType(destinationType);
|
|
setDestination(null);
|
|
}
|
|
|
|
/**
|
|
* Supplies a {@code BufferedImage} to be used as the
|
|
* destination for decoded pixel data. The currently set image
|
|
* will be written to by the {@code read},
|
|
* {@code readAll}, and {@code readRaster} methods, and
|
|
* a reference to it will be returned by those methods.
|
|
*
|
|
* <p> Pixel data from the aforementioned methods will be written
|
|
* starting at the offset specified by
|
|
* {@code getDestinationOffset}.
|
|
*
|
|
* <p> If {@code destination} is {@code null}, a
|
|
* newly-created {@code BufferedImage} will be returned by
|
|
* those methods.
|
|
*
|
|
* <p> At the time of reading, the image is checked to verify that
|
|
* its {@code ColorModel} and {@code SampleModel}
|
|
* correspond to one of the {@code ImageTypeSpecifier}s
|
|
* returned from the {@code ImageReader}'s
|
|
* {@code getImageTypes} method. If it does not, the reader
|
|
* will throw an {@code IIOException}.
|
|
*
|
|
* @param destination the BufferedImage to be written to, or
|
|
* {@code null}.
|
|
*
|
|
* @see #getDestination
|
|
*/
|
|
public void setDestination(BufferedImage destination) {
|
|
this.destination = destination;
|
|
}
|
|
|
|
/**
|
|
* Returns the {@code BufferedImage} currently set by the
|
|
* {@code setDestination} method, or {@code null}
|
|
* if none is set.
|
|
*
|
|
* @return the BufferedImage to be written to.
|
|
*
|
|
* @see #setDestination
|
|
*/
|
|
public BufferedImage getDestination() {
|
|
return destination;
|
|
}
|
|
|
|
/**
|
|
* Sets the indices of the destination bands where data
|
|
* will be placed. Duplicate indices are not allowed.
|
|
*
|
|
* <p> A {@code null} value indicates that all destination
|
|
* bands will be used.
|
|
*
|
|
* <p> Choosing a destination band subset will not affect the
|
|
* number of bands in the output image of a read if no destination
|
|
* image is specified; the created destination image will still
|
|
* have the same number of bands as if this method had never been
|
|
* called. If a different number of bands in the destination
|
|
* image is desired, an image must be supplied using the
|
|
* {@code ImageReadParam.setDestination} method.
|
|
*
|
|
* <p> At the time of reading or writing, an
|
|
* {@code IllegalArgumentException} will be thrown by the
|
|
* reader or writer if a value larger than the largest destination
|
|
* band index has been specified, or if the number of source bands
|
|
* and destination bands to be used differ. The
|
|
* {@code ImageReader.checkReadParamBandSettings} method may
|
|
* be used to automate this test.
|
|
*
|
|
* @param destinationBands an array of integer band indices to be
|
|
* used.
|
|
*
|
|
* @exception IllegalArgumentException if {@code destinationBands}
|
|
* contains a negative or duplicate value.
|
|
*
|
|
* @see #getDestinationBands
|
|
* @see #getSourceBands
|
|
* @see ImageReader#checkReadParamBandSettings
|
|
*/
|
|
public void setDestinationBands(int[] destinationBands) {
|
|
if (destinationBands == null) {
|
|
this.destinationBands = null;
|
|
} else {
|
|
int numBands = destinationBands.length;
|
|
for (int i = 0; i < numBands; i++) {
|
|
int band = destinationBands[i];
|
|
if (band < 0) {
|
|
throw new IllegalArgumentException("Band value < 0!");
|
|
}
|
|
for (int j = i + 1; j < numBands; j++) {
|
|
if (band == destinationBands[j]) {
|
|
throw new IllegalArgumentException("Duplicate band value!");
|
|
}
|
|
}
|
|
}
|
|
this.destinationBands = destinationBands.clone();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns the set of band indices where data will be placed.
|
|
* If no value has been set, {@code null} is returned to
|
|
* indicate that all destination bands will be used.
|
|
*
|
|
* @return the indices of the destination bands to be used,
|
|
* or {@code null}.
|
|
*
|
|
* @see #setDestinationBands
|
|
*/
|
|
public int[] getDestinationBands() {
|
|
if (destinationBands == null) {
|
|
return null;
|
|
} else {
|
|
return destinationBands.clone();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns {@code true} if this reader allows the source
|
|
* image to be rendered at an arbitrary size as part of the
|
|
* decoding process, by means of the
|
|
* {@code setSourceRenderSize} method. If this method
|
|
* returns {@code false}, calls to
|
|
* {@code setSourceRenderSize} will throw an
|
|
* {@code UnsupportedOperationException}.
|
|
*
|
|
* @return {@code true} if setting source rendering size is
|
|
* supported.
|
|
*
|
|
* @see #setSourceRenderSize
|
|
*/
|
|
public boolean canSetSourceRenderSize() {
|
|
return canSetSourceRenderSize;
|
|
}
|
|
|
|
/**
|
|
* If the image is able to be rendered at an arbitrary size, sets
|
|
* the source width and height to the supplied values. Note that
|
|
* the values returned from the {@code getWidth} and
|
|
* {@code getHeight} methods on {@code ImageReader} are
|
|
* not affected by this method; they will continue to return the
|
|
* default size for the image. Similarly, if the image is also
|
|
* tiled the tile width and height are given in terms of the default
|
|
* size.
|
|
*
|
|
* <p> Typically, the width and height should be chosen such that
|
|
* the ratio of width to height closely approximates the aspect
|
|
* ratio of the image, as returned from
|
|
* {@code ImageReader.getAspectRatio}.
|
|
*
|
|
* <p> If this plug-in does not allow the rendering size to be
|
|
* set, an {@code UnsupportedOperationException} will be
|
|
* thrown.
|
|
*
|
|
* <p> To remove the render size setting, pass in a value of
|
|
* {@code null} for {@code size}.
|
|
*
|
|
* @param size a {@code Dimension} indicating the desired
|
|
* width and height.
|
|
*
|
|
* @exception IllegalArgumentException if either the width or the
|
|
* height is negative or 0.
|
|
* @exception UnsupportedOperationException if image resizing
|
|
* is not supported by this plug-in.
|
|
*
|
|
* @see #getSourceRenderSize
|
|
* @see ImageReader#getWidth
|
|
* @see ImageReader#getHeight
|
|
* @see ImageReader#getAspectRatio
|
|
*/
|
|
public void setSourceRenderSize(Dimension size)
|
|
throws UnsupportedOperationException {
|
|
if (!canSetSourceRenderSize()) {
|
|
throw new UnsupportedOperationException
|
|
("Can't set source render size!");
|
|
}
|
|
|
|
if (size == null) {
|
|
this.sourceRenderSize = null;
|
|
} else {
|
|
if (size.width <= 0 || size.height <= 0) {
|
|
throw new IllegalArgumentException("width or height <= 0!");
|
|
}
|
|
this.sourceRenderSize = (Dimension)size.clone();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns the width and height of the source image as it
|
|
* will be rendered during decoding, if they have been set via the
|
|
* {@code setSourceRenderSize} method. A
|
|
* {@code null} value indicates that no setting has been made.
|
|
*
|
|
* @return the rendered width and height of the source image
|
|
* as a {@code Dimension}.
|
|
*
|
|
* @see #setSourceRenderSize
|
|
*/
|
|
public Dimension getSourceRenderSize() {
|
|
return (sourceRenderSize == null) ?
|
|
null : (Dimension)sourceRenderSize.clone();
|
|
}
|
|
|
|
/**
|
|
* Sets the range of progressive passes that will be decoded.
|
|
* Passes outside of this range will be ignored.
|
|
*
|
|
* <p> A progressive pass is a re-encoding of the entire image,
|
|
* generally at progressively higher effective resolutions, but
|
|
* requiring greater transmission bandwidth. The most common use
|
|
* of progressive encoding is found in the JPEG format, where
|
|
* successive passes include more detailed representations of the
|
|
* high-frequency image content.
|
|
*
|
|
* <p> The actual number of passes to be decoded is determined
|
|
* during decoding, based on the number of actual passes available
|
|
* in the stream. Thus if {@code minPass + numPasses - 1} is
|
|
* larger than the index of the last available passes, decoding
|
|
* will end with that pass.
|
|
*
|
|
* <p> A value of {@code numPasses} of
|
|
* {@code Integer.MAX_VALUE} indicates that all passes from
|
|
* {@code minPass} forward should be read. Otherwise, the
|
|
* index of the last pass (<i>i.e.</i>, {@code minPass + numPasses - 1})
|
|
* must not exceed {@code Integer.MAX_VALUE}.
|
|
*
|
|
* <p> There is no {@code unsetSourceProgressivePasses}
|
|
* method; the same effect may be obtained by calling
|
|
* {@code setSourceProgressivePasses(0, Integer.MAX_VALUE)}.
|
|
*
|
|
* @param minPass the index of the first pass to be decoded.
|
|
* @param numPasses the maximum number of passes to be decoded.
|
|
*
|
|
* @exception IllegalArgumentException if {@code minPass} is
|
|
* negative, {@code numPasses} is negative or 0, or
|
|
* {@code numPasses} is smaller than
|
|
* {@code Integer.MAX_VALUE} but
|
|
* {@code minPass + numPasses - 1} is greater than
|
|
* {@code INTEGER.MAX_VALUE}.
|
|
*
|
|
* @see #getSourceMinProgressivePass
|
|
* @see #getSourceMaxProgressivePass
|
|
*/
|
|
public void setSourceProgressivePasses(int minPass, int numPasses) {
|
|
if (minPass < 0) {
|
|
throw new IllegalArgumentException("minPass < 0!");
|
|
}
|
|
if (numPasses <= 0) {
|
|
throw new IllegalArgumentException("numPasses <= 0!");
|
|
}
|
|
if ((numPasses != Integer.MAX_VALUE) &&
|
|
(((minPass + numPasses - 1) & 0x80000000) != 0)) {
|
|
throw new IllegalArgumentException
|
|
("minPass + numPasses - 1 > INTEGER.MAX_VALUE!");
|
|
}
|
|
|
|
this.minProgressivePass = minPass;
|
|
this.numProgressivePasses = numPasses;
|
|
}
|
|
|
|
/**
|
|
* Returns the index of the first progressive pass that will be
|
|
* decoded. If no value has been set, 0 will be returned (which is
|
|
* the correct value).
|
|
*
|
|
* @return the index of the first pass that will be decoded.
|
|
*
|
|
* @see #setSourceProgressivePasses
|
|
* @see #getSourceNumProgressivePasses
|
|
*/
|
|
public int getSourceMinProgressivePass() {
|
|
return minProgressivePass;
|
|
}
|
|
|
|
/**
|
|
* If {@code getSourceNumProgressivePasses} is equal to
|
|
* {@code Integer.MAX_VALUE}, returns
|
|
* {@code Integer.MAX_VALUE}. Otherwise, returns
|
|
* {@code getSourceMinProgressivePass() +
|
|
* getSourceNumProgressivePasses() - 1}.
|
|
*
|
|
* @return the index of the last pass to be read, or
|
|
* {@code Integer.MAX_VALUE}.
|
|
*/
|
|
public int getSourceMaxProgressivePass() {
|
|
if (numProgressivePasses == Integer.MAX_VALUE) {
|
|
return Integer.MAX_VALUE;
|
|
} else {
|
|
return minProgressivePass + numProgressivePasses - 1;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns the number of the progressive passes that will be
|
|
* decoded. If no value has been set,
|
|
* {@code Integer.MAX_VALUE} will be returned (which is the
|
|
* correct value).
|
|
*
|
|
* @return the number of the passes that will be decoded.
|
|
*
|
|
* @see #setSourceProgressivePasses
|
|
* @see #getSourceMinProgressivePass
|
|
*/
|
|
public int getSourceNumProgressivePasses() {
|
|
return numProgressivePasses;
|
|
}
|
|
}
|