Examples with BaselineTIFFTagSet it.geosolutions.imageio.plugins.tiff.BaselineTIFFTagSet used on opensource projects

Example 1 with BaselineTIFFTagSet

use of it.geosolutions.imageio.plugins.tiff.BaselineTIFFTagSet in project imageio-ext by geosolutions-it.

the class TIFFT4Compressor method setMetadata.

/**
 * Sets the value of the <code>metadata</code> field.
 *
 * <p> The implementation in this class also sets local options
 * from the T4_OPTIONS field if it exists, and if it doesn't, adds
 * it with default values.</p>
 *
 * @param metadata the <code>IIOMetadata</code> object for the
 * image being written.
 *
 * @see #getMetadata()
 */
public void setMetadata(IIOMetadata metadata) {
    super.setMetadata(metadata);
    if (metadata instanceof TIFFImageMetadata) {
        TIFFImageMetadata tim = (TIFFImageMetadata) metadata;
        TIFFField f = tim.getTIFFField(BaselineTIFFTagSet.TAG_T4_OPTIONS);
        if (f != null) {
            int options = f.getAsInt(0);
            is1DMode = (options & 0x1) == 0;
            isEOLAligned = (options & 0x4) == 0x4;
        } else {
            long[] oarray = new long[1];
            oarray[0] = (isEOLAligned ? 0x4 : 0x0) | (is1DMode ? 0x0 : 0x1);
            BaselineTIFFTagSet base = BaselineTIFFTagSet.getInstance();
            TIFFField T4Options = new TIFFField(base.getTag(BaselineTIFFTagSet.TAG_T4_OPTIONS), TIFFTag.TIFF_LONG, 1, oarray);
            tim.rootIFD.addTIFFField(T4Options);
        }
    }
}

Example 2 with BaselineTIFFTagSet

use of it.geosolutions.imageio.plugins.tiff.BaselineTIFFTagSet in project imageio-ext by geosolutions-it.

the class EmptyImage method setupMetadata.

/**
 * Sets up the output metadata adding, removing, and overriding fields
 * as needed. The destination image dimensions are provided as parameters
 * because these might differ from those of the source due to subsampling.
 *
 * @param cm The <code>ColorModel</code> of the image being written.
 * @param sm The <code>SampleModel</code> of the image being written.
 * @param destWidth The width of the written image after subsampling.
 * @param destHeight The height of the written image after subsampling.
 */
void setupMetadata(ColorModel cm, SampleModel sm, int destWidth, int destHeight) throws IIOException {
    // Get initial IFD from metadata
    // Always emit these fields:
    // 
    // Override values from metadata:
    // 
    // planarConfiguration -> chunky (planar not supported on output)
    // 
    // Override values from metadata with image-derived values:
    // 
    // bitsPerSample (if not bilivel)
    // colorMap (if palette color)
    // photometricInterpretation (derive from image)
    // imageLength
    // imageWidth
    // 
    // rowsPerStrip     \      /   tileLength
    // stripOffsets      | OR |   tileOffsets
    // stripByteCounts  /     |   tileByteCounts
    // \   tileWidth
    // 
    // 
    // Override values from metadata with write param values:
    // 
    // compression
    // Use values from metadata if present for these fields,
    // otherwise use defaults:
    // 
    // resolutionUnit
    // XResolution (take from metadata if present)
    // YResolution
    // rowsPerStrip
    // sampleFormat
    TIFFIFD rootIFD = imageMetadata.getRootIFD();
    BaselineTIFFTagSet base = BaselineTIFFTagSet.getInstance();
    // If PlanarConfiguration field present, set value to chunky.
    TIFFField f = rootIFD.getTIFFField(BaselineTIFFTagSet.TAG_PLANAR_CONFIGURATION);
    if (f != null && f.getAsInt(0) != BaselineTIFFTagSet.PLANAR_CONFIGURATION_CHUNKY) {
        // XXX processWarningOccurred()
        TIFFField planarConfigurationField = new TIFFField(base.getTag(BaselineTIFFTagSet.TAG_PLANAR_CONFIGURATION), BaselineTIFFTagSet.PLANAR_CONFIGURATION_CHUNKY);
        rootIFD.addTIFFField(planarConfigurationField);
    }
    char[] extraSamples = null;
    this.photometricInterpretation = -1;
    boolean forcePhotometricInterpretation = false;
    f = rootIFD.getTIFFField(BaselineTIFFTagSet.TAG_PHOTOMETRIC_INTERPRETATION);
    if (f != null) {
        photometricInterpretation = f.getAsInt(0);
        if (photometricInterpretation == BaselineTIFFTagSet.PHOTOMETRIC_INTERPRETATION_PALETTE_COLOR && !(cm instanceof IndexColorModel)) {
            photometricInterpretation = -1;
        } else {
            forcePhotometricInterpretation = true;
        }
    }
    // f = rootIFD.getTIFFField(BaselineTIFFTagSet.TAG_EXTRA_SAMPLES);
    // if (f != null) {
    // extraSamples = f.getAsChars();
    // }
    // f = rootIFD.getTIFFField(BaselineTIFFTagSet.TAG_BITS_PER_SAMPLE);
    // if (f != null) {
    // bitsPerSample = f.getAsChars();
    // }
    int[] sampleSize = sm.getSampleSize();
    int numBands = sm.getNumBands();
    int numExtraSamples = 0;
    // cannot be zero.
    if (numBands > 1 && cm != null && cm.hasAlpha()) {
        --numBands;
        numExtraSamples = 1;
        extraSamples = new char[1];
        if (cm.isAlphaPremultiplied()) {
            extraSamples[0] = BaselineTIFFTagSet.EXTRA_SAMPLES_ASSOCIATED_ALPHA;
        } else {
            extraSamples[0] = BaselineTIFFTagSet.EXTRA_SAMPLES_UNASSOCIATED_ALPHA;
        }
    }
    if (numBands == 3) {
        this.nativePhotometricInterpretation = BaselineTIFFTagSet.PHOTOMETRIC_INTERPRETATION_RGB;
        if (photometricInterpretation == -1) {
            photometricInterpretation = BaselineTIFFTagSet.PHOTOMETRIC_INTERPRETATION_RGB;
        }
    } else if (sm.getNumBands() == 1 && cm instanceof IndexColorModel) {
        IndexColorModel icm = (IndexColorModel) cm;
        int r0 = icm.getRed(0);
        int r1 = icm.getRed(1);
        if (icm.getMapSize() == 2 && (r0 == icm.getGreen(0)) && (r0 == icm.getBlue(0)) && (r1 == icm.getGreen(1)) && (r1 == icm.getBlue(1)) && (r0 == 0 || r0 == 255) && (r1 == 0 || r1 == 255) && (r0 != r1)) {
            if (r0 == 0) {
                nativePhotometricInterpretation = BaselineTIFFTagSet.PHOTOMETRIC_INTERPRETATION_BLACK_IS_ZERO;
            } else {
                nativePhotometricInterpretation = BaselineTIFFTagSet.PHOTOMETRIC_INTERPRETATION_WHITE_IS_ZERO;
            }
            // WhiteIsZero or BlackIsZero, leave it alone
            if (photometricInterpretation != BaselineTIFFTagSet.PHOTOMETRIC_INTERPRETATION_BLACK_IS_ZERO && photometricInterpretation != BaselineTIFFTagSet.PHOTOMETRIC_INTERPRETATION_WHITE_IS_ZERO) {
                photometricInterpretation = r0 == 0 ? BaselineTIFFTagSet.PHOTOMETRIC_INTERPRETATION_BLACK_IS_ZERO : BaselineTIFFTagSet.PHOTOMETRIC_INTERPRETATION_WHITE_IS_ZERO;
            }
        } else {
            nativePhotometricInterpretation = photometricInterpretation = BaselineTIFFTagSet.PHOTOMETRIC_INTERPRETATION_PALETTE_COLOR;
        }
    } else {
        if (cm != null) {
            switch(cm.getColorSpace().getType()) {
                case ColorSpace.TYPE_Lab:
                    nativePhotometricInterpretation = BaselineTIFFTagSet.PHOTOMETRIC_INTERPRETATION_CIELAB;
                    break;
                case ColorSpace.TYPE_YCbCr:
                    nativePhotometricInterpretation = BaselineTIFFTagSet.PHOTOMETRIC_INTERPRETATION_Y_CB_CR;
                    break;
                case ColorSpace.TYPE_CMYK:
                    nativePhotometricInterpretation = BaselineTIFFTagSet.PHOTOMETRIC_INTERPRETATION_CMYK;
                    break;
                default:
                    nativePhotometricInterpretation = BaselineTIFFTagSet.PHOTOMETRIC_INTERPRETATION_BLACK_IS_ZERO;
            }
        } else {
            nativePhotometricInterpretation = BaselineTIFFTagSet.PHOTOMETRIC_INTERPRETATION_BLACK_IS_ZERO;
        }
        if (photometricInterpretation == -1) {
            photometricInterpretation = nativePhotometricInterpretation;
        }
    }
    // Set the compressor and color converter.
    this.compressor = null;
    this.colorConverter = null;
    if (param instanceof TIFFImageWriteParam) {
        TIFFImageWriteParam tparam = (TIFFImageWriteParam) param;
        if (tparam.getCompressionMode() == tparam.MODE_EXPLICIT) {
            compressor = tparam.getTIFFCompressor();
            String compressionType = param.getCompressionType();
            if (compressor != null && !compressor.getCompressionType().equals(compressionType)) {
                // Unset the TIFFCompressor if its compression type is
                // not the one selected.
                compressor = null;
            }
        } else {
            // Compression mode not MODE_EXPLICIT.
            compressor = null;
        }
        colorConverter = tparam.getColorConverter();
        if (colorConverter != null) {
            photometricInterpretation = tparam.getPhotometricInterpretation();
        }
    }
    // Emit compression tag
    int compressionMode = param instanceof TIFFImageWriteParam ? param.getCompressionMode() : ImageWriteParam.MODE_DEFAULT;
    switch(compressionMode) {
        case ImageWriteParam.MODE_EXPLICIT:
            {
                String compressionType = param.getCompressionType();
                if (compressionType == null) {
                    this.compression = BaselineTIFFTagSet.COMPRESSION_NONE;
                } else {
                    // Determine corresponding compression tag value.
                    int len = compressionTypes.length;
                    for (int i = 0; i < len; i++) {
                        if (compressionType.equals(compressionTypes[i])) {
                            this.compression = compressionNumbers[i];
                        }
                    }
                }
                // with the precedence described in TIFFImageWriteParam.
                if (compressor != null && compressor.getCompressionTagValue() != this.compression) {
                    // Does not match: unset the compressor.
                    compressor = null;
                }
            }
            break;
        case ImageWriteParam.MODE_COPY_FROM_METADATA:
            {
                TIFFField compField = rootIFD.getTIFFField(BaselineTIFFTagSet.TAG_COMPRESSION);
                if (compField != null) {
                    this.compression = compField.getAsInt(0);
                    break;
                }
            }
        case ImageWriteParam.MODE_DEFAULT:
        case ImageWriteParam.MODE_DISABLED:
        default:
            this.compression = BaselineTIFFTagSet.COMPRESSION_NONE;
    }
    TIFFField predictorField = rootIFD.getTIFFField(BaselineTIFFTagSet.TAG_PREDICTOR);
    if (predictorField != null) {
        this.predictor = predictorField.getAsInt(0);
        // We only support Horizontal Predictor for a bitDepth of 8
        if (sampleSize[0] != 8 || // Check the value of the tag for validity
        (predictor != BaselineTIFFTagSet.PREDICTOR_NONE && predictor != BaselineTIFFTagSet.PREDICTOR_HORIZONTAL_DIFFERENCING)) {
            // XXX processWarningOccured ???
            // Set to default
            predictor = BaselineTIFFTagSet.PREDICTOR_NONE;
            // Emit this changed predictor value to metadata
            TIFFField newPredictorField = new TIFFField(base.getTag(BaselineTIFFTagSet.TAG_PREDICTOR), predictor);
            rootIFD.addTIFFField(newPredictorField);
        }
    // XXX Do we need to ensure that predictor is not passed on if
    // the compression is not either Deflate or LZW?
    }
    TIFFField compressionField = new TIFFField(base.getTag(BaselineTIFFTagSet.TAG_COMPRESSION), compression);
    rootIFD.addTIFFField(compressionField);
    // Set EXIF flag. Note that there is no way to determine definitively
    // when an uncompressed thumbnail is being written as the EXIF IFD
    // pointer field is optional for thumbnails.
    boolean isEXIF = false;
    if (numBands == 3 && sampleSize[0] == 8 && sampleSize[1] == 8 && sampleSize[2] == 8) {
        // Three bands with 8 bits per sample.
        if (rootIFD.getTIFFField(EXIFParentTIFFTagSet.TAG_EXIF_IFD_POINTER) != null) {
            // EXIF IFD pointer present.
            if (compression == BaselineTIFFTagSet.COMPRESSION_NONE && (photometricInterpretation == BaselineTIFFTagSet.PHOTOMETRIC_INTERPRETATION_RGB || photometricInterpretation == BaselineTIFFTagSet.PHOTOMETRIC_INTERPRETATION_Y_CB_CR)) {
                // Uncompressed RGB or YCbCr.
                isEXIF = true;
            } else if (compression == BaselineTIFFTagSet.COMPRESSION_OLD_JPEG) {
                // Compressed.
                isEXIF = true;
            }
        } else if (compressionMode == ImageWriteParam.MODE_EXPLICIT && EXIF_JPEG_COMPRESSION_TYPE.equals(param.getCompressionType())) {
            // EXIF IFD pointer absent but EXIF JPEG compression set.
            isEXIF = true;
        }
    }
    // Initialize JPEG interchange format flag which is used to
    // indicate that the image is stored as a single JPEG stream.
    // This flag is separated from the 'isEXIF' flag in case JPEG
    // interchange format is eventually supported for non-EXIF images.
    boolean isJPEGInterchange = isEXIF && compression == BaselineTIFFTagSet.COMPRESSION_OLD_JPEG;
    if (compressor == null) {
        if (compression == BaselineTIFFTagSet.COMPRESSION_CCITT_RLE) {
            if (PackageUtil.isCodecLibAvailable()) {
                try {
                    compressor = new TIFFCodecLibRLECompressor();
                    if (DEBUG) {
                        System.out.println("Using codecLib RLE compressor");
                    }
                } catch (RuntimeException e) {
                    if (DEBUG) {
                        System.out.println(e);
                    }
                }
            }
            if (compressor == null) {
                compressor = new TIFFRLECompressor();
                if (DEBUG) {
                    System.out.println("Using Java RLE compressor");
                }
            }
            if (!forcePhotometricInterpretation) {
                photometricInterpretation = BaselineTIFFTagSet.PHOTOMETRIC_INTERPRETATION_WHITE_IS_ZERO;
            }
        } else if (compression == BaselineTIFFTagSet.COMPRESSION_CCITT_T_4) {
            if (PackageUtil.isCodecLibAvailable()) {
                try {
                    compressor = new TIFFCodecLibT4Compressor();
                    if (DEBUG) {
                        System.out.println("Using codecLib T.4 compressor");
                    }
                } catch (RuntimeException e) {
                    if (DEBUG) {
                        System.out.println(e);
                    }
                }
            }
            if (compressor == null) {
                compressor = new TIFFT4Compressor();
                if (DEBUG) {
                    System.out.println("Using Java T.4 compressor");
                }
            }
            if (!forcePhotometricInterpretation) {
                photometricInterpretation = BaselineTIFFTagSet.PHOTOMETRIC_INTERPRETATION_WHITE_IS_ZERO;
            }
        } else if (compression == BaselineTIFFTagSet.COMPRESSION_CCITT_T_6) {
            if (PackageUtil.isCodecLibAvailable()) {
                try {
                    compressor = new TIFFCodecLibT6Compressor();
                    if (DEBUG) {
                        System.out.println("Using codecLib T.6 compressor");
                    }
                } catch (RuntimeException e) {
                    if (DEBUG) {
                        System.out.println(e);
                    }
                }
            }
            if (compressor == null) {
                compressor = new TIFFT6Compressor();
                if (DEBUG) {
                    System.out.println("Using Java T.6 compressor");
                }
            }
            if (!forcePhotometricInterpretation) {
                photometricInterpretation = BaselineTIFFTagSet.PHOTOMETRIC_INTERPRETATION_WHITE_IS_ZERO;
            }
        } else if (compression == BaselineTIFFTagSet.COMPRESSION_LZW) {
            compressor = new TIFFLZWCompressor(predictor);
        } else if (compression == BaselineTIFFTagSet.COMPRESSION_OLD_JPEG) {
            if (isEXIF) {
                compressor = new TIFFEXIFJPEGCompressor(param);
            } else {
                throw new IIOException("Old JPEG compression not supported!");
            }
        } else if (compression == BaselineTIFFTagSet.COMPRESSION_JPEG) {
            if (numBands == 3 && sampleSize[0] == 8 && sampleSize[1] == 8 && sampleSize[2] == 8) {
                photometricInterpretation = BaselineTIFFTagSet.PHOTOMETRIC_INTERPRETATION_Y_CB_CR;
            } else if (numBands == 1 && sampleSize[0] == 8) {
                photometricInterpretation = BaselineTIFFTagSet.PHOTOMETRIC_INTERPRETATION_BLACK_IS_ZERO;
            } else {
                throw new IIOException("JPEG compression supported for 1- and 3-band byte images only!");
            }
            compressor = new TIFFJPEGCompressor(param);
        } else if (compression == BaselineTIFFTagSet.COMPRESSION_ZLIB) {
            compressor = new TIFFZLibCompressor(param, predictor);
        } else if (compression == BaselineTIFFTagSet.COMPRESSION_PACKBITS) {
            compressor = new TIFFPackBitsCompressor();
        } else if (compression == BaselineTIFFTagSet.COMPRESSION_DEFLATE) {
            compressor = new TIFFDeflateCompressor(param, predictor);
        } else {
            // Determine inverse fill setting.
            f = rootIFD.getTIFFField(BaselineTIFFTagSet.TAG_FILL_ORDER);
            boolean inverseFill = (f != null && f.getAsInt(0) == 2);
            if (inverseFill) {
                compressor = new TIFFLSBCompressor();
            } else {
                compressor = new TIFFNullCompressor();
            }
        }
    // compression == ?
    }
    if (DEBUG) {
        if (param != null && param.getCompressionMode() == param.MODE_EXPLICIT) {
            System.out.println("compressionType = " + param.getCompressionType());
        }
        if (compressor != null) {
            System.out.println("compressor = " + compressor.getClass().getName());
        }
    }
    if (colorConverter == null) {
        if (cm != null && cm.getColorSpace().getType() == ColorSpace.TYPE_RGB) {
            // 
            if (photometricInterpretation == BaselineTIFFTagSet.PHOTOMETRIC_INTERPRETATION_Y_CB_CR && compression != BaselineTIFFTagSet.COMPRESSION_JPEG) {
                // 
                // Convert RGB to YCbCr only if compression type is not
                // JPEG in which case this is handled implicitly by the
                // compressor.
                // 
                colorConverter = new TIFFYCbCrColorConverter(imageMetadata);
            } else if (photometricInterpretation == BaselineTIFFTagSet.PHOTOMETRIC_INTERPRETATION_CIELAB) {
                colorConverter = new TIFFCIELabColorConverter();
            }
        }
    }
    // 
    if (photometricInterpretation == BaselineTIFFTagSet.PHOTOMETRIC_INTERPRETATION_Y_CB_CR && compression != BaselineTIFFTagSet.COMPRESSION_JPEG) {
        // Remove old subsampling and positioning fields.
        rootIFD.removeTIFFField(BaselineTIFFTagSet.TAG_Y_CB_CR_SUBSAMPLING);
        rootIFD.removeTIFFField(BaselineTIFFTagSet.TAG_Y_CB_CR_POSITIONING);
        // Add unity chrominance subsampling factors.
        rootIFD.addTIFFField(new TIFFField(base.getTag(BaselineTIFFTagSet.TAG_Y_CB_CR_SUBSAMPLING), TIFFTag.TIFF_SHORT, 2, new char[] { (char) 1, (char) 1 }));
        // Add cosited positioning.
        rootIFD.addTIFFField(new TIFFField(base.getTag(BaselineTIFFTagSet.TAG_Y_CB_CR_POSITIONING), TIFFTag.TIFF_SHORT, 1, new char[] { (char) BaselineTIFFTagSet.Y_CB_CR_POSITIONING_COSITED }));
    }
    TIFFField photometricInterpretationField = new TIFFField(base.getTag(BaselineTIFFTagSet.TAG_PHOTOMETRIC_INTERPRETATION), photometricInterpretation);
    rootIFD.addTIFFField(photometricInterpretationField);
    this.bitsPerSample = new char[numBands + numExtraSamples];
    this.bitDepth = 0;
    for (int i = 0; i < numBands; i++) {
        this.bitDepth = Math.max(bitDepth, sampleSize[i]);
    }
    if (bitDepth == 3) {
        bitDepth = 4;
    } else if (bitDepth > 4 && bitDepth <= 8) {
        bitDepth = 8;
    } else if (bitDepth > 8 && bitDepth <= 16) {
        bitDepth = 16;
    } else if (bitDepth > 16 && bitDepth <= 32) {
        bitDepth = 32;
    } else if (bitDepth > 32) {
        bitDepth = 64;
    }
    for (int i = 0; i < bitsPerSample.length; i++) {
        bitsPerSample[i] = (char) bitDepth;
    }
    // if already in the metadata and correct (count and value == 1).
    if (bitsPerSample.length != 1 || bitsPerSample[0] != 1) {
        TIFFField bitsPerSampleField = new TIFFField(base.getTag(BaselineTIFFTagSet.TAG_BITS_PER_SAMPLE), TIFFTag.TIFF_SHORT, bitsPerSample.length, bitsPerSample);
        rootIFD.addTIFFField(bitsPerSampleField);
    } else {
        // bitsPerSample.length == 1 && bitsPerSample[0] == 1
        TIFFField bitsPerSampleField = rootIFD.getTIFFField(BaselineTIFFTagSet.TAG_BITS_PER_SAMPLE);
        if (bitsPerSampleField != null) {
            int[] bps = bitsPerSampleField.getAsInts();
            if (bps == null || bps.length != 1 || bps[0] != 1) {
                rootIFD.removeTIFFField(BaselineTIFFTagSet.TAG_BITS_PER_SAMPLE);
            }
        }
    }
    // Prepare SampleFormat field.
    f = rootIFD.getTIFFField(BaselineTIFFTagSet.TAG_SAMPLE_FORMAT);
    if (f == null && (bitDepth == 16 || bitDepth == 32 || bitDepth == 64)) {
        // Set up default content for 16- and 32-bit cases.
        char sampleFormatValue;
        int dataType = sm.getDataType();
        if (bitDepth == 16 && dataType == DataBuffer.TYPE_USHORT) {
            sampleFormatValue = (char) BaselineTIFFTagSet.SAMPLE_FORMAT_UNSIGNED_INTEGER;
        } else if (bitDepth == 32 && dataType == DataBuffer.TYPE_FLOAT) {
            sampleFormatValue = (char) BaselineTIFFTagSet.SAMPLE_FORMAT_FLOATING_POINT;
        } else if (bitDepth == 64 && dataType == DataBuffer.TYPE_DOUBLE) {
            sampleFormatValue = (char) BaselineTIFFTagSet.SAMPLE_FORMAT_FLOATING_POINT;
        } else {
            sampleFormatValue = BaselineTIFFTagSet.SAMPLE_FORMAT_SIGNED_INTEGER;
        }
        this.sampleFormat = (int) sampleFormatValue;
        char[] sampleFormatArray = new char[bitsPerSample.length];
        Arrays.fill(sampleFormatArray, sampleFormatValue);
        // Update the metadata.
        TIFFTag sampleFormatTag = base.getTag(BaselineTIFFTagSet.TAG_SAMPLE_FORMAT);
        TIFFField sampleFormatField = new TIFFField(sampleFormatTag, TIFFTag.TIFF_SHORT, sampleFormatArray.length, sampleFormatArray);
        rootIFD.addTIFFField(sampleFormatField);
    } else if (f != null) {
        // Get whatever was provided.
        sampleFormat = f.getAsInt(0);
    } else {
        // Set default value for internal use only.
        sampleFormat = BaselineTIFFTagSet.SAMPLE_FORMAT_UNDEFINED;
    }
    if (extraSamples != null) {
        TIFFField extraSamplesField = new TIFFField(base.getTag(BaselineTIFFTagSet.TAG_EXTRA_SAMPLES), TIFFTag.TIFF_SHORT, extraSamples.length, extraSamples);
        rootIFD.addTIFFField(extraSamplesField);
    } else {
        rootIFD.removeTIFFField(BaselineTIFFTagSet.TAG_EXTRA_SAMPLES);
    }
    TIFFField samplesPerPixelField = new TIFFField(base.getTag(BaselineTIFFTagSet.TAG_SAMPLES_PER_PIXEL), bitsPerSample.length);
    rootIFD.addTIFFField(samplesPerPixelField);
    // Emit ColorMap if image is of palette color type
    if (photometricInterpretation == BaselineTIFFTagSet.PHOTOMETRIC_INTERPRETATION_PALETTE_COLOR && cm instanceof IndexColorModel) {
        char[] colorMap = new char[3 * (1 << bitsPerSample[0])];
        IndexColorModel icm = (IndexColorModel) cm;
        // mapSize is determined by BitsPerSample, not by incoming ICM.
        int mapSize = 1 << bitsPerSample[0];
        int indexBound = Math.min(mapSize, icm.getMapSize());
        for (int i = 0; i < indexBound; i++) {
            colorMap[i] = (char) ((icm.getRed(i) * 65535) / 255);
            colorMap[mapSize + i] = (char) ((icm.getGreen(i) * 65535) / 255);
            colorMap[2 * mapSize + i] = (char) ((icm.getBlue(i) * 65535) / 255);
        }
        TIFFField colorMapField = new TIFFField(base.getTag(BaselineTIFFTagSet.TAG_COLOR_MAP), TIFFTag.TIFF_SHORT, colorMap.length, colorMap);
        rootIFD.addTIFFField(colorMapField);
    } else {
        rootIFD.removeTIFFField(BaselineTIFFTagSet.TAG_COLOR_MAP);
    }
    // metadata and the ColorSpace is non-standard ICC.
    if (cm != null && rootIFD.getTIFFField(BaselineTIFFTagSet.TAG_ICC_PROFILE) == null && ImageUtil.isNonStandardICCColorSpace(cm.getColorSpace())) {
        ICC_ColorSpace iccColorSpace = (ICC_ColorSpace) cm.getColorSpace();
        byte[] iccProfileData = iccColorSpace.getProfile().getData();
        TIFFField iccProfileField = new TIFFField(base.getTag(BaselineTIFFTagSet.TAG_ICC_PROFILE), TIFFTag.TIFF_UNDEFINED, iccProfileData.length, iccProfileData);
        rootIFD.addTIFFField(iccProfileField);
    }
    // Always emit XResolution and YResolution.
    TIFFField XResolutionField = rootIFD.getTIFFField(BaselineTIFFTagSet.TAG_X_RESOLUTION);
    TIFFField YResolutionField = rootIFD.getTIFFField(BaselineTIFFTagSet.TAG_Y_RESOLUTION);
    if (XResolutionField == null && YResolutionField == null) {
        long[][] resRational = new long[1][2];
        resRational[0] = new long[2];
        TIFFField ResolutionUnitField = rootIFD.getTIFFField(BaselineTIFFTagSet.TAG_RESOLUTION_UNIT);
        // quantities is present.
        if (ResolutionUnitField == null && rootIFD.getTIFFField(BaselineTIFFTagSet.TAG_X_POSITION) == null && rootIFD.getTIFFField(BaselineTIFFTagSet.TAG_Y_POSITION) == null) {
            // Set resolution to unit and units to dimensionless.
            resRational[0][0] = 1;
            resRational[0][1] = 1;
            ResolutionUnitField = new TIFFField(rootIFD.getTag(BaselineTIFFTagSet.TAG_RESOLUTION_UNIT), BaselineTIFFTagSet.RESOLUTION_UNIT_NONE);
            rootIFD.addTIFFField(ResolutionUnitField);
        } else {
            // Set resolution to a value which would make the maximum
            // image dimension equal to 4 inches as arbitrarily stated
            // in the description of ResolutionUnit in the TIFF 6.0
            // specification. If the ResolutionUnit field specifies
            // "none" then set the resolution to unity (1/1).
            int resolutionUnit = ResolutionUnitField != null ? ResolutionUnitField.getAsInt(0) : BaselineTIFFTagSet.RESOLUTION_UNIT_INCH;
            int maxDimension = Math.max(destWidth, destHeight);
            switch(resolutionUnit) {
                case BaselineTIFFTagSet.RESOLUTION_UNIT_INCH:
                    resRational[0][0] = maxDimension;
                    resRational[0][1] = 4;
                    break;
                case BaselineTIFFTagSet.RESOLUTION_UNIT_CENTIMETER:
                    // divide out 100
                    resRational[0][0] = 100L * maxDimension;
                    // 2.54 cm/inch * 100
                    resRational[0][1] = 4 * 254;
                    break;
                default:
                    resRational[0][0] = 1;
                    resRational[0][1] = 1;
            }
        }
        XResolutionField = new TIFFField(rootIFD.getTag(BaselineTIFFTagSet.TAG_X_RESOLUTION), TIFFTag.TIFF_RATIONAL, 1, resRational);
        rootIFD.addTIFFField(XResolutionField);
        YResolutionField = new TIFFField(rootIFD.getTag(BaselineTIFFTagSet.TAG_Y_RESOLUTION), TIFFTag.TIFF_RATIONAL, 1, resRational);
        rootIFD.addTIFFField(YResolutionField);
    } else if (XResolutionField == null && YResolutionField != null) {
        // Set XResolution to YResolution.
        long[] yResolution = (long[]) YResolutionField.getAsRational(0).clone();
        XResolutionField = new TIFFField(rootIFD.getTag(BaselineTIFFTagSet.TAG_X_RESOLUTION), TIFFTag.TIFF_RATIONAL, 1, yResolution);
        rootIFD.addTIFFField(XResolutionField);
    } else if (XResolutionField != null && YResolutionField == null) {
        // Set YResolution to XResolution.
        long[] xResolution = (long[]) XResolutionField.getAsRational(0).clone();
        YResolutionField = new TIFFField(rootIFD.getTag(BaselineTIFFTagSet.TAG_Y_RESOLUTION), TIFFTag.TIFF_RATIONAL, 1, xResolution);
        rootIFD.addTIFFField(YResolutionField);
    }
    // Set mandatory fields, overriding metadata passed in
    int width = destWidth;
    TIFFField imageWidthField = new TIFFField(base.getTag(BaselineTIFFTagSet.TAG_IMAGE_WIDTH), width);
    rootIFD.addTIFFField(imageWidthField);
    int height = destHeight;
    TIFFField imageLengthField = new TIFFField(base.getTag(BaselineTIFFTagSet.TAG_IMAGE_LENGTH), height);
    rootIFD.addTIFFField(imageLengthField);
    // Determine rowsPerStrip
    int rowsPerStrip;
    TIFFField rowsPerStripField = rootIFD.getTIFFField(BaselineTIFFTagSet.TAG_ROWS_PER_STRIP);
    if (rowsPerStripField != null) {
        rowsPerStrip = rowsPerStripField.getAsInt(0);
        if (rowsPerStrip < 0) {
            rowsPerStrip = height;
        }
    } else {
        int bitsPerPixel = bitDepth * (numBands + numExtraSamples);
        int bytesPerRow = (bitsPerPixel * width + 7) / 8;
        rowsPerStrip = Math.max(Math.max(DEFAULT_BYTES_PER_STRIP / bytesPerRow, 1), 8);
    }
    rowsPerStrip = Math.min(rowsPerStrip, height);
    // Tiling flag.
    boolean useTiling = false;
    // Analyze tiling parameters
    int tilingMode = param instanceof TIFFImageWriteParam ? param.getTilingMode() : ImageWriteParam.MODE_DEFAULT;
    if (tilingMode == ImageWriteParam.MODE_DISABLED || tilingMode == ImageWriteParam.MODE_DEFAULT) {
        this.tileWidth = width;
        this.tileLength = rowsPerStrip;
        useTiling = false;
    } else if (tilingMode == ImageWriteParam.MODE_EXPLICIT) {
        tileWidth = param.getTileWidth();
        tileLength = param.getTileHeight();
        useTiling = true;
    } else if (tilingMode == ImageWriteParam.MODE_COPY_FROM_METADATA) {
        f = rootIFD.getTIFFField(BaselineTIFFTagSet.TAG_TILE_WIDTH);
        if (f == null) {
            tileWidth = width;
            useTiling = false;
        } else {
            tileWidth = f.getAsInt(0);
            useTiling = true;
        }
        f = rootIFD.getTIFFField(BaselineTIFFTagSet.TAG_TILE_LENGTH);
        if (f == null) {
            tileLength = rowsPerStrip;
        } else {
            tileLength = f.getAsInt(0);
            useTiling = true;
        }
    } else {
        throw new IIOException("Illegal value of tilingMode!");
    }
    if (compression == BaselineTIFFTagSet.COMPRESSION_JPEG) {
        // Reset tile size per TTN2 spec for JPEG compression.
        int subX;
        int subY;
        if (numBands == 1) {
            subX = subY = 1;
        } else {
            subX = subY = TIFFJPEGCompressor.CHROMA_SUBSAMPLING;
        }
        if (useTiling) {
            int MCUMultipleX = 8 * subX;
            int MCUMultipleY = 8 * subY;
            tileWidth = Math.max(MCUMultipleX * ((tileWidth + MCUMultipleX / 2) / MCUMultipleX), MCUMultipleX);
            tileLength = Math.max(MCUMultipleY * ((tileLength + MCUMultipleY / 2) / MCUMultipleY), MCUMultipleY);
        } else if (rowsPerStrip < height) {
            int MCUMultiple = 8 * Math.max(subX, subY);
            rowsPerStrip = tileLength = Math.max(MCUMultiple * ((tileLength + MCUMultiple / 2) / MCUMultiple), MCUMultiple);
        }
    } else if (isJPEGInterchange) {
        // Force tile size to equal image size.
        tileWidth = width;
        tileLength = height;
    } else if (useTiling) {
        // Round tile size to multiple of 16 per TIFF 6.0 specification
        // (see pages 67-68 of version 6.0.1 from Adobe).
        int tileWidthRemainder = tileWidth % 16;
        if (tileWidthRemainder != 0) {
            // Round to nearest multiple of 16 not less than 16.
            tileWidth = Math.max(16 * ((tileWidth + 8) / 16), 16);
        // XXX insert processWarningOccurred(int,String);
        }
        int tileLengthRemainder = tileLength % 16;
        if (tileLengthRemainder != 0) {
            // Round to nearest multiple of 16 not less than 16.
            tileLength = Math.max(16 * ((tileLength + 8) / 16), 16);
        // XXX insert processWarningOccurred(int,String);
        }
    }
    this.tilesAcross = (width + tileWidth - 1) / tileWidth;
    this.tilesDown = (height + tileLength - 1) / tileLength;
    if (!useTiling) {
        this.isTiled = false;
        rootIFD.removeTIFFField(BaselineTIFFTagSet.TAG_TILE_WIDTH);
        rootIFD.removeTIFFField(BaselineTIFFTagSet.TAG_TILE_LENGTH);
        rootIFD.removeTIFFField(BaselineTIFFTagSet.TAG_TILE_OFFSETS);
        rootIFD.removeTIFFField(BaselineTIFFTagSet.TAG_TILE_BYTE_COUNTS);
        rowsPerStripField = new TIFFField(base.getTag(BaselineTIFFTagSet.TAG_ROWS_PER_STRIP), rowsPerStrip);
        rootIFD.addTIFFField(rowsPerStripField);
        TIFFField stripOffsetsField = new TIFFField(base.getTag(BaselineTIFFTagSet.TAG_STRIP_OFFSETS), isBtiff ? TIFFTag.TIFF_LONG8 : TIFFTag.TIFF_LONG, tilesDown);
        rootIFD.addTIFFField(stripOffsetsField);
        TIFFField stripByteCountsField = new TIFFField(base.getTag(BaselineTIFFTagSet.TAG_STRIP_BYTE_COUNTS), isBtiff ? TIFFTag.TIFF_LONG8 : TIFFTag.TIFF_LONG, tilesDown);
        rootIFD.addTIFFField(stripByteCountsField);
    } else {
        this.isTiled = true;
        rootIFD.removeTIFFField(BaselineTIFFTagSet.TAG_ROWS_PER_STRIP);
        rootIFD.removeTIFFField(BaselineTIFFTagSet.TAG_STRIP_OFFSETS);
        rootIFD.removeTIFFField(BaselineTIFFTagSet.TAG_STRIP_BYTE_COUNTS);
        TIFFField tileWidthField = new TIFFField(base.getTag(BaselineTIFFTagSet.TAG_TILE_WIDTH), tileWidth);
        rootIFD.addTIFFField(tileWidthField);
        TIFFField tileLengthField = new TIFFField(base.getTag(BaselineTIFFTagSet.TAG_TILE_LENGTH), tileLength);
        rootIFD.addTIFFField(tileLengthField);
        TIFFField tileOffsetsField = new TIFFField(base.getTag(BaselineTIFFTagSet.TAG_TILE_OFFSETS), isBtiff ? TIFFTag.TIFF_LONG8 : TIFFTag.TIFF_LONG, tilesDown * tilesAcross);
        rootIFD.addTIFFField(tileOffsetsField);
        TIFFField tileByteCountsField = new TIFFField(base.getTag(BaselineTIFFTagSet.TAG_TILE_BYTE_COUNTS), isBtiff ? TIFFTag.TIFF_LONG8 : TIFFTag.TIFF_LONG, tilesDown * tilesAcross);
        rootIFD.addTIFFField(tileByteCountsField);
    }
    if (isEXIF) {
        // 
        // Ensure presence of mandatory fields and absence of prohibited
        // fields and those that duplicate information in JPEG marker
        // segments per tables 14-18 of the EXIF 2.2 specification.
        // 
        // If an empty image is being written or inserted then infer
        // that the primary IFD is being set up.
        boolean isPrimaryIFD = isEncodingEmpty();
        // Handle TIFF fields in order of increasing tag number.
        if (compression == BaselineTIFFTagSet.COMPRESSION_OLD_JPEG) {
            // ImageWidth
            rootIFD.removeTIFFField(BaselineTIFFTagSet.TAG_IMAGE_WIDTH);
            // ImageLength
            rootIFD.removeTIFFField(BaselineTIFFTagSet.TAG_IMAGE_LENGTH);
            // BitsPerSample
            rootIFD.removeTIFFField(BaselineTIFFTagSet.TAG_BITS_PER_SAMPLE);
            // Compression
            if (isPrimaryIFD) {
                rootIFD.removeTIFFField(BaselineTIFFTagSet.TAG_COMPRESSION);
            }
            // PhotometricInterpretation
            rootIFD.removeTIFFField(BaselineTIFFTagSet.TAG_PHOTOMETRIC_INTERPRETATION);
            // StripOffsets
            rootIFD.removeTIFFField(BaselineTIFFTagSet.TAG_STRIP_OFFSETS);
            // SamplesPerPixel
            rootIFD.removeTIFFField(BaselineTIFFTagSet.TAG_SAMPLES_PER_PIXEL);
            // RowsPerStrip
            rootIFD.removeTIFFField(BaselineTIFFTagSet.TAG_ROWS_PER_STRIP);
            // StripByteCounts
            rootIFD.removeTIFFField(BaselineTIFFTagSet.TAG_STRIP_BYTE_COUNTS);
            // XResolution and YResolution are handled above for all TIFFs.
            // PlanarConfiguration
            rootIFD.removeTIFFField(BaselineTIFFTagSet.TAG_PLANAR_CONFIGURATION);
            // ResolutionUnit
            if (rootIFD.getTIFFField(BaselineTIFFTagSet.TAG_RESOLUTION_UNIT) == null) {
                f = new TIFFField(base.getTag(BaselineTIFFTagSet.TAG_RESOLUTION_UNIT), BaselineTIFFTagSet.RESOLUTION_UNIT_INCH);
                rootIFD.addTIFFField(f);
            }
            if (isPrimaryIFD) {
                // JPEGInterchangeFormat
                rootIFD.removeTIFFField(BaselineTIFFTagSet.TAG_JPEG_INTERCHANGE_FORMAT);
                // JPEGInterchangeFormatLength
                rootIFD.removeTIFFField(BaselineTIFFTagSet.TAG_JPEG_INTERCHANGE_FORMAT_LENGTH);
                // YCbCrSubsampling
                rootIFD.removeTIFFField(BaselineTIFFTagSet.TAG_Y_CB_CR_SUBSAMPLING);
                // YCbCrPositioning
                if (rootIFD.getTIFFField(BaselineTIFFTagSet.TAG_Y_CB_CR_POSITIONING) == null) {
                    f = new TIFFField(base.getTag(BaselineTIFFTagSet.TAG_Y_CB_CR_POSITIONING), TIFFTag.TIFF_SHORT, 1, new char[] { (char) BaselineTIFFTagSet.Y_CB_CR_POSITIONING_CENTERED });
                    rootIFD.addTIFFField(f);
                }
            } else {
                // Thumbnail IFD
                // JPEGInterchangeFormat
                f = new TIFFField(base.getTag(BaselineTIFFTagSet.TAG_JPEG_INTERCHANGE_FORMAT), TIFFTag.TIFF_LONG, 1);
                rootIFD.addTIFFField(f);
                // JPEGInterchangeFormatLength
                f = new TIFFField(base.getTag(BaselineTIFFTagSet.TAG_JPEG_INTERCHANGE_FORMAT_LENGTH), TIFFTag.TIFF_LONG, 1);
                rootIFD.addTIFFField(f);
                // YCbCrSubsampling
                rootIFD.removeTIFFField(BaselineTIFFTagSet.TAG_Y_CB_CR_SUBSAMPLING);
            }
        } else {
            // ResolutionUnit
            if (rootIFD.getTIFFField(BaselineTIFFTagSet.TAG_RESOLUTION_UNIT) == null) {
                f = new TIFFField(base.getTag(BaselineTIFFTagSet.TAG_RESOLUTION_UNIT), BaselineTIFFTagSet.RESOLUTION_UNIT_INCH);
                rootIFD.addTIFFField(f);
            }
            // JPEGInterchangeFormat
            rootIFD.removeTIFFField(BaselineTIFFTagSet.TAG_JPEG_INTERCHANGE_FORMAT);
            // JPEGInterchangeFormatLength
            rootIFD.removeTIFFField(BaselineTIFFTagSet.TAG_JPEG_INTERCHANGE_FORMAT_LENGTH);
            if (photometricInterpretation == BaselineTIFFTagSet.PHOTOMETRIC_INTERPRETATION_RGB) {
                // YCbCrCoefficients
                rootIFD.removeTIFFField(BaselineTIFFTagSet.TAG_Y_CB_CR_COEFFICIENTS);
                // YCbCrSubsampling
                rootIFD.removeTIFFField(BaselineTIFFTagSet.TAG_Y_CB_CR_SUBSAMPLING);
                // YCbCrPositioning
                rootIFD.removeTIFFField(BaselineTIFFTagSet.TAG_Y_CB_CR_POSITIONING);
            }
        }
        // Get EXIF tags.
        TIFFTagSet exifTags = EXIFTIFFTagSet.getInstance();
        // Retrieve or create the EXIF IFD.
        TIFFIFD exifIFD = null;
        f = rootIFD.getTIFFField(EXIFParentTIFFTagSet.TAG_EXIF_IFD_POINTER);
        if (f != null) {
            // Retrieve the EXIF IFD.
            exifIFD = (TIFFIFD) f.getData();
        } else if (isPrimaryIFD) {
            // Create the EXIF IFD.
            List exifTagSets = new ArrayList(1);
            exifTagSets.add(exifTags);
            exifIFD = new TIFFIFD(exifTagSets);
            // Add it to the root IFD.
            TIFFTagSet tagSet = EXIFParentTIFFTagSet.getInstance();
            TIFFTag exifIFDTag = tagSet.getTag(EXIFParentTIFFTagSet.TAG_EXIF_IFD_POINTER);
            rootIFD.addTIFFField(new TIFFField(exifIFDTag, TIFFTag.TIFF_LONG, 1, exifIFD));
        }
        if (exifIFD != null) {
            // ExifVersion
            if (exifIFD.getTIFFField(EXIFTIFFTagSet.TAG_EXIF_VERSION) == null) {
                f = new TIFFField(exifTags.getTag(EXIFTIFFTagSet.TAG_EXIF_VERSION), TIFFTag.TIFF_UNDEFINED, 4, EXIFTIFFTagSet.EXIF_VERSION_2_2);
                exifIFD.addTIFFField(f);
            }
            if (compression == BaselineTIFFTagSet.COMPRESSION_OLD_JPEG) {
                // ComponentsConfiguration
                if (exifIFD.getTIFFField(EXIFTIFFTagSet.TAG_COMPONENTS_CONFIGURATION) == null) {
                    f = new TIFFField(exifTags.getTag(EXIFTIFFTagSet.TAG_COMPONENTS_CONFIGURATION), TIFFTag.TIFF_UNDEFINED, 4, new byte[] { (byte) EXIFTIFFTagSet.COMPONENTS_CONFIGURATION_Y, (byte) EXIFTIFFTagSet.COMPONENTS_CONFIGURATION_CB, (byte) EXIFTIFFTagSet.COMPONENTS_CONFIGURATION_CR, (byte) 0 });
                    exifIFD.addTIFFField(f);
                }
            } else {
                // ComponentsConfiguration
                exifIFD.removeTIFFField(EXIFTIFFTagSet.TAG_COMPONENTS_CONFIGURATION);
                // CompressedBitsPerPixel
                exifIFD.removeTIFFField(EXIFTIFFTagSet.TAG_COMPRESSED_BITS_PER_PIXEL);
            }
            // FlashpixVersion
            if (exifIFD.getTIFFField(EXIFTIFFTagSet.TAG_FLASHPIX_VERSION) == null) {
                f = new TIFFField(exifTags.getTag(EXIFTIFFTagSet.TAG_FLASHPIX_VERSION), TIFFTag.TIFF_UNDEFINED, 4, new byte[] { (byte) '0', (byte) '1', (byte) '0', (byte) '0' });
                exifIFD.addTIFFField(f);
            }
            // ColorSpace
            if (exifIFD.getTIFFField(EXIFTIFFTagSet.TAG_COLOR_SPACE) == null) {
                f = new TIFFField(exifTags.getTag(EXIFTIFFTagSet.TAG_COLOR_SPACE), TIFFTag.TIFF_SHORT, 1, new char[] { (char) EXIFTIFFTagSet.COLOR_SPACE_SRGB });
                exifIFD.addTIFFField(f);
            }
            if (compression == BaselineTIFFTagSet.COMPRESSION_OLD_JPEG) {
                // PixelXDimension
                if (exifIFD.getTIFFField(EXIFTIFFTagSet.TAG_PIXEL_X_DIMENSION) == null) {
                    f = new TIFFField(exifTags.getTag(EXIFTIFFTagSet.TAG_PIXEL_X_DIMENSION), width);
                    exifIFD.addTIFFField(f);
                }
                // PixelYDimension
                if (exifIFD.getTIFFField(EXIFTIFFTagSet.TAG_PIXEL_Y_DIMENSION) == null) {
                    f = new TIFFField(exifTags.getTag(EXIFTIFFTagSet.TAG_PIXEL_Y_DIMENSION), height);
                    exifIFD.addTIFFField(f);
                }
            } else {
                exifIFD.removeTIFFField(EXIFTIFFTagSet.TAG_INTEROPERABILITY_IFD_POINTER);
            }
        }
    }
// if(isEXIF)
}

Example 3 with BaselineTIFFTagSet

use of it.geosolutions.imageio.plugins.tiff.BaselineTIFFTagSet in project imageio-ext by geosolutions-it.

the class TIFFIFD method getShallowClone.

/**
 * Returns a <code>TIFFIFD</code> wherein all fields from the
 * <code>BaselineTIFFTagSet</code> are copied by value and all other
 * fields copied by reference.
 */
public TIFFIFD getShallowClone() {
    // Get the baseline TagSet.
    TIFFTagSet baselineTagSet = BaselineTIFFTagSet.getInstance();
    // If the baseline TagSet is not included just return.
    List tagSetList = getTagSetList();
    if (!tagSetList.contains(baselineTagSet)) {
        return this;
    }
    // Create a new object.
    TIFFIFD shallowClone = new TIFFIFD(tagSetList, getParentTag());
    // Get the tag numbers in the baseline set.
    Set baselineTagNumbers = baselineTagSet.getTagNumbers();
    // Iterate over the fields in this IFD.
    Iterator fields = iterator();
    while (fields.hasNext()) {
        // Get the next field.
        TIFFField field = (TIFFField) fields.next();
        // Get its tag number.
        Integer tagNumber = new Integer(field.getTagNumber());
        // Branch based on membership in baseline set.
        TIFFField fieldClone;
        if (baselineTagNumbers.contains(tagNumber)) {
            // Copy by value.
            Object fieldData = field.getData();
            int fieldType = field.getType();
            try {
                switch(fieldType) {
                    case TIFFTag.TIFF_BYTE:
                    case TIFFTag.TIFF_SBYTE:
                    case TIFFTag.TIFF_UNDEFINED:
                        fieldData = ((byte[]) fieldData).clone();
                        break;
                    case TIFFTag.TIFF_ASCII:
                        fieldData = ((String[]) fieldData).clone();
                        break;
                    case TIFFTag.TIFF_SHORT:
                        fieldData = ((char[]) fieldData).clone();
                        break;
                    case TIFFTag.TIFF_LONG:
                    case TIFFTag.TIFF_IFD_POINTER:
                        fieldData = ((long[]) fieldData).clone();
                        break;
                    case TIFFTag.TIFF_RATIONAL:
                        fieldData = ((long[][]) fieldData).clone();
                        break;
                    case TIFFTag.TIFF_SSHORT:
                        fieldData = ((short[]) fieldData).clone();
                        break;
                    case TIFFTag.TIFF_SLONG:
                        fieldData = ((int[]) fieldData).clone();
                        break;
                    case TIFFTag.TIFF_SRATIONAL:
                        fieldData = ((int[][]) fieldData).clone();
                        break;
                    case TIFFTag.TIFF_FLOAT:
                        fieldData = ((float[]) fieldData).clone();
                        break;
                    case TIFFTag.TIFF_DOUBLE:
                        fieldData = ((double[]) fieldData).clone();
                        break;
                    default:
                }
            } catch (Exception e) {
            // Ignore it and copy by reference ...
            }
            fieldClone = new TIFFField(field.getTag(), fieldType, field.getCount(), fieldData);
        } else {
            // Copy by reference.
            fieldClone = field;
        }
        // Add the field to the clone.
        shallowClone.addTIFFField(fieldClone);
    }
    // Set positions.
    shallowClone.setPositions(stripOrTileOffsetsPosition, stripOrTileByteCountsPosition, lastPosition);
    return shallowClone;
}

Example 4 with BaselineTIFFTagSet

use of it.geosolutions.imageio.plugins.tiff.BaselineTIFFTagSet in project imageio-ext by geosolutions-it.

the class TIFFT6Compressor method encode.

public int encode(byte[] b, int off, int width, int height, int[] bitsPerSample, int scanlineStride) throws IOException {
    if (bitsPerSample.length != 1 || bitsPerSample[0] != 1) {
        throw new IIOException("Bits per sample must be 1 for T6 compression!");
    }
    if (metadata instanceof TIFFImageMetadata) {
        TIFFImageMetadata tim = (TIFFImageMetadata) metadata;
        long[] options = new long[1];
        options[0] = 0;
        BaselineTIFFTagSet base = BaselineTIFFTagSet.getInstance();
        TIFFField T6Options = new TIFFField(base.getTag(BaselineTIFFTagSet.TAG_T6_OPTIONS), TIFFTag.TIFF_LONG, 1, options);
        tim.rootIFD.addTIFFField(T6Options);
    }
    // See comment in TIFFT4Compressor
    int maxBits = 9 * ((width + 1) / 2) + 2;
    int bufSize = (maxBits + 7) / 8;
    bufSize = height * (bufSize + 2) + 12;
    byte[] compData = new byte[bufSize];
    int bytes = encodeT6(b, scanlineStride, 8 * off, width, height, compData);
    stream.write(compData, 0, bytes);
    return bytes;
}

Example 5 with BaselineTIFFTagSet

use of it.geosolutions.imageio.plugins.tiff.BaselineTIFFTagSet in project imageio-ext by geosolutions-it.

the class TIFFJPEGCompressor method setMetadata.

/**
 * Sets the value of the <code>metadata</code> field.
 *
 * <p>The implementation in this class also adds the TIFF fields
 * JPEGTables, YCbCrSubSampling, YCbCrPositioning, and
 * ReferenceBlackWhite superseding any prior settings of those
 * fields.</p>
 *
 * @param metadata the <code>IIOMetadata</code> object for the
 * image being written.
 *
 * @see #getMetadata()
 */
public void setMetadata(IIOMetadata metadata) {
    super.setMetadata(metadata);
    if (metadata instanceof TIFFImageMetadata) {
        TIFFImageMetadata tim = (TIFFImageMetadata) metadata;
        TIFFIFD rootIFD = tim.getRootIFD();
        BaselineTIFFTagSet base = BaselineTIFFTagSet.getInstance();
        TIFFField f = tim.getTIFFField(BaselineTIFFTagSet.TAG_SAMPLES_PER_PIXEL);
        int numBands = f.getAsInt(0);
        if (numBands == 1) {
            // Remove YCbCr fields not relevant for grayscale.
            rootIFD.removeTIFFField(BaselineTIFFTagSet.TAG_Y_CB_CR_SUBSAMPLING);
            rootIFD.removeTIFFField(BaselineTIFFTagSet.TAG_Y_CB_CR_POSITIONING);
            rootIFD.removeTIFFField(BaselineTIFFTagSet.TAG_REFERENCE_BLACK_WHITE);
        } else {
            // numBands == 3
            // Replace YCbCr fields.
            // YCbCrSubSampling
            TIFFField YCbCrSubSamplingField = new TIFFField(base.getTag(BaselineTIFFTagSet.TAG_Y_CB_CR_SUBSAMPLING), TIFFTag.TIFF_SHORT, 2, new char[] { CHROMA_SUBSAMPLING, CHROMA_SUBSAMPLING });
            rootIFD.addTIFFField(YCbCrSubSamplingField);
            // YCbCrPositioning
            TIFFField YCbCrPositioningField = new TIFFField(base.getTag(BaselineTIFFTagSet.TAG_Y_CB_CR_POSITIONING), TIFFTag.TIFF_SHORT, 1, new char[] { BaselineTIFFTagSet.Y_CB_CR_POSITIONING_CENTERED });
            rootIFD.addTIFFField(YCbCrPositioningField);
            // ReferenceBlackWhite
            TIFFField referenceBlackWhiteField = new TIFFField(base.getTag(BaselineTIFFTagSet.TAG_REFERENCE_BLACK_WHITE), TIFFTag.TIFF_RATIONAL, 6, new long[][] { // no headroon/footroom
            { 0, 1 }, { 255, 1 }, { 128, 1 }, { 255, 1 }, { 128, 1 }, { 255, 1 } });
            rootIFD.addTIFFField(referenceBlackWhiteField);
        }
        // JPEGTables field is written if and only if one is
        // already present in the metadata. If one is present
        // and has either zero length or does not represent a
        // valid tables-only stream, then a JPEGTables field
        // will be written initialized to the standard tables-
        // only stream written by the JPEG writer.
        // Retrieve the JPEGTables field.
        TIFFField JPEGTablesField = tim.getTIFFField(BaselineTIFFTagSet.TAG_JPEG_TABLES);
        // Initialize JPEG writer to one supporting abbreviated streams.
        if (JPEGTablesField != null) {
            // Intialize the JPEG writer to one that supports stream
            // metadata, i.e., abbreviated streams, and may or may not
            // support image metadata.
            initJPEGWriter(true, false);
        }
        // streams was available.
        if (JPEGTablesField != null && JPEGWriter != null) {
            if (DEBUG)
                System.out.println("Has JPEGTables ...");
            // Set the abbreviated stream flag.
            this.writeAbbreviatedStream = true;
            // Branch based on field value count.
            if (JPEGTablesField.getCount() > 0) {
                if (DEBUG)
                    System.out.println("JPEGTables > 0");
                // Derive the stream metadata from the field.
                // Get the field values.
                byte[] tables = JPEGTablesField.getAsBytes();
                // Create an input stream for the tables.
                ByteArrayInputStream bais = new ByteArrayInputStream(tables);
                MemoryCacheImageInputStream iis = new MemoryCacheImageInputStream(bais);
                // Read the tables stream using the JPEG reader.
                ImageReader jpegReader = getJPEGTablesReader();
                jpegReader.setInput(iis);
                // Initialize the stream metadata object.
                try {
                    JPEGStreamMetadata = jpegReader.getStreamMetadata();
                } catch (Exception e) {
                    // Fall back to default tables.
                    JPEGStreamMetadata = null;
                } finally {
                    jpegReader.reset();
                }
                if (DEBUG)
                    System.out.println(JPEGStreamMetadata);
            }
            if (JPEGStreamMetadata == null) {
                if (DEBUG)
                    System.out.println("JPEGTables == 0");
                // Derive the field from default stream metadata.
                // Get default stream metadata.
                JPEGStreamMetadata = JPEGWriter.getDefaultStreamMetadata(JPEGParam);
                // Create an output stream for the tables.
                ByteArrayOutputStream tableByteStream = new ByteArrayOutputStream();
                MemoryCacheImageOutputStream tableStream = new MemoryCacheImageOutputStream(tableByteStream);
                // Write a tables-only stream.
                JPEGWriter.setOutput(tableStream);
                try {
                    JPEGWriter.prepareWriteSequence(JPEGStreamMetadata);
                    tableStream.flush();
                    JPEGWriter.endWriteSequence();
                    // Get the tables-only stream content.
                    byte[] tables = tableByteStream.toByteArray();
                    if (DEBUG)
                        System.out.println("tables.length = " + tables.length);
                    // Add the JPEGTables field.
                    JPEGTablesField = new TIFFField(base.getTag(BaselineTIFFTagSet.TAG_JPEG_TABLES), TIFFTag.TIFF_UNDEFINED, tables.length, tables);
                    rootIFD.addTIFFField(JPEGTablesField);
                } catch (Exception e) {
                    // Do not write JPEGTables field.
                    rootIFD.removeTIFFField(BaselineTIFFTagSet.TAG_JPEG_TABLES);
                    this.writeAbbreviatedStream = false;
                }
            }
        } else {
            // Do not write JPEGTables field.
            // Remove any field present.
            rootIFD.removeTIFFField(BaselineTIFFTagSet.TAG_JPEG_TABLES);
            // Initialize the writer preferring codecLib.
            initJPEGWriter(false, false);
        }
    }
}