/*
* 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.
*/
package org.apache.sanselan.formats.tiff.write;
import java.io.IOException;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import org.apache.sanselan.ImageWriteException;
import org.apache.sanselan.common.BinaryConstants;
import org.apache.sanselan.common.BinaryOutputStream;
import org.apache.sanselan.common.PackBits;
import org.apache.sanselan.common.mylzw.MyLZWCompressor;
import org.apache.sanselan.formats.tiff.TiffElement;
import org.apache.sanselan.formats.tiff.TiffImageData;
import org.apache.sanselan.formats.tiff.constants.TiffConstants;
import com.google.code.appengine.awt.image.BufferedImage;
public abstract class TiffImageWriterBase implements TiffConstants,
BinaryConstants
{
protected final int byteOrder;
public TiffImageWriterBase()
{
this.byteOrder = DEFAULT_TIFF_BYTE_ORDER;
}
public TiffImageWriterBase(int byteOrder)
{
this.byteOrder = byteOrder;
}
protected final static int imageDataPaddingLength(int dataLength)
{
return (4 - (dataLength % 4)) % 4;
}
public abstract void write(OutputStream os, TiffOutputSet outputSet)
throws IOException, ImageWriteException;
protected TiffOutputSummary validateDirectories(TiffOutputSet outputSet)
throws ImageWriteException
{
List directories = outputSet.getDirectories();
if (1 > directories.size())
throw new ImageWriteException("No directories.");
TiffOutputDirectory exifDirectory = null;
TiffOutputDirectory gpsDirectory = null;
TiffOutputDirectory interoperabilityDirectory = null;
TiffOutputField exifDirectoryOffsetField = null;
TiffOutputField gpsDirectoryOffsetField = null;
TiffOutputField interoperabilityDirectoryOffsetField = null;
ArrayList directoryIndices = new ArrayList();
Map directoryTypeMap = new HashMap();
for (int i = 0; i < directories.size(); i++)
{
TiffOutputDirectory directory = (TiffOutputDirectory) directories
.get(i);
int dirType = directory.type;
Integer key = new Integer(dirType);
directoryTypeMap.put(key, directory);
// Debug.debug("validating dirType", dirType + " ("
// + directory.getFields().size() + " fields)");
if (dirType < 0)
{
switch (dirType)
{
case DIRECTORY_TYPE_EXIF:
if (exifDirectory != null)
throw new ImageWriteException(
"More than one EXIF directory.");
exifDirectory = directory;
break;
case DIRECTORY_TYPE_GPS:
if (gpsDirectory != null)
throw new ImageWriteException(
"More than one GPS directory.");
gpsDirectory = directory;
break;
case DIRECTORY_TYPE_INTEROPERABILITY:
if (interoperabilityDirectory != null)
throw new ImageWriteException(
"More than one Interoperability directory.");
interoperabilityDirectory = directory;
break;
default:
throw new ImageWriteException("Unknown directory: "
+ dirType);
}
} else
{
if (directoryIndices.contains(key))
throw new ImageWriteException(
"More than one directory with index: " + dirType
+ ".");
directoryIndices.add(new Integer(dirType));
// dirMap.put(arg0, arg1)
}
HashSet fieldTags = new HashSet();
ArrayList fields = directory.getFields();
for (int j = 0; j < fields.size(); j++)
{
TiffOutputField field = (TiffOutputField) fields.get(j);
Integer fieldKey = new Integer(field.tag);
if (fieldTags.contains(fieldKey))
throw new ImageWriteException("Tag ("
+ field.tagInfo.getDescription()
+ ") appears twice in directory.");
fieldTags.add(fieldKey);
if (field.tag == EXIF_TAG_EXIF_OFFSET.tag)
{
if (exifDirectoryOffsetField != null)
throw new ImageWriteException(
"More than one Exif directory offset field.");
exifDirectoryOffsetField = field;
} else if (field.tag == EXIF_TAG_INTEROP_OFFSET.tag)
{
if (interoperabilityDirectoryOffsetField != null)
throw new ImageWriteException(
"More than one Interoperability directory offset field.");
interoperabilityDirectoryOffsetField = field;
} else if (field.tag == EXIF_TAG_GPSINFO.tag)
{
if (gpsDirectoryOffsetField != null)
throw new ImageWriteException(
"More than one GPS directory offset field.");
gpsDirectoryOffsetField = field;
}
}
// directory.
}
if (directoryIndices.size() < 1)
throw new ImageWriteException("Missing root directory.");
// "normal" TIFF directories should have continous indices starting with
// 0, ie. 0, 1, 2...
Collections.sort(directoryIndices);
TiffOutputDirectory previousDirectory = null;
for (int i = 0; i < directoryIndices.size(); i++)
{
Integer index = (Integer) directoryIndices.get(i);
if (index.intValue() != i)
throw new ImageWriteException("Missing directory: " + i + ".");
// set up chain of directory references for "normal" directories.
TiffOutputDirectory directory = (TiffOutputDirectory) directoryTypeMap
.get(index);
if (null != previousDirectory)
previousDirectory.setNextDirectory(directory);
previousDirectory = directory;
}
TiffOutputDirectory rootDirectory = (TiffOutputDirectory) directoryTypeMap
.get(new Integer(DIRECTORY_TYPE_ROOT));
// prepare results
TiffOutputSummary result = new TiffOutputSummary(byteOrder,
rootDirectory, directoryTypeMap);
if (interoperabilityDirectory == null
&& interoperabilityDirectoryOffsetField != null)
{
// perhaps we should just discard field?
throw new ImageWriteException(
"Output set has Interoperability Directory Offset field, but no Interoperability Directory");
} else if (interoperabilityDirectory != null)
{
if (exifDirectory == null)
{
exifDirectory = outputSet.addExifDirectory();
}
if (interoperabilityDirectoryOffsetField == null)
{
interoperabilityDirectoryOffsetField = TiffOutputField
.createOffsetField(EXIF_TAG_INTEROP_OFFSET, byteOrder);
exifDirectory.add(interoperabilityDirectoryOffsetField);
}
result.add(interoperabilityDirectory,
interoperabilityDirectoryOffsetField);
}
// make sure offset fields and offset'd directories correspond.
if (exifDirectory == null && exifDirectoryOffsetField != null)
{
// perhaps we should just discard field?
throw new ImageWriteException(
"Output set has Exif Directory Offset field, but no Exif Directory");
} else if (exifDirectory != null)
{
if (exifDirectoryOffsetField == null)
{
exifDirectoryOffsetField = TiffOutputField.createOffsetField(
EXIF_TAG_EXIF_OFFSET, byteOrder);
rootDirectory.add(exifDirectoryOffsetField);
}
result.add(exifDirectory, exifDirectoryOffsetField);
}
if (gpsDirectory == null && gpsDirectoryOffsetField != null)
{
// perhaps we should just discard field?
throw new ImageWriteException(
"Output set has GPS Directory Offset field, but no GPS Directory");
} else if (gpsDirectory != null)
{
if (gpsDirectoryOffsetField == null)
{
gpsDirectoryOffsetField = TiffOutputField.createOffsetField(
EXIF_TAG_GPSINFO, byteOrder);
rootDirectory.add(gpsDirectoryOffsetField);
}
result.add(gpsDirectory, gpsDirectoryOffsetField);
}
return result;
// Debug.debug();
}
public void writeImage(BufferedImage src, OutputStream os, Map params)
throws ImageWriteException, IOException
{
// writeImageNew(src, os, params);
// }
//
// public void writeImageNew(BufferedImage src, OutputStream os, Map
// params)
// throws ImageWriteException, IOException
// {
// make copy of params; we'll clear keys as we consume them.
params = new HashMap(params);
// clear format key.
if (params.containsKey(PARAM_KEY_FORMAT))
params.remove(PARAM_KEY_FORMAT);
String xmpXml = null;
if (params.containsKey(PARAM_KEY_XMP_XML))
{
xmpXml = (String) params.get(PARAM_KEY_XMP_XML);
params.remove(PARAM_KEY_XMP_XML);
}
int width = src.getWidth();
int height = src.getHeight();
// BinaryOutputStream bos = new BinaryOutputStream(os,
// WRITE_BYTE_ORDER);
//
// writeImageFileHeader(bos, WRITE_BYTE_ORDER);
// ArrayList directoryFields = new ArrayList();
final int photometricInterpretation = 2; // TODO:
int compression = TIFF_COMPRESSION_LZW; // LZW is default
if (params.containsKey(PARAM_KEY_COMPRESSION))
{
Object value = params.get(PARAM_KEY_COMPRESSION);
if (value != null)
{
if (!(value instanceof Number))
throw new ImageWriteException(
"Invalid compression parameter: " + value);
compression = ((Number) value).intValue();
}
params.remove(PARAM_KEY_COMPRESSION);
}
final int samplesPerPixel = 3; // TODO:
final int bitsPerSample = 8; // TODO:
// int fRowsPerStrip; // TODO:
int rowsPerStrip = 8000 / (width * samplesPerPixel); // TODO:
rowsPerStrip = Math.max(1, rowsPerStrip); // must have at least one.
byte strips[][] = getStrips(src, samplesPerPixel, bitsPerSample,
rowsPerStrip);
// int stripCount = (height + fRowsPerStrip - 1) / fRowsPerStrip;
// int stripCount = strips.length;
if (params.size() > 0)
{
Object firstKey = params.keySet().iterator().next();
throw new ImageWriteException("Unknown parameter: " + firstKey);
}
// System.out.println("width: " + width);
// System.out.println("height: " + height);
// System.out.println("fRowsPerStrip: " + fRowsPerStrip);
// System.out.println("fSamplesPerPixel: " + fSamplesPerPixel);
// System.out.println("stripCount: " + stripCount);
if (compression == TIFF_COMPRESSION_PACKBITS)
{
for (int i = 0; i < strips.length; i++)
strips[i] = new PackBits().compress(strips[i]);
} else if (compression == TIFF_COMPRESSION_LZW)
{
for (int i = 0; i < strips.length; i++)
{
byte uncompressed[] = strips[i];
int LZW_MINIMUM_CODE_SIZE = 8;
MyLZWCompressor compressor = new MyLZWCompressor(
LZW_MINIMUM_CODE_SIZE, BYTE_ORDER_MSB, true);
byte compressed[] = compressor.compress(uncompressed);
strips[i] = compressed;
}
} else if (compression == TIFF_COMPRESSION_UNCOMPRESSED)
{
// do nothing.
} else
throw new ImageWriteException(
"Invalid compression parameter (Only LZW, Packbits and uncompressed supported).");
TiffElement.DataElement imageData[] = new TiffElement.DataElement[strips.length];
for (int i = 0; i < strips.length; i++)
imageData[i] = new TiffImageData.Data(0, strips[i].length,
strips[i]);
// int stripOffsets[] = new int[stripCount];
// int stripByteCounts[] = new int[stripCount];
//
// for (int i = 0; i < strips.length; i++)
// stripByteCounts[i] = strips[i].length;
TiffOutputSet outputSet = new TiffOutputSet(byteOrder);
TiffOutputDirectory directory = outputSet.addRootDirectory();
// WriteField stripOffsetsField;
{
{
TiffOutputField field = new TiffOutputField(
TIFF_TAG_IMAGE_WIDTH, FIELD_TYPE_LONG, 1,
FIELD_TYPE_LONG.writeData(new int[] { width, },
byteOrder));
directory.add(field);
}
{
TiffOutputField field = new TiffOutputField(
TIFF_TAG_IMAGE_LENGTH, FIELD_TYPE_LONG, 1,
FIELD_TYPE_LONG.writeData(new int[] { height, },
byteOrder));
directory.add(field);
}
{
TiffOutputField field = new TiffOutputField(
TIFF_TAG_PHOTOMETRIC_INTERPRETATION, FIELD_TYPE_SHORT,
1, FIELD_TYPE_SHORT.writeData(
new int[] { photometricInterpretation, },
byteOrder));
directory.add(field);
}
{
TiffOutputField field = new TiffOutputField(
TIFF_TAG_COMPRESSION, FIELD_TYPE_SHORT, 1,
FIELD_TYPE_SHORT.writeData(new int[] { compression, },
byteOrder));
directory.add(field);
}
{
TiffOutputField field = new TiffOutputField(
TIFF_TAG_SAMPLES_PER_PIXEL, FIELD_TYPE_SHORT, 1,
FIELD_TYPE_SHORT.writeData(
new int[] { samplesPerPixel, }, byteOrder));
directory.add(field);
}
{
TiffOutputField field = new TiffOutputField(
TIFF_TAG_BITS_PER_SAMPLE, FIELD_TYPE_SHORT, 3,
FIELD_TYPE_SHORT.writeData(new int[] { bitsPerSample,
bitsPerSample, bitsPerSample, }, byteOrder));
directory.add(field);
}
// {
// stripOffsetsField = new WriteField(TIFF_TAG_STRIP_OFFSETS,
// FIELD_TYPE_LONG, stripOffsets.length, FIELD_TYPE_LONG
// .writeData(stripOffsets, byteOrder));
// directory.add(stripOffsetsField);
// }
// {
// WriteField field = new WriteField(TIFF_TAG_STRIP_BYTE_COUNTS,
// FIELD_TYPE_LONG, stripByteCounts.length,
// FIELD_TYPE_LONG.writeData(stripByteCounts,
// WRITE_BYTE_ORDER));
// directory.add(field);
// }
{
TiffOutputField field = new TiffOutputField(
TIFF_TAG_ROWS_PER_STRIP, FIELD_TYPE_LONG, 1,
FIELD_TYPE_LONG.writeData(new int[] { rowsPerStrip, },
byteOrder));
directory.add(field);
}
{
int resolutionUnit = 2;// inches.
TiffOutputField field = new TiffOutputField(
TIFF_TAG_RESOLUTION_UNIT, FIELD_TYPE_SHORT, 1,
FIELD_TYPE_SHORT.writeData(
new int[] { resolutionUnit, }, byteOrder));
directory.add(field);
}
{
int xResolution = 72;
TiffOutputField field = new TiffOutputField(
TIFF_TAG_XRESOLUTION, FIELD_TYPE_RATIONAL, 1,
FIELD_TYPE_RATIONAL
.writeData(xResolution, 1, byteOrder));
directory.add(field);
}
{
int yResolution = 72;
TiffOutputField field = new TiffOutputField(
TIFF_TAG_YRESOLUTION, FIELD_TYPE_RATIONAL, 1,
FIELD_TYPE_RATIONAL
.writeData(yResolution, 1, byteOrder));
directory.add(field);
}
if (null != xmpXml)
{
byte xmpXmlBytes[] = xmpXml.getBytes("utf-8");
TiffOutputField field = new TiffOutputField(TIFF_TAG_XMP,
FIELD_TYPE_BYTE, xmpXmlBytes.length, xmpXmlBytes);
directory.add(field);
}
}
TiffImageData tiffImageData = new TiffImageData.Strips(imageData,
rowsPerStrip);
directory.setTiffImageData(tiffImageData);
write(os, outputSet);
}
private byte[][] getStrips(BufferedImage src, int samplesPerPixel,
int bitsPerSample, int rowsPerStrip)
{
int width = src.getWidth();
int height = src.getHeight();
int stripCount = (height + rowsPerStrip - 1) / rowsPerStrip;
byte result[][] = null;
{ // Write Strips
result = new byte[stripCount][];
int remaining_rows = height;
for (int i = 0; i < stripCount; i++)
{
int rowsInStrip = Math.min(rowsPerStrip, remaining_rows);
remaining_rows -= rowsInStrip;
int bitsInStrip = bitsPerSample * rowsInStrip * width
* samplesPerPixel;
int bytesInStrip = (bitsInStrip + 7) / 8;
byte uncompressed[] = new byte[bytesInStrip];
int counter = 0;
int y = i * rowsPerStrip;
int stop = i * rowsPerStrip + rowsPerStrip;
for (; (y < height) && (y < stop); y++)
{
for (int x = 0; x < width; x++)
{
int rgb = src.getRGB(x, y);
int red = 0xff & (rgb >> 16);
int green = 0xff & (rgb >> 8);
int blue = 0xff & (rgb >> 0);
uncompressed[counter++] = (byte) red;
uncompressed[counter++] = (byte) green;
uncompressed[counter++] = (byte) blue;
}
}
result[i] = uncompressed;
}
}
return result;
}
protected void writeImageFileHeader(BinaryOutputStream bos)
throws IOException, ImageWriteException
{
int offsetToFirstIFD = TIFF_HEADER_SIZE;
writeImageFileHeader(bos, offsetToFirstIFD);
}
protected void writeImageFileHeader(BinaryOutputStream bos,
int offsetToFirstIFD) throws IOException, ImageWriteException
{
bos.write(byteOrder);
bos.write(byteOrder);
bos.write2Bytes(42); // tiffVersion
bos.write4Bytes(offsetToFirstIFD);
}
}