https://openjdk.java.net/ 
/*
 * Copyright (c) 2005, 2016, 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 com.sun.imageio.plugins.tiff;

import java.io.IOException;
import javax.imageio.ImageWriter;
import javax.imageio.metadata.IIOMetadata;
import javax.imageio.stream.ImageOutputStream;


An abstract superclass for pluggable TIFF compressors.

/**
 * An abstract superclass for pluggable TIFF compressors.
 */
public abstract class TIFFCompressor {

    
The ImageWriter calling this TIFFCompressor. 
/**
     * The {@code ImageWriter} calling this
     * {@code TIFFCompressor}.
     */
    protected ImageWriter writer;

    
The IIOMetadata object containing metadata for the current image. 
/**
     * The {@code IIOMetadata} object containing metadata for the
     * current image.
     */
    protected IIOMetadata metadata;

    
The name of the compression type supported by this compressor.

/**
     * The name of the compression type supported by this compressor.
     */
    protected String compressionType;

    
The value to be assigned to the TIFF Compression tag in the
TIFF image metadata.

/**
     * The value to be assigned to the TIFF <i>Compression</i> tag in the
     * TIFF image metadata.
     */
    protected int compressionTagValue;

    
Whether the compression is lossless.

/**
     * Whether the compression is lossless.
     */
    protected boolean isCompressionLossless;

    
The ImageOutputStream to be written. 
/**
     * The {@code ImageOutputStream} to be written.
     */
    protected ImageOutputStream stream;

    
Creates a compressor object for use in compressing TIFF data.

The parameters compressionTagValue and isCompressionLossless are provided to accomodate compression types which are unknown. A compression type is "known" if it is either among those already supported by the TIFF writer (see TIFFImageWriteParam), or is listed in the TIFF 6.0 specification but not supported. If the compression type is unknown, the compressionTagValue and isCompressionLossless parameters are ignored.


Params:
  • compressionType – The name of the compression type.
  • compressionTagValue – The value to be assigned to the TIFF
Compression tag in the TIFF image metadata; ignored if compressionType is a known type.
  • isCompressionLossless – Whether the compression is lossless; ignored if compressionType is a known type.
Throws:
/**
     * Creates a compressor object for use in compressing TIFF data.
     *
     * <p>The parameters {@code compressionTagValue} and
     * {@code isCompressionLossless} are provided to accomodate
     * compression types which are unknown. A compression type is
     * "known" if it is either among those already supported by the
     * TIFF writer (see {@link TIFFImageWriteParam}), or is listed in
     * the TIFF 6.0 specification but not supported. If the compression
     * type is unknown, the {@code compressionTagValue} and
     * {@code isCompressionLossless} parameters are ignored.</p>
     *
     * @param compressionType The name of the compression type.
     * @param compressionTagValue The value to be assigned to the TIFF
     * <i>Compression</i> tag in the TIFF image metadata; ignored if
     * {@code compressionType} is a known type.
     * @param isCompressionLossless Whether the compression is lossless;
     * ignored if {@code compressionType} is a known type.
     *
     * @throws NullPointerException if {@code compressionType} is
     * {@code null}.
     * @throws IllegalArgumentException if {@code compressionTagValue} is
     * less {@code 1}.
     */
    public TIFFCompressor(String compressionType,
                          int compressionTagValue,
                          boolean isCompressionLossless) {
        if(compressionType == null) {
            throw new NullPointerException("compressionType == null");
        } else if(compressionTagValue < 1) {
            throw new IllegalArgumentException("compressionTagValue < 1");
        }

        // Set the compression type.
        this.compressionType = compressionType;

        // Determine whether this type is either defined in the TIFF 6.0
        // specification or is already supported.
        int compressionIndex = -1;
        String[] compressionTypes = TIFFImageWriter.compressionTypes;
        int len = compressionTypes.length;
        for(int i = 0; i < len; i++) {
            if(compressionTypes[i].equals(compressionType)) {
                // Save the index of the supported type.
                compressionIndex = i;
                break;
            }
        }

        if(compressionIndex != -1) {
            // Known compression type.
            this.compressionTagValue =
                TIFFImageWriter.compressionNumbers[compressionIndex];
            this.isCompressionLossless =
                TIFFImageWriter.isCompressionLossless[compressionIndex];
        } else {
            // Unknown compression type.
            this.compressionTagValue = compressionTagValue;
            this.isCompressionLossless = isCompressionLossless;
        }
    }

    
Retrieve the name of the compression type supported by this compressor.

Returns:The compression type name.
/**
     * Retrieve the name of the compression type supported by this compressor.
     *
     * @return The compression type name.
     */
    public String getCompressionType() {
        return compressionType;
    }

    
Retrieve the value to be assigned to the TIFF Compression tag
in the TIFF image metadata.

Returns:The Compression tag value.
/**
     * Retrieve the value to be assigned to the TIFF <i>Compression</i> tag
     * in the TIFF image metadata.
     *
     * @return The <i>Compression</i> tag value.
     */
    public int getCompressionTagValue() {
        return compressionTagValue;
    }

    
Retrieves a value indicating whether the compression is lossless.

Returns:Whether the compression is lossless.
/**
     * Retrieves a value indicating whether the compression is lossless.
     *
     * @return Whether the compression is lossless.
     */
    public boolean isCompressionLossless() {
        return isCompressionLossless;
    }

    
Sets the ImageOutputStream to be written. 
Params:
  • stream – an ImageOutputStream to be written.
See Also:
/**
     * Sets the {@code ImageOutputStream} to be written.
     *
     * @param stream an {@code ImageOutputStream} to be written.
     *
     * @see #getStream
     */
    public void setStream(ImageOutputStream stream) {
        this.stream = stream;
    }

    
Returns the ImageOutputStream that will be written. 
See Also:
Returns:an ImageOutputStream.
/**
     * Returns the {@code ImageOutputStream} that will be written.
     *
     * @return an {@code ImageOutputStream}.
     *
     * @see #setStream(ImageOutputStream)
     */
    public ImageOutputStream getStream() {
        return stream;
    }

    
Sets the value of the writer field. 
Params:
  • writer – the current ImageWriter.
See Also:
/**
     * Sets the value of the {@code writer} field.
     *
     * @param writer the current {@code ImageWriter}.
     *
     * @see #getWriter()
     */
    public void setWriter(ImageWriter writer) {
        this.writer = writer;
    }

    
Returns the current ImageWriter. 
See Also:
Returns:an ImageWriter.
/**
     * Returns the current {@code ImageWriter}.
     *
     * @return an {@code ImageWriter}.
     *
     * @see #setWriter(ImageWriter)
     */
    public ImageWriter getWriter() {
        return this.writer;
    }

    
Sets the value of the metadata field. 
Params:
  • metadata – the IIOMetadata object for the image being written.
See Also:
/**
     * Sets the value of the {@code metadata} field.
     *
     * @param metadata the {@code IIOMetadata} object for the
     * image being written.
     *
     * @see #getMetadata()
     */
    public void setMetadata(IIOMetadata metadata) {
        this.metadata = metadata;
    }

    
Returns the current IIOMetadata object. 
See Also:
Returns:the IIOMetadata object for the image being written.
/**
     * Returns the current {@code IIOMetadata} object.
     *
     * @return the {@code IIOMetadata} object for the image being
     * written.
     *
     * @see #setMetadata(IIOMetadata)
     */
    public IIOMetadata getMetadata() {
        return this.metadata;
    }

    
Encodes the supplied image data, writing to the currently set ImageOutputStream. 
Params:
  • b – an array of bytes containing the packed but uncompressed image data.
  • off – the starting offset of the data to be written in the array b.
  • width – the width of the rectangle of pixels to be written.
  • height – the height of the rectangle of pixels to be written.
  • bitsPerSample – an array of ints indicting the number of bits used to represent each image sample within a pixel.
  • scanlineStride – the number of bytes separating each
row of the input data.
Throws:
  • IOException – if the supplied data cannot be encoded by this TIFFCompressor, or if any I/O error occurs during writing.
Returns:the number of bytes written.
/**
     * Encodes the supplied image data, writing to the currently set
     * {@code ImageOutputStream}.
     *
     * @param b an array of {@code byte}s containing the packed
     * but uncompressed image data.
     * @param off the starting offset of the data to be written in the
     * array {@code b}.
     * @param width the width of the rectangle of pixels to be written.
     * @param height the height of the rectangle of pixels to be written.
     * @param bitsPerSample an array of {@code int}s indicting
     * the number of bits used to represent each image sample within
     * a pixel.
     * @param scanlineStride the number of bytes separating each
     * row of the input data.
     *
     * @return the number of bytes written.
     *
     * @throws IOException if the supplied data cannot be encoded by
     * this {@code TIFFCompressor}, or if any I/O error occurs
     * during writing.
     */
    public abstract int encode(byte[] b, int off,
                               int width, int height,
                               int[] bitsPerSample,
                               int scanlineStride) throws IOException;

}