replicant-frameworks_native/awt/javax/imageio/ImageWriteParam.java
The Android Open Source Project 7c1b96a165 Initial Contribution
2008-10-21 07:00:00 -07:00

634 lines
18 KiB
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 java.util.Locale;
import java.awt.*;
/**
* The ImageWriteParam class provides information to an ImageWriter
* about how an image is to be encoded.
*/
public class ImageWriteParam extends IIOParam {
/**
* The Constant MODE_DISABLED indicates that
* stream is not tiled, progressive, or compressed.
*/
public static final int MODE_DISABLED = 0;
/**
* The Constant MODE_DEFAULT indicates that the stream will be tiled,
* progressive, or compressed according to the plug-in's default.
*/
public static final int MODE_DEFAULT = 1;
/**
* The Constant MODE_EXPLICIT indicates that the stream will be tiled,
* progressive, or compressed according to current settings
* which are defined by set methods.
*/
public static final int MODE_EXPLICIT = 2;
/**
* The Constant MODE_COPY_FROM_METADATA indicates that the stream
* will be tiled, progressive, or compressed according to
* stream or image metadata.
*/
public static final int MODE_COPY_FROM_METADATA = 3;
/** Whether the ImageWriter can write tiles. */
protected boolean canWriteTiles = false;
/** The tiling mode. */
protected int tilingMode = MODE_COPY_FROM_METADATA;
/** The preferred tile sizes. */
protected Dimension[] preferredTileSizes = null;
/** The tiling set. */
protected boolean tilingSet = false;
/** The tile width. */
protected int tileWidth = 0;
/** The tile height. */
protected int tileHeight = 0;
/** Whether the ImageWriter can offset tiles. */
protected boolean canOffsetTiles = false;
/** The tile grid x offset. */
protected int tileGridXOffset = 0;
/** The tile grid y offset. */
protected int tileGridYOffset = 0;
/** Whether the ImageWriter can write in progressive mode. */
protected boolean canWriteProgressive = false;
/** The progressive mode. */
protected int progressiveMode = MODE_COPY_FROM_METADATA;
/** Whether the ImageWriter can write in compressed mode. */
protected boolean canWriteCompressed = false;
/** The compression mode. */
protected int compressionMode = MODE_COPY_FROM_METADATA;
/** The compression types. */
protected String[] compressionTypes = null;
/** The compression type. */
protected String compressionType = null;
/** The compression quality. */
protected float compressionQuality = 1.0f;
/** The locale. */
protected Locale locale = null;
/**
* Instantiates a new ImageWriteParam.
*/
protected ImageWriteParam() {}
/**
* Instantiates a new ImageWriteParam with the specified Locale.
*
* @param locale the Locale.
*/
public ImageWriteParam(Locale locale) {
this.locale = locale;
}
/**
* Gets the mode for writing the stream in a progressive sequence.
*
* @return the current progressive mode.
*/
public int getProgressiveMode() {
if (canWriteProgressive()) {
return progressiveMode;
}
throw new UnsupportedOperationException("progressive mode is not supported");
}
/**
* Returns true if images can be written using
* increasing quality passes by progressive.
*
* @return true if images can be written using
* increasing quality passes by progressive, false otherwise.
*/
public boolean canWriteProgressive() {
return canWriteProgressive;
}
/**
* Sets the progressive mode which defines whether the stream
* contains a progressive sequence of increasing quality
* during writing. The progressive mode should be one of
* the following values: MODE_DISABLED, MODE_DEFAULT, or
* MODE_COPY_FROM_METADATA.
*
* @param mode the new progressive mode.
*/
public void setProgressiveMode(int mode) {
if (canWriteProgressive()) {
if (mode < MODE_DISABLED || mode > MODE_COPY_FROM_METADATA || mode == MODE_EXPLICIT) {
throw new IllegalArgumentException("mode is not supported");
}
this.progressiveMode = mode;
}
throw new UnsupportedOperationException("progressive mode is not supported");
}
/**
* Returns true if the writer can use tiles with non zero
* grid offsets while writing.
*
* @return true if the writer can use tiles with non zero
* grid offsets while writing, false otherwise.
*/
public boolean canOffsetTiles() {
return canOffsetTiles;
}
/**
* Returns true if this writer can write images with
* compression.
*
* @return true, true if this writer can write images with
* compression, false otherwise.
*/
public boolean canWriteCompressed() {
return canWriteCompressed;
}
/**
* Returns true if the writer can write tiles.
*
* @return true if the writer can write tiles, false otherwise.
*/
public boolean canWriteTiles() {
return canWriteTiles;
}
/**
* Check write compressed.
*/
private final void checkWriteCompressed() {
if (!canWriteCompressed()) {
throw new UnsupportedOperationException("Compression not supported.");
}
}
/**
* Check compression mode.
*/
private final void checkCompressionMode() {
if (getCompressionMode() != MODE_EXPLICIT) {
throw new IllegalStateException("Compression mode not MODE_EXPLICIT!");
}
}
/**
* Check compression type.
*/
private final void checkCompressionType() {
if (getCompressionTypes() != null && getCompressionType() == null) {
throw new IllegalStateException("No compression type set!");
}
}
/**
* Gets the compression mode.
*
* @return the compression mode if it's supported.
*/
public int getCompressionMode() {
checkWriteCompressed();
return compressionMode;
}
/**
* Gets the an array of supported compression types.
*
* @return the an array of supported compression types.
*/
public String[] getCompressionTypes() {
checkWriteCompressed();
if (compressionTypes != null) {
return compressionTypes.clone();
}
return null;
}
/**
* Gets the current compression type, or returns null.
*
* @return the current compression type, or returns null
* if it is not set.
*/
public String getCompressionType() {
checkWriteCompressed();
checkCompressionMode();
return compressionType;
}
/**
* Gets a bit rate which represents an estimate of the number of bits
* of output data for each bit of input image data with the specified
* quality.
*
* @param quality the quality.
*
* @return an estimate of the bit rate, or -1.0F if there is no
* estimate.
*/
public float getBitRate(float quality) {
checkWriteCompressed();
checkCompressionMode();
checkCompressionType();
if (quality < 0 || quality > 1) {
throw new IllegalArgumentException("Quality out-of-bounds!");
}
return -1.0f;
}
/**
* Gets the compression quality.
*
* @return the compression quality.
*/
public float getCompressionQuality() {
checkWriteCompressed();
checkCompressionMode();
checkCompressionType();
return compressionQuality;
}
/**
* Gets the array of compression quality descriptions.
*
* @return the string array of compression quality descriptions.
*/
public String[] getCompressionQualityDescriptions() {
checkWriteCompressed();
checkCompressionMode();
checkCompressionType();
return null;
}
/**
* Gets an array of floats which decribe
* compression quality levels.
*
* @return the array of compression quality values.
*/
public float[] getCompressionQualityValues() {
checkWriteCompressed();
checkCompressionMode();
checkCompressionType();
return null;
}
/**
* Gets the locale of this ImageWriteParam.
*
* @return the locale of this ImageWriteParam.
*/
public Locale getLocale() {
return locale;
}
/**
* Gets the current compression type using the current Locale.
*
* @return the current compression type using the current Locale.
*/
public String getLocalizedCompressionTypeName() {
checkWriteCompressed();
checkCompressionMode();
String compressionType = getCompressionType();
if (compressionType == null) {
throw new IllegalStateException("No compression type set!");
}
return compressionType;
}
/**
* Check tiling.
*/
private final void checkTiling() {
if (!canWriteTiles()) {
throw new UnsupportedOperationException("Tiling not supported!");
}
}
/**
* Check tiling mode.
*/
private final void checkTilingMode() {
if (getTilingMode() != MODE_EXPLICIT) {
throw new IllegalStateException("Tiling mode not MODE_EXPLICIT!");
}
}
/**
* Check tiling params.
*/
private final void checkTilingParams() {
if (!tilingSet) {
throw new IllegalStateException("Tiling parameters not set!");
}
}
/**
* Gets the tiling mode if tiling is supported.
*
* @return the tiling mode if tiling is supported.
*/
public int getTilingMode() {
checkTiling();
return tilingMode;
}
/**
* Gets an array of Dimensions giving the sizes of the tiles as
* they are encoded in the output file or stream.
*
* @return the preferred tile sizes.
*/
public Dimension[] getPreferredTileSizes() {
checkTiling();
if (preferredTileSizes == null) {
return null;
}
Dimension[] retval = new Dimension[preferredTileSizes.length];
for (int i = 0; i < preferredTileSizes.length; i++) {
retval[i] = new Dimension(retval[i]);
}
return retval;
}
/**
* Gets the tile grid X offset for encoding.
*
* @return the tile grid X offset for encoding.
*/
public int getTileGridXOffset() {
checkTiling();
checkTilingMode();
checkTilingParams();
return tileGridXOffset;
}
/**
* Gets the tile grid Y offset for encoding.
*
* @return the tile grid Y offset for encoding.
*/
public int getTileGridYOffset() {
checkTiling();
checkTilingMode();
checkTilingParams();
return tileGridYOffset;
}
/**
* Gets the tile height in an image as it is written to the
* output stream.
*
* @return the tile height in an image as it is written to the
* output stream.
*/
public int getTileHeight() {
checkTiling();
checkTilingMode();
checkTilingParams();
return tileHeight;
}
/**
* Gets the tile width in an image as it is written to the
* output stream.
*
* @return the tile width in an image as it is written to the
* output stream.
*/
public int getTileWidth() {
checkTiling();
checkTilingMode();
checkTilingParams();
return tileWidth;
}
/**
* Checks if the current compression type has lossless
* compression or not.
*
* @return true, if the current compression type has lossless
* compression, false otherwise.
*/
public boolean isCompressionLossless() {
checkWriteCompressed();
checkCompressionMode();
checkCompressionType();
return true;
}
/**
* Removes current compression type.
*/
public void unsetCompression() {
checkWriteCompressed();
checkCompressionMode();
compressionType = null;
compressionQuality = 1;
}
/**
* Sets the compression mode to the specified value.
* The specified mode can be one of the predefined
* constants: MODE_DEFAULT, MODE_DISABLED, MODE_EXPLICIT,
* or MODE_COPY_FROM_METADATA.
*
* @param mode the new compression mode to be set.
*/
public void setCompressionMode(int mode) {
checkWriteCompressed();
switch (mode) {
case MODE_EXPLICIT: {
compressionMode = mode;
unsetCompression();
break;
}
case MODE_COPY_FROM_METADATA:
case MODE_DISABLED:
case MODE_DEFAULT: {
compressionMode = mode;
break;
}
default: {
throw new IllegalArgumentException("Illegal value for mode!");
}
}
}
/**
* Sets the compression quality. The value should be between 0 and 1.
*
* @param quality the new compression quality,
* float value between 0 and 1.
*/
public void setCompressionQuality(float quality) {
checkWriteCompressed();
checkCompressionMode();
checkCompressionType();
if (quality < 0 || quality > 1) {
throw new IllegalArgumentException("Quality out-of-bounds!");
}
compressionQuality = quality;
}
/**
* Sets the compression type. The specified string
* should be one of the values returned
* by getCompressionTypes method.
*
* @param compressionType the new compression type.
*/
public void setCompressionType(String compressionType) {
checkWriteCompressed();
checkCompressionMode();
if (compressionType == null) { // Don't check anything
this.compressionType = null;
} else {
String[] compressionTypes = getCompressionTypes();
if (compressionTypes == null) {
throw new UnsupportedOperationException("No settable compression types");
}
for (int i = 0; i < compressionTypes.length; i++) {
if (compressionTypes[i].equals(compressionType)) {
this.compressionType = compressionType;
return;
}
}
// Compression type is not in the list.
throw new IllegalArgumentException("Unknown compression type!");
}
}
/**
* Sets the instruction that tiling should be performed for
* the image in the output stream with the specified parameters.
*
* @param tileWidth the tile's width.
* @param tileHeight the tile's height.
* @param tileGridXOffset the tile grid's x offset.
* @param tileGridYOffset the tile grid's y offset.
*/
public void setTiling(int tileWidth, int tileHeight, int tileGridXOffset, int tileGridYOffset) {
checkTiling();
checkTilingMode();
if (!canOffsetTiles() && (tileGridXOffset != 0 || tileGridYOffset != 0)) {
throw new UnsupportedOperationException("Can't offset tiles!");
}
if (tileWidth <=0 || tileHeight <= 0) {
throw new IllegalArgumentException("tile dimensions are non-positive!");
}
Dimension preferredTileSizes[] = getPreferredTileSizes();
if (preferredTileSizes != null) {
for (int i = 0; i < preferredTileSizes.length; i+=2) {
Dimension minSize = preferredTileSizes[i];
Dimension maxSize = preferredTileSizes[i+1];
if (
tileWidth < minSize.width || tileWidth > maxSize.width ||
tileHeight < minSize.height || tileHeight > maxSize.height
) {
throw new IllegalArgumentException("Illegal tile size!");
}
}
}
tilingSet = true;
this.tileWidth = tileWidth;
this.tileHeight = tileHeight;
this.tileGridXOffset = tileGridXOffset;
this.tileGridYOffset = tileGridYOffset;
}
/**
* Clears all tiling settings.
*/
public void unsetTiling() {
checkTiling();
checkTilingMode();
tilingSet = false;
tileWidth = 0;
tileHeight = 0;
tileGridXOffset = 0;
tileGridYOffset = 0;
}
/**
* Sets the tiling mode. The specified mode should be one of the
* following values: MODE_DISABLED, MODE_DEFAULT, MODE_EXPLICIT,
* or MODE_COPY_FROM_METADATA.
*
* @param mode the new tiling mode.
*/
public void setTilingMode(int mode) {
checkTiling();
switch (mode) {
case MODE_EXPLICIT: {
tilingMode = mode;
unsetTiling();
break;
}
case MODE_COPY_FROM_METADATA:
case MODE_DISABLED:
case MODE_DEFAULT: {
tilingMode = mode;
break;
}
default: {
throw new IllegalArgumentException("Illegal value for mode!");
}
}
}
}