Backups/TwelveMonkeys
2
0
Fork 0
mirror of https://github.com/haraldk/TwelveMonkeys.git synced 2026-04-05 00:00:01 -04:00
Code Issues Projects Releases Wiki Activity

Merge remote-tracking branch 'remotes/haraldk/master' into CCITTWriter

Browse Source
This commit is contained in:
Schmidor
2015-10-08 01:12:13 +02:00
parent 39b92ab19f 867ca61755
commit 585b5faa62
82 changed files with 4467 additions and 529 deletions
Download Patch File Download Diff File Expand all files Collapse all files

431
imageio/imageio-tiff/src/main/java/com/twelvemonkeys/imageio/plugins/tiff/CCITTFaxDecoderStream.java
View File

@@ -28,24 +28,23 @@
package com.twelvemonkeys.imageio.plugins.tiff;
import com.twelvemonkeys.lang.Validate;
import java.io.EOFException;
import java.io.FilterInputStream;
import java.io.IOException;
import java.io.InputStream;
import com.twelvemonkeys.imageio.metadata.exif.TIFF;
import com.twelvemonkeys.lang.Validate;
/**
* CCITT Modified Huffman RLE, Group 3 (T4) and Group 4 (T6) fax compression.
*
*
* @author <a href="mailto:harald.kuhr@gmail.com">Harald Kuhr</a>
* @author <a href="https://github.com/Schmidor">Oliver Schmidtmer</a>
* @author last modified by $Author: haraldk$
* @version $Id: CCITTFaxDecoderStream.java,v 1.0 23.05.12 15:55 haraldk Exp$
*/
final class CCITTFaxDecoderStream extends FilterInputStream {
// See TIFF 6.0 Specification, Section 10: "Modified Huffman Compression",
// page 43.
// See TIFF 6.0 Specification, Section 10: "Modified Huffman Compression", page 43.
private final int columns;
private final byte[] decodedRow;
@@ -62,8 +61,6 @@ final class CCITTFaxDecoderStream extends FilterInputStream {
private int changesReferenceRowCount;
private int changesCurrentRowCount;
private static final int EOL_CODE = 0x01; // 12 bit
private boolean optionG32D = false;
@SuppressWarnings("unused") // Leading zeros for aligning EOL
@@ -72,29 +69,34 @@ final class CCITTFaxDecoderStream extends FilterInputStream {
private boolean optionUncompressed = false;
public CCITTFaxDecoderStream(final InputStream stream, final int columns, final int type, final int fillOrder,
final long options) {
final long options) {
super(Validate.notNull(stream, "stream"));
this.columns = Validate.isTrue(columns > 0, columns, "width must be greater than 0");
// We know this is only used for b/w (1 bit)
this.decodedRow = new byte[(columns + 7) / 8];
this.type = type;
this.fillOrder = fillOrder;// Validate.isTrue(fillOrder == 1, fillOrder,
// "Only fill order 1 supported: %s"); //
// TODO: Implement fillOrder == 2
this.type = Validate.isTrue(
type == TIFFBaseline.COMPRESSION_CCITT_MODIFIED_HUFFMAN_RLE ||
type == TIFFExtension.COMPRESSION_CCITT_T4 || type == TIFFExtension.COMPRESSION_CCITT_T6,
type, "Only CCITT Modified Huffman RLE compression (2), CCITT T4 (3) or CCITT T6 (4) supported: %s"
);
this.fillOrder = Validate.isTrue(
fillOrder == TIFFBaseline.FILL_LEFT_TO_RIGHT || fillOrder == TIFFExtension.FILL_RIGHT_TO_LEFT,
fillOrder, "Expected fill order 1 or 2: %s"
);
this.changesReferenceRow = new int[columns];
this.changesCurrentRow = new int[columns];
switch (type) {
case TIFFExtension.COMPRESSION_CCITT_T4:
optionG32D = (options & TIFFExtension.GROUP3OPT_2DENCODING) != 0;
optionG3Fill = (options & TIFFExtension.GROUP3OPT_FILLBITS) != 0;
optionUncompressed = (options & TIFFExtension.GROUP3OPT_UNCOMPRESSED) != 0;
break;
case TIFFExtension.COMPRESSION_CCITT_T6:
optionUncompressed = (options & TIFFExtension.GROUP4OPT_UNCOMPRESSED) != 0;
break;
case TIFFExtension.COMPRESSION_CCITT_T4:
optionG32D = (options & TIFFExtension.GROUP3OPT_2DENCODING) != 0;
optionG3Fill = (options & TIFFExtension.GROUP3OPT_FILLBITS) != 0;
optionUncompressed = (options & TIFFExtension.GROUP3OPT_UNCOMPRESSED) != 0;
break;
case TIFFExtension.COMPRESSION_CCITT_T6:
optionUncompressed = (options & TIFFExtension.GROUP4OPT_UNCOMPRESSED) != 0;
break;
}
Validate.isTrue(!optionUncompressed, optionUncompressed,
@@ -107,7 +109,8 @@ final class CCITTFaxDecoderStream extends FilterInputStream {
try {
decodeRow();
} catch (EOFException e) {
}
catch (EOFException e) {
// TODO: Rewrite to avoid throw/catch for normal flow...
if (decodedLength != 0) {
throw e;
@@ -126,16 +129,20 @@ final class CCITTFaxDecoderStream extends FilterInputStream {
int index = 0;
boolean white = true;
changesCurrentRowCount = 0;
do {
int completeRun = 0;
int completeRun;
if (white) {
completeRun = decodeRun(whiteRunTree);
} else {
}
else {
completeRun = decodeRun(blackRunTree);
}
index += completeRun;
changesCurrentRow[changesCurrentRowCount++] = index;
// Flip color for next run
white = !white;
} while (index < columns);
@@ -147,62 +154,79 @@ final class CCITTFaxDecoderStream extends FilterInputStream {
changesCurrentRow = changesReferenceRow;
changesReferenceRow = tmp;
if (changesReferenceRowCount == 0) {
changesReferenceRowCount = 3;
changesReferenceRow[0] = columns;
changesReferenceRow[1] = columns;
changesReferenceRow[2] = columns;
}
boolean white = true;
int index = 0;
changesCurrentRowCount = 0;
mode: while (index < columns) {
// read mode
Node n = codeTree.root;
while (true) {
n = n.walk(readBit());
if (n == null) {
continue mode;
} else if (n.isLeaf) {
}
else if (n.isLeaf) {
switch (n.value) {
case VALUE_HMODE:
int runLength = 0;
runLength = decodeRun(white ? whiteRunTree : blackRunTree);
index += runLength;
changesCurrentRow[changesCurrentRowCount++] = index;
case VALUE_HMODE:
int runLength;
runLength = decodeRun(white ? whiteRunTree : blackRunTree);
index += runLength;
changesCurrentRow[changesCurrentRowCount++] = index;
runLength = decodeRun(white ? blackRunTree : whiteRunTree);
index += runLength;
changesCurrentRow[changesCurrentRowCount++] = index;
break;
case VALUE_PASSMODE:
index = changesReferenceRow[getNextChangingElement(index, white) + 1];
break;
default:
// Vertical mode (-3 to 3)
index = changesReferenceRow[getNextChangingElement(index, white)] + n.value;
changesCurrentRow[changesCurrentRowCount] = index;
changesCurrentRowCount++;
white = !white;
break;
runLength = decodeRun(white ? blackRunTree : whiteRunTree);
index += runLength;
changesCurrentRow[changesCurrentRowCount++] = index;
break;
case VALUE_PASSMODE:
int pChangingElement = getNextChangingElement(index, white) + 1;
if (pChangingElement >= changesReferenceRowCount || pChangingElement == -1) {
index = columns;
}
else {
index = changesReferenceRow[pChangingElement];
}
break;
default:
// Vertical mode (-3 to 3)
int vChangingElement = getNextChangingElement(index, white);
if (vChangingElement >= changesReferenceRowCount || vChangingElement == -1) {
index = columns + n.value;
}
else {
index = changesReferenceRow[vChangingElement] + n.value;
}
changesCurrentRow[changesCurrentRowCount] = index;
changesCurrentRowCount++;
white = !white;
break;
}
continue mode;
}
}
}
}
private int getNextChangingElement(int a0, boolean white) {
private int getNextChangingElement(final int a0, final boolean white) {
int start = white ? 0 : 1;
for (int i = start; i < changesReferenceRowCount; i += 2) {
if (a0 < changesReferenceRow[i]) {
if (a0 < changesReferenceRow[i] || (a0 == 0 && changesReferenceRow[i] == 0)) {
return i;
}
}
}
return 0;
return -1;
}
private void decodeRowType2() throws IOException {
@@ -214,20 +238,24 @@ final class CCITTFaxDecoderStream extends FilterInputStream {
eof: while (true) {
// read till next EOL code
Node n = eolOnlyTree.root;
while (true) {
Node tmp = n;
n = n.walk(readBit());
if (n == null)
if (n == null) {
continue eof;
}
if (n.isLeaf) {
break eof;
}
}
}
boolean k = optionG32D ? readBit() : true;
if (k) {
if (!optionG32D || readBit()) {
decode1D();
} else {
}
else {
decode2D();
}
}
@@ -238,23 +266,28 @@ final class CCITTFaxDecoderStream extends FilterInputStream {
private void decodeRow() throws IOException {
switch (type) {
case TIFFBaseline.COMPRESSION_CCITT_MODIFIED_HUFFMAN_RLE:
decodeRowType2();
break;
case TIFFExtension.COMPRESSION_CCITT_T4:
decodeRowType4();
break;
case TIFFExtension.COMPRESSION_CCITT_T6:
decodeRowType6();
break;
case TIFFBaseline.COMPRESSION_CCITT_MODIFIED_HUFFMAN_RLE:
decodeRowType2();
break;
case TIFFExtension.COMPRESSION_CCITT_T4:
decodeRowType4();
break;
case TIFFExtension.COMPRESSION_CCITT_T6:
decodeRowType6();
break;
}
int index = 0;
boolean white = true;
for (int i = 0; i <= changesCurrentRowCount; i++) {
int nextChange = columns;
if (i != changesCurrentRowCount) {
nextChange = changesCurrentRow[i];
}
if (nextChange > columns) {
nextChange = columns;
}
@@ -281,13 +314,14 @@ final class CCITTFaxDecoderStream extends FilterInputStream {
if (index % 8 == 0) {
decodedRow[byteIndex] = 0;
}
decodedRow[byteIndex] |= (white ? 0 : 1 << (7 - ((index) % 8)));
index++;
}
white = !white;
}
if (index != columns) {
throw new IOException("Sum of run-lengths does not equal scan line width: " + index + " > " + columns);
}
@@ -295,43 +329,42 @@ final class CCITTFaxDecoderStream extends FilterInputStream {
decodedLength = (index + 7) / 8;
}
private int decodeRun(Tree tree) throws IOException {
private int decodeRun(final Tree tree) throws IOException {
int total = 0;
Node n = tree.root;
while (true) {
boolean bit = readBit();
n = n.walk(bit);
if (n == null)
if (n == null) {
throw new IOException("Unknown code in Huffman RLE stream");
}
if (n.isLeaf) {
total += n.value;
if (n.value < 64) {
return total;
} else {
}
else {
n = tree.root;
continue;
}
}
}
}
private void resetBuffer() {
private void resetBuffer() throws IOException {
for (int i = 0; i < decodedRow.length; i++) {
decodedRow[i] = 0;
}
while (true) {
if (bufferPos == -1) {
return;
}
try {
boolean skip = readBit();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
readBit();
}
}
@@ -341,22 +374,29 @@ final class CCITTFaxDecoderStream extends FilterInputStream {
private boolean readBit() throws IOException {
if (bufferPos < 0 || bufferPos > 7) {
buffer = in.read();
if (buffer == -1) {
throw new EOFException("Unexpected end of Huffman RLE stream");
}
bufferPos = 0;
}
boolean isSet;
if (fillOrder == TIFFBaseline.FILL_LEFT_TO_RIGHT) {
isSet = ((buffer >> (7 - bufferPos)) & 1) == 1;
} else {
}
else {
isSet = ((buffer >> (bufferPos)) & 1) == 1;
}
bufferPos++;
if (bufferPos > 7)
if (bufferPos > 7) {
bufferPos = -1;
}
return isSet;
}
@@ -428,23 +468,25 @@ final class CCITTFaxDecoderStream extends FilterInputStream {
throw new IOException("mark/reset not supported");
}
static class Node {
private static final class Node {
Node left;
Node right;
int value; // > 63 non term.
boolean canBeFill = false;
boolean isLeaf = false;
void set(boolean next, Node node) {
void set(final boolean next, final Node node) {
if (!next) {
left = node;
} else {
}
else {
right = node;
}
}
Node walk(boolean next) {
Node walk(final boolean next) {
return next ? right : left;
}
@@ -454,51 +496,69 @@ final class CCITTFaxDecoderStream extends FilterInputStream {
}
}
static class Tree {
Node root = new Node();
private static final class Tree {
final Node root = new Node();
void fill(int depth, int path, int value) throws IOException {
void fill(final int depth, final int path, final int value) throws IOException {
Node current = root;
for (int i = 0; i < depth; i++) {
int bitPos = depth - 1 - i;
boolean isSet = ((path >> bitPos) & 1) == 1;
Node next = current.walk(isSet);
if (next == null) {
next = new Node();
if (i == depth - 1) {
next.value = value;
next.isLeaf = true;
}
if (path == 0)
if (path == 0) {
next.canBeFill = true;
}
current.set(isSet, next);
} else {
if (next.isLeaf)
throw new IOException("node is leaf, no other following");
}
else {
if (next.isLeaf) {
throw new IOException("node is leaf, no other following");
}
}
current = next;
}
}
void fill(int depth, int path, Node node) throws IOException {
void fill(final int depth, final int path, final Node node) throws IOException {
Node current = root;
for (int i = 0; i < depth; i++) {
int bitPos = depth - 1 - i;
boolean isSet = ((path >> bitPos) & 1) == 1;
Node next = current.walk(isSet);
if (next == null) {
if (i == depth - 1) {
next = node;
} else {
}
else {
next = new Node();
}
if (path == 0)
if (path == 0) {
next.canBeFill = true;
}
current.set(isSet, next);
} else {
if (next.isLeaf)
throw new IOException("node is leaf, no other following");
}
else {
if (next.isLeaf) {
throw new IOException("node is leaf, no other following");
}
}
current = next;
}
}
@@ -506,105 +566,148 @@ final class CCITTFaxDecoderStream extends FilterInputStream {
static final short[][] BLACK_CODES = {
{ // 2 bits
0x2, 0x3, },
0x2, 0x3,
},
{ // 3 bits
0x2, 0x3, },
0x2, 0x3,
},
{ // 4 bits
0x2, 0x3, },
0x2, 0x3,
},
{ // 5 bits
0x3, },
0x3,
},
{ // 6 bits
0x4, 0x5, },
0x4, 0x5,
},
{ // 7 bits
0x4, 0x5, 0x7, },
0x4, 0x5, 0x7,
},
{ // 8 bits
0x4, 0x7, },
0x4, 0x7,
},
{ // 9 bits
0x18, },
0x18,
},
{ // 10 bits
0x17, 0x18, 0x37, 0x8, 0xf, },
0x17, 0x18, 0x37, 0x8, 0xf,
},
{ // 11 bits
0x17, 0x18, 0x28, 0x37, 0x67, 0x68, 0x6c, 0x8, 0xc, 0xd, },
0x17, 0x18, 0x28, 0x37, 0x67, 0x68, 0x6c, 0x8, 0xc, 0xd,
},
{ // 12 bits
0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x1c, 0x1d, 0x1e, 0x1f, 0x24, 0x27, 0x28, 0x2b, 0x2c, 0x33,
0x34, 0x35, 0x37, 0x38, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5b, 0x64, 0x65,
0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xd2, 0xd3,
0xd4, 0xd5, 0xd6, 0xd7, 0xda, 0xdb, },
0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x1c, 0x1d, 0x1e, 0x1f, 0x24, 0x27, 0x28, 0x2b, 0x2c, 0x33,
0x34, 0x35, 0x37, 0x38, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5b, 0x64, 0x65,
0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xd2, 0xd3,
0xd4, 0xd5, 0xd6, 0xd7, 0xda, 0xdb,
},
{ // 13 bits
0x4a, 0x4b, 0x4c, 0x4d, 0x52, 0x53, 0x54, 0x55, 0x5a, 0x5b, 0x64, 0x65, 0x6c, 0x6d, 0x72, 0x73,
0x74, 0x75, 0x76, 0x77, } };
0x4a, 0x4b, 0x4c, 0x4d, 0x52, 0x53, 0x54, 0x55, 0x5a, 0x5b, 0x64, 0x65, 0x6c, 0x6d, 0x72, 0x73,
0x74, 0x75, 0x76, 0x77,
}
};
static final short[][] BLACK_RUN_LENGTHS = {
{ // 2 bits
3, 2, },
3, 2,
},
{ // 3 bits
1, 4, },
1, 4,
},
{ // 4 bits
6, 5, },
6, 5,
},
{ // 5 bits
7, },
7,
},
{ // 6 bits
9, 8, },
9, 8,
},
{ // 7 bits
10, 11, 12, },
10, 11, 12,
},
{ // 8 bits
13, 14, },
13, 14,
},
{ // 9 bits
15, },
15,
},
{ // 10 bits
16, 17, 0, 18, 64, },
16, 17, 0, 18, 64,
},
{ // 11 bits
24, 25, 23, 22, 19, 20, 21, 1792, 1856, 1920, },
24, 25, 23, 22, 19, 20, 21, 1792, 1856, 1920,
},
{ // 12 bits
1984, 2048, 2112, 2176, 2240, 2304, 2368, 2432, 2496, 2560, 52, 55, 56, 59, 60, 320, 384, 448, 53,
54, 50, 51, 44, 45, 46, 47, 57, 58, 61, 256, 48, 49, 62, 63, 30, 31, 32, 33, 40, 41, 128, 192, 26,
27, 28, 29, 34, 35, 36, 37, 38, 39, 42, 43, },
1984, 2048, 2112, 2176, 2240, 2304, 2368, 2432, 2496, 2560, 52, 55, 56, 59, 60, 320, 384, 448, 53,
54, 50, 51, 44, 45, 46, 47, 57, 58, 61, 256, 48, 49, 62, 63, 30, 31, 32, 33, 40, 41, 128, 192, 26,
27, 28, 29, 34, 35, 36, 37, 38, 39, 42, 43,
},
{ // 13 bits
640, 704, 768, 832, 1280, 1344, 1408, 1472, 1536, 1600, 1664, 1728, 512, 576, 896, 960, 1024, 1088,
1152, 1216, } };
640, 704, 768, 832, 1280, 1344, 1408, 1472, 1536, 1600, 1664, 1728, 512, 576, 896, 960, 1024, 1088,
1152, 1216,
}
};
public static final short[][] WHITE_CODES = {
{ // 4 bits
0x7, 0x8, 0xb, 0xc, 0xe, 0xf, },
0x7, 0x8, 0xb, 0xc, 0xe, 0xf,
},
{ // 5 bits
0x12, 0x13, 0x14, 0x1b, 0x7, 0x8, },
0x12, 0x13, 0x14, 0x1b, 0x7, 0x8,
},
{ // 6 bits
0x17, 0x18, 0x2a, 0x2b, 0x3, 0x34, 0x35, 0x7, 0x8, },
0x17, 0x18, 0x2a, 0x2b, 0x3, 0x34, 0x35, 0x7, 0x8,
},
{ // 7 bits
0x13, 0x17, 0x18, 0x24, 0x27, 0x28, 0x2b, 0x3, 0x37, 0x4, 0x8, 0xc, },
0x13, 0x17, 0x18, 0x24, 0x27, 0x28, 0x2b, 0x3, 0x37, 0x4, 0x8, 0xc,
},
{ // 8 bits
0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x1a, 0x1b, 0x2, 0x24, 0x25, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d,
0x3, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x4, 0x4a, 0x4b, 0x5, 0x52, 0x53, 0x54, 0x55, 0x58, 0x59,
0x5a, 0x5b, 0x64, 0x65, 0x67, 0x68, 0xa, 0xb, },
0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x1a, 0x1b, 0x2, 0x24, 0x25, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d,
0x3, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x4, 0x4a, 0x4b, 0x5, 0x52, 0x53, 0x54, 0x55, 0x58, 0x59,
0x5a, 0x5b, 0x64, 0x65, 0x67, 0x68, 0xa, 0xb,
},
{ // 9 bits
0x98, 0x99, 0x9a, 0x9b, 0xcc, 0xcd, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xdb, },
0x98, 0x99, 0x9a, 0x9b, 0xcc, 0xcd, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xdb,
},
{ // 10 bits
},
{ // 11 bits
0x8, 0xc, 0xd, },
0x8, 0xc, 0xd,
},
{ // 12 bits
0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x1c, 0x1d, 0x1e, 0x1f, } };
0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x1c, 0x1d, 0x1e, 0x1f,
}
};
public static final short[][] WHITE_RUN_LENGTHS = {
{ // 4 bits
2, 3, 4, 5, 6, 7, },
2, 3, 4, 5, 6, 7,
},
{ // 5 bits
128, 8, 9, 64, 10, 11, },
128, 8, 9, 64, 10, 11,
},
{ // 6 bits
192, 1664, 16, 17, 13, 14, 15, 1, 12, },
192, 1664, 16, 17, 13, 14, 15, 1, 12,
},
{ // 7 bits
26, 21, 28, 27, 18, 24, 25, 22, 256, 23, 20, 19, },
26, 21, 28, 27, 18, 24, 25, 22, 256, 23, 20, 19,
},
{ // 8 bits
33, 34, 35, 36, 37, 38, 31, 32, 29, 53, 54, 39, 40, 41, 42, 43, 44, 30, 61, 62, 63, 0, 320, 384, 45,
59, 60, 46, 49, 50, 51, 52, 55, 56, 57, 58, 448, 512, 640, 576, 47, 48, },
{ // 9
// bits
1472, 1536, 1600, 1728, 704, 768, 832, 896, 960, 1024, 1088, 1152, 1216, 1280, 1344, 1408, },
33, 34, 35, 36, 37, 38, 31, 32, 29, 53, 54, 39, 40, 41, 42, 43, 44, 30, 61, 62, 63, 0, 320, 384, 45,
59, 60, 46, 49, 50, 51, 52, 55, 56, 57, 58, 448, 512, 640, 576, 47, 48,
},
{ // 9 bits
1472, 1536, 1600, 1728, 704, 768, 832, 896, 960, 1024, 1088, 1152, 1216, 1280, 1344, 1408,
},
{ // 10 bits
},
{ // 11 bits
1792, 1856, 1920, },
1792, 1856, 1920,
},
{ // 12 bits
1984, 2048, 2112, 2176, 2240, 2304, 2368, 2432, 2496, 2560, } };
1984, 2048, 2112, 2176, 2240, 2304, 2368, 2432, 2496, 2560,
}
};
final static Node EOL;
final static Node FILL;
@@ -631,8 +734,9 @@ final class CCITTFaxDecoderStream extends FilterInputStream {
try {
eolOnlyTree.fill(12, 0, FILL);
eolOnlyTree.fill(12, 1, EOL);
} catch (Exception e) {
e.printStackTrace();
}
catch (IOException e) {
throw new AssertionError(e);
}
blackRunTree = new Tree();
@@ -644,9 +748,11 @@ final class CCITTFaxDecoderStream extends FilterInputStream {
}
blackRunTree.fill(12, 0, FILL);
blackRunTree.fill(12, 1, EOL);
} catch (Exception e) {
e.printStackTrace();
}
catch (IOException e) {
throw new AssertionError(e);
}
whiteRunTree = new Tree();
try {
for (int i = 0; i < WHITE_CODES.length; i++) {
@@ -654,10 +760,12 @@ final class CCITTFaxDecoderStream extends FilterInputStream {
whiteRunTree.fill(i + 4, WHITE_CODES[i][j], WHITE_RUN_LENGTHS[i][j]);
}
}
whiteRunTree.fill(12, 0, FILL);
whiteRunTree.fill(12, 1, EOL);
} catch (Exception e) {
e.printStackTrace();
}
catch (IOException e) {
throw new AssertionError(e);
}
codeTree = new Tree();
@@ -671,8 +779,9 @@ final class CCITTFaxDecoderStream extends FilterInputStream {
codeTree.fill(3, 2, -1); // V_L(1)
codeTree.fill(6, 2, -2); // V_L(2)
codeTree.fill(7, 2, -3); // V_L(3)
} catch (Exception e) {
e.printStackTrace();
}
catch (IOException e) {
throw new AssertionError(e);
}
}
}

1
imageio/imageio-tiff/src/main/java/com/twelvemonkeys/imageio/plugins/tiff/LZWDecoder.java
View File

@@ -190,7 +190,6 @@ abstract class LZWDecoder implements Decoder {
public static Decoder create(boolean oldBitReversedStream) {
return oldBitReversedStream ? new LZWCompatibilityDecoder() : new LZWSpecDecoder();
// return oldBitReversedStream ? new LZWCompatibilityDecoder() : new LZWTreeDecoder();
}
static final class LZWSpecDecoder extends LZWDecoder {

2
imageio/imageio-tiff/src/main/java/com/twelvemonkeys/imageio/plugins/tiff/TIFFExtension.java
View File

@@ -62,6 +62,8 @@ interface TIFFExtension {
int PREDICTOR_HORIZONTAL_DIFFERENCING = 2;
int PREDICTOR_HORIZONTAL_FLOATINGPOINT = 3;
int FILL_RIGHT_TO_LEFT = 2;
int SAMPLEFORMAT_INT = 2;
int SAMPLEFORMAT_FP = 3;
int SAMPLEFORMAT_UNDEFINED = 4;

534
imageio/imageio-tiff/src/main/java/com/twelvemonkeys/imageio/plugins/tiff/TIFFImageMetadata.java
View File

@@ -1,18 +1,24 @@
package com.twelvemonkeys.imageio.plugins.tiff;
import com.twelvemonkeys.imageio.AbstractMetadata;
import com.twelvemonkeys.imageio.metadata.AbstractDirectory;
import com.twelvemonkeys.imageio.metadata.Directory;
import com.twelvemonkeys.imageio.metadata.Entry;
import com.twelvemonkeys.imageio.metadata.exif.Rational;
import com.twelvemonkeys.imageio.metadata.exif.TIFF;
import com.twelvemonkeys.lang.Validate;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import javax.imageio.metadata.IIOInvalidTreeException;
import javax.imageio.metadata.IIOMetadataFormatImpl;
import javax.imageio.metadata.IIOMetadataNode;
import java.lang.reflect.Array;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Calendar;
import java.util.*;
/**
* TIFFImageMetadata.
@@ -21,18 +27,46 @@ import java.util.Calendar;
* @author last modified by $Author: harald.kuhr$
* @version $Id: TIFFImageMetadata.java,v 1.0 17/04/15 harald.kuhr Exp$
*/
final class TIFFImageMetadata extends AbstractMetadata {
public final class TIFFImageMetadata extends AbstractMetadata {
private final Directory ifd;
static final int RATIONAL_SCALE_FACTOR = 100000;
TIFFImageMetadata(final Directory ifd) {
super(true, TIFFMedataFormat.SUN_NATIVE_IMAGE_METADATA_FORMAT_NAME, TIFFMedataFormat.class.getName(), null, null);
this.ifd = Validate.notNull(ifd, "IFD");
private final Directory original;
private Directory ifd;
/**
* Creates an empty TIFF metadata object.
*
* Client code can update or change the metadata using the
* {@link #setFromTree(String, Node)}
* or {@link #mergeTree(String, Node)} methods.
*/
public TIFFImageMetadata() {
this(new TIFFIFD(Collections.<Entry>emptyList()));
}
@Override
public boolean isReadOnly() {
return false;
/**
* Creates a TIFF metadata object, using the values from the given IFD.
*
* Client code can update or change the metadata using the
* {@link #setFromTree(String, Node)}
* or {@link #mergeTree(String, Node)} methods.
*/
public TIFFImageMetadata(final Directory ifd) {
super(true, TIFFMedataFormat.SUN_NATIVE_IMAGE_METADATA_FORMAT_NAME, TIFFMedataFormat.class.getName(), null, null);
this.ifd = Validate.notNull(ifd, "IFD");
this.original = ifd;
}
/**
* Creates a TIFF metadata object, using the values from the given entries.
*
* Client code can update or change the metadata using the
* {@link #setFromTree(String, Node)}
* or {@link #mergeTree(String, Node)} methods.
*/
public TIFFImageMetadata(final Collection<Entry> entries) {
this(new TIFFIFD(entries));
}
protected IIOMetadataNode getNativeTree() {
@@ -99,7 +133,7 @@ final class TIFFImageMetadata extends AbstractMetadata {
IIOMetadataNode elementNode = new IIOMetadataNode(typeName);
valueNode.appendChild(elementNode);
setValue(value, unsigned, elementNode);
setTIFFNativeValue(value, unsigned, elementNode);
}
else {
for (int i = 0; i < count; i++) {
@@ -107,7 +141,7 @@ final class TIFFImageMetadata extends AbstractMetadata {
IIOMetadataNode elementNode = new IIOMetadataNode(typeName);
valueNode.appendChild(elementNode);
setValue(val, unsigned, elementNode);
setTIFFNativeValue(val, unsigned, elementNode);
}
}
}
@@ -119,7 +153,7 @@ final class TIFFImageMetadata extends AbstractMetadata {
return ifdNode;
}
private void setValue(final Object value, final boolean unsigned, final IIOMetadataNode elementNode) {
private void setTIFFNativeValue(final Object value, final boolean unsigned, final IIOMetadataNode elementNode) {
if (unsigned && value instanceof Byte) {
elementNode.setAttribute("value", String.valueOf((Byte) value & 0xFF));
}
@@ -289,12 +323,12 @@ final class TIFFImageMetadata extends AbstractMetadata {
// Handle ColorSpaceType (RGB/CMYK/YCbCr etc)...
Entry photometricTag = ifd.getEntryById(TIFF.TAG_PHOTOMETRIC_INTERPRETATION);
int photometricValue = ((Number) photometricTag.getValue()).intValue(); // No default for this tag!
int photometricValue = getValueAsInt(photometricTag); // No default for this tag!
Entry samplesPerPixelTag = ifd.getEntryById(TIFF.TAG_SAMPLES_PER_PIXEL);
Entry bitsPerSampleTag = ifd.getEntryById(TIFF.TAG_BITS_PER_SAMPLE);
int numChannelsValue = samplesPerPixelTag != null
? ((Number) samplesPerPixelTag.getValue()).intValue()
? getValueAsInt(samplesPerPixelTag)
: bitsPerSampleTag.valueCount();
IIOMetadataNode colorSpaceType = new IIOMetadataNode("ColorSpaceType");
@@ -393,7 +427,7 @@ final class TIFFImageMetadata extends AbstractMetadata {
Entry compressionTag = ifd.getEntryById(TIFF.TAG_COMPRESSION);
int compressionValue = compressionTag == null
? TIFFBaseline.COMPRESSION_NONE
: ((Number) compressionTag.getValue()).intValue();
: getValueAsInt(compressionTag);
// Naming is identical to JAI ImageIO metadata as far as possible
switch (compressionValue) {
@@ -502,7 +536,7 @@ final class TIFFImageMetadata extends AbstractMetadata {
Entry planarConfigurationTag = ifd.getEntryById(TIFF.TAG_PLANAR_CONFIGURATION);
int planarConfigurationValue = planarConfigurationTag == null
? TIFFBaseline.PLANARCONFIG_CHUNKY
: ((Number) planarConfigurationTag.getValue()).intValue();
: getValueAsInt(planarConfigurationTag);
switch (planarConfigurationValue) {
case TIFFBaseline.PLANARCONFIG_CHUNKY:
@@ -519,14 +553,16 @@ final class TIFFImageMetadata extends AbstractMetadata {
Entry photometricInterpretationTag = ifd.getEntryById(TIFF.TAG_PHOTOMETRIC_INTERPRETATION);
int photometricInterpretationValue = photometricInterpretationTag == null
? TIFFBaseline.PHOTOMETRIC_WHITE_IS_ZERO
: ((Number) photometricInterpretationTag.getValue()).intValue();
: getValueAsInt(photometricInterpretationTag);
Entry samleFormatTag = ifd.getEntryById(TIFF.TAG_SAMPLE_FORMAT);
// TODO: Fix for sampleformat 1 1 1 (as int[]) ??!?!?
int sampleFormatValue = samleFormatTag == null
? TIFFBaseline.SAMPLEFORMAT_UINT
: ((Number) samleFormatTag.getValue()).intValue();
: getValueAsInt(samleFormatTag);
IIOMetadataNode sampleFormat = new IIOMetadataNode("SampleFormat");
node.appendChild(sampleFormat);
switch (sampleFormatValue) {
case TIFFBaseline.SAMPLEFORMAT_UINT:
if (photometricInterpretationValue == TIFFBaseline.PHOTOMETRIC_PALETTE) {
@@ -562,13 +598,13 @@ final class TIFFImageMetadata extends AbstractMetadata {
Entry samplesPerPixelTag = ifd.getEntryById(TIFF.TAG_SAMPLES_PER_PIXEL);
int numChannelsValue = samplesPerPixelTag != null
? ((Number) samplesPerPixelTag.getValue()).intValue()
? getValueAsInt(samplesPerPixelTag)
: bitsPerSampleTag.valueCount();
// SampleMSB
Entry fillOrderTag = ifd.getEntryById(TIFF.TAG_FILL_ORDER);
int fillOrder = fillOrderTag != null
? ((Number) fillOrderTag.getValue()).intValue()
? getValueAsInt(fillOrderTag)
: TIFFBaseline.FILL_LEFT_TO_RIGHT;
IIOMetadataNode sampleMSB = new IIOMetadataNode("SampleMSB");
node.appendChild(sampleMSB);
@@ -588,6 +624,22 @@ final class TIFFImageMetadata extends AbstractMetadata {
return node;
}
private static int getValueAsInt(final Entry entry) {
Object value = entry.getValue();
if (value instanceof Number) {
return ((Number) value).intValue();
}
else if (value instanceof short[]) {
return ((short[]) value)[0];
}
else if (value instanceof int[]) {
return ((int[]) value)[0];
}
throw new IllegalArgumentException("Unsupported type: " + entry);
}
// TODO: Candidate superclass method!
private String createListValue(final int itemCount, final String... values) {
StringBuilder buffer = new StringBuilder();
@@ -620,7 +672,7 @@ final class TIFFImageMetadata extends AbstractMetadata {
// ImageOrientation
Entry orientationTag = ifd.getEntryById(TIFF.TAG_ORIENTATION);
if (orientationTag != null) {
int orientationValue = ((Number) orientationTag.getValue()).intValue();
int orientationValue = getValueAsInt(orientationTag);
String value = null;
switch (orientationValue) {
@@ -659,7 +711,7 @@ final class TIFFImageMetadata extends AbstractMetadata {
}
Entry resUnitTag = ifd.getEntryById(TIFF.TAG_RESOLUTION_UNIT);
int resUnitValue = resUnitTag == null ? TIFFBaseline.RESOLUTION_UNIT_DPI : ((Number) resUnitTag.getValue()).intValue();
int resUnitValue = resUnitTag == null ? TIFFBaseline.RESOLUTION_UNIT_DPI : getValueAsInt(resUnitTag);
if (resUnitValue == TIFFBaseline.RESOLUTION_UNIT_CENTIMETER || resUnitValue == TIFFBaseline.RESOLUTION_UNIT_DPI) {
// 10 mm in 1 cm or 25.4 mm in 1 inch
double scale = resUnitValue == TIFFBaseline.RESOLUTION_UNIT_CENTIMETER ? 10 : 25.4;
@@ -703,7 +755,7 @@ final class TIFFImageMetadata extends AbstractMetadata {
if (extraSamplesTag != null) {
int extraSamplesValue = (extraSamplesTag.getValue() instanceof Number)
? ((Number) extraSamplesTag.getValue()).intValue()
? getValueAsInt(extraSamplesTag)
: ((Number) Array.get(extraSamplesTag.getValue(), 0)).intValue();
// Other values exists, these are not alpha
@@ -739,7 +791,7 @@ final class TIFFImageMetadata extends AbstractMetadata {
if (subFileTypeTag != null) {
// NOTE: The JAI metadata is somewhat broken here, as these are bit flags, not values...
String value = null;
int subFileTypeValue = ((Number) subFileTypeTag.getValue()).intValue();
int subFileTypeValue = getValueAsInt(subFileTypeTag);
if ((subFileTypeValue & TIFFBaseline.FILETYPE_MASK) != 0) {
value = "TransparencyMask";
}
@@ -795,6 +847,7 @@ final class TIFFImageMetadata extends AbstractMetadata {
addTextEntryIfPresent(text, TIFF.TAG_IMAGE_DESCRIPTION);
addTextEntryIfPresent(text, TIFF.TAG_MAKE);
addTextEntryIfPresent(text, TIFF.TAG_MODEL);
addTextEntryIfPresent(text, TIFF.TAG_PAGE_NAME);
addTextEntryIfPresent(text, TIFF.TAG_SOFTWARE);
addTextEntryIfPresent(text, TIFF.TAG_ARTIST);
addTextEntryIfPresent(text, TIFF.TAG_HOST_COMPUTER);
@@ -821,4 +874,435 @@ final class TIFFImageMetadata extends AbstractMetadata {
// See http://stackoverflow.com/questions/30910719/javax-imageio-1-0-standard-plug-in-neutral-metadata-format-tiling-information
return super.getStandardTileNode();
}
/// Mutation
@Override
public boolean isReadOnly() {
return false;
}
public void setFromTree(final String formatName, final Node root) throws IIOInvalidTreeException {
// Standard validation
super.mergeTree(formatName, root);
// Set by "merging" with empty map
LinkedHashMap<Integer, Entry> entries = new LinkedHashMap<>();
mergeEntries(formatName, root, entries);
// TODO: Consistency validation?
// Finally create a new IFD from merged values
ifd = new TIFFIFD(entries.values());
}
@Override
public void mergeTree(final String formatName, final Node root) throws IIOInvalidTreeException {
// Standard validation
super.mergeTree(formatName, root);
// Clone entries (shallow clone, as entries themselves are immutable)
LinkedHashMap<Integer, Entry> entries = new LinkedHashMap<>(ifd.size() + 10);
for (Entry entry : ifd) {
entries.put((Integer) entry.getIdentifier(), entry);
}
mergeEntries(formatName, root, entries);
// TODO: Consistency validation?
// Finally create a new IFD from merged values
ifd = new TIFFIFD(entries.values());
}
private void mergeEntries(final String formatName, final Node root, final Map<Integer, Entry> entries) throws IIOInvalidTreeException {
// Merge from both native and standard trees
if (getNativeMetadataFormatName().equals(formatName)) {
mergeNativeTree(root, entries);
}
else if (IIOMetadataFormatImpl.standardMetadataFormatName.equals(formatName)) {
mergeStandardTree(root, entries);
}
else {
// Should already be checked for
throw new AssertionError();
}
}
private void mergeStandardTree(final Node root, final Map<Integer, Entry> entries) throws IIOInvalidTreeException {
NodeList nodes = root.getChildNodes();
// Merge selected values from standard tree
for (int i = 0; i < nodes.getLength(); i++) {
Node node = nodes.item(i);
if ("Dimension".equals(node.getNodeName())) {
mergeFromStandardDimensionNode(node, entries);
}
else if ("Document".equals(node.getNodeName())) {
mergeFromStandardDocumentNode(node, entries);
}
else if ("Text".equals(node.getNodeName())) {
mergeFromStandardTextNode(node, entries);
}
}
}
private void mergeFromStandardDimensionNode(final Node dimensionNode, final Map<Integer, Entry> entries) {
// Dimension: xRes/yRes
// - If set, set res unit to pixels per cm as this better reflects values?
// - Or, convert to DPI, if we already had values in DPI??
// Also, if we have only aspect, set these values, and use unknown as unit?
// TODO: ImageOrientation => Orientation
NodeList children = dimensionNode.getChildNodes();
Float aspect = null;
Float xRes = null;
Float yRes = null;
for (int i = 0; i < children.getLength(); i++) {
Node child = children.item(i);
String nodeName = child.getNodeName();
if ("PixelAspectRatio".equals(nodeName)) {
aspect = Float.parseFloat(getAttribute(child, "value"));
}
else if ("HorizontalPixelSize".equals(nodeName)) {
xRes = Float.parseFloat(getAttribute(child, "value"));
}
else if ("VerticalPixelSize".equals(nodeName)) {
yRes = Float.parseFloat(getAttribute(child, "value"));
}
}
// If we have one size compute the other
if (xRes == null && yRes != null) {
xRes = yRes * (aspect != null ? aspect : 1f);
}
else if (yRes == null && xRes != null) {
yRes = xRes / (aspect != null ? aspect : 1f);
}
// If we have resolution
if (xRes != null && yRes != null) {
// If old unit was DPI, convert values and keep DPI, otherwise use PPCM
Entry resUnitEntry = entries.get(TIFF.TAG_RESOLUTION_UNIT);
int resUnitValue = resUnitEntry != null && resUnitEntry.getValue() != null
&& ((Number) resUnitEntry.getValue()).intValue() == TIFFBaseline.RESOLUTION_UNIT_DPI
? TIFFBaseline.RESOLUTION_UNIT_DPI
: TIFFBaseline.RESOLUTION_UNIT_CENTIMETER;
// Units from standard format are pixels per mm, convert to cm or inches
float scale = resUnitValue == TIFFBaseline.RESOLUTION_UNIT_CENTIMETER ? 10 : 25.4f;
int x = Math.round(xRes * scale * RATIONAL_SCALE_FACTOR);
int y = Math.round(yRes * scale * RATIONAL_SCALE_FACTOR);
entries.put(TIFF.TAG_X_RESOLUTION, new TIFFImageWriter.TIFFEntry(TIFF.TAG_X_RESOLUTION, new Rational(x, RATIONAL_SCALE_FACTOR)));
entries.put(TIFF.TAG_Y_RESOLUTION, new TIFFImageWriter.TIFFEntry(TIFF.TAG_Y_RESOLUTION, new Rational(y, RATIONAL_SCALE_FACTOR)));
entries.put(TIFF.TAG_RESOLUTION_UNIT,
new TIFFImageWriter.TIFFEntry(TIFF.TAG_RESOLUTION_UNIT, TIFF.TYPE_SHORT, resUnitValue));
}
else if (aspect != null) {
if (aspect >= 1) {
int v = Math.round(aspect * RATIONAL_SCALE_FACTOR);
entries.put(TIFF.TAG_X_RESOLUTION, new TIFFImageWriter.TIFFEntry(TIFF.TAG_X_RESOLUTION, new Rational(v, RATIONAL_SCALE_FACTOR)));
entries.put(TIFF.TAG_Y_RESOLUTION, new TIFFImageWriter.TIFFEntry(TIFF.TAG_Y_RESOLUTION, new Rational(1)));
}
else {
int v = Math.round(RATIONAL_SCALE_FACTOR / aspect);
entries.put(TIFF.TAG_X_RESOLUTION, new TIFFImageWriter.TIFFEntry(TIFF.TAG_X_RESOLUTION, new Rational(1)));
entries.put(TIFF.TAG_Y_RESOLUTION, new TIFFImageWriter.TIFFEntry(TIFF.TAG_Y_RESOLUTION, new Rational(v, RATIONAL_SCALE_FACTOR)));
}
entries.put(TIFF.TAG_RESOLUTION_UNIT,
new TIFFImageWriter.TIFFEntry(TIFF.TAG_RESOLUTION_UNIT, TIFF.TYPE_SHORT, TIFFBaseline.RESOLUTION_UNIT_NONE));
}
// Else give up...
}
private void mergeFromStandardDocumentNode(final Node documentNode, final Map<Integer, Entry> entries) {
// Document: SubfileType, CreationDate
NodeList children = documentNode.getChildNodes();
for (int i = 0; i < children.getLength(); i++) {
Node child = children.item(i);
String nodeName = child.getNodeName();
if ("SubimageInterpretation".equals(nodeName)) {
// TODO: SubFileType
}
else if ("ImageCreationTime".equals(nodeName)) {
// TODO: CreationDate
}
}
}
private void mergeFromStandardTextNode(final Node textNode, final Map<Integer, Entry> entries) throws IIOInvalidTreeException {
NodeList textEntries = textNode.getChildNodes();
for (int i = 0; i < textEntries.getLength(); i++) {
Node textEntry = textEntries.item(i);
if (!"TextEntry".equals(textEntry.getNodeName())) {
throw new IIOInvalidTreeException("Text node should only contain TextEntry nodes", textNode);
}
String keyword = getAttribute(textEntry, "keyword");
String value = getAttribute(textEntry, "value");
// DocumentName, ImageDescription, Make, Model, PageName,
// Software, Artist, HostComputer, InkNames, Copyright
if (value != null && !value.isEmpty() && keyword != null) {
// We do all comparisons in lower case, for compatibility
keyword = keyword.toLowerCase();
TIFFImageWriter.TIFFEntry entry;
if ("documentname".equals(keyword)) {
entry = new TIFFImageWriter.TIFFEntry(TIFF.TAG_DOCUMENT_NAME, TIFF.TYPE_ASCII, value);
}
else if ("imagedescription".equals(keyword)) {
entry = new TIFFImageWriter.TIFFEntry(TIFF.TAG_IMAGE_DESCRIPTION, TIFF.TYPE_ASCII, value);
}
else if ("make".equals(keyword)) {
entry = new TIFFImageWriter.TIFFEntry(TIFF.TAG_MAKE, TIFF.TYPE_ASCII, value);
}
else if ("model".equals(keyword)) {
entry = new TIFFImageWriter.TIFFEntry(TIFF.TAG_MODEL, TIFF.TYPE_ASCII, value);
}
else if ("pagename".equals(keyword)) {
entry = new TIFFImageWriter.TIFFEntry(TIFF.TAG_PAGE_NAME, TIFF.TYPE_ASCII, value);
}
else if ("software".equals(keyword)) {
entry = new TIFFImageWriter.TIFFEntry(TIFF.TAG_SOFTWARE, TIFF.TYPE_ASCII, value);
}
else if ("artist".equals(keyword)) {
entry = new TIFFImageWriter.TIFFEntry(TIFF.TAG_ARTIST, TIFF.TYPE_ASCII, value);
}
else if ("hostcomputer".equals(keyword)) {
entry = new TIFFImageWriter.TIFFEntry(TIFF.TAG_HOST_COMPUTER, TIFF.TYPE_ASCII, value);
}
else if ("inknames".equals(keyword)) {
entry = new TIFFImageWriter.TIFFEntry(TIFF.TAG_INK_NAMES, TIFF.TYPE_ASCII, value);
}
else if ("copyright".equals(keyword)) {
entry = new TIFFImageWriter.TIFFEntry(TIFF.TAG_COPYRIGHT, TIFF.TYPE_ASCII, value);
}
else {
continue;
}
entries.put((Integer) entry.getIdentifier(), entry);
}
}
}
private void mergeNativeTree(final Node root, final Map<Integer, Entry> entries) throws IIOInvalidTreeException {
Directory ifd = toIFD(root.getFirstChild());
// Merge (overwrite) entries with entries from IFD
for (Entry entry : ifd) {
entries.put((Integer) entry.getIdentifier(), entry);
}
}
private Directory toIFD(final Node ifdNode) throws IIOInvalidTreeException {
if (ifdNode == null || !ifdNode.getNodeName().equals("TIFFIFD")) {
throw new IIOInvalidTreeException("Expected \"TIFFIFD\" node", ifdNode);
}
List<Entry> entries = new ArrayList<>();
NodeList nodes = ifdNode.getChildNodes();
for (int i = 0; i < nodes.getLength(); i++) {
entries.add(toEntry(nodes.item(i)));
}
return new TIFFIFD(entries);
}
private Entry toEntry(final Node node) throws IIOInvalidTreeException {
String name = node.getNodeName();
if (name.equals("TIFFIFD")) {
int tag = Integer.parseInt(getAttribute(node, "parentTagNumber"));
Directory subIFD = toIFD(node);
return new TIFFImageWriter.TIFFEntry(tag, TIFF.TYPE_IFD, subIFD);
}
else if (name.equals("TIFFField")) {
int tag = Integer.parseInt(getAttribute(node, "number"));
short type = getTIFFType(node);
Object value = getValue(node, type);
return value != null ? new TIFFImageWriter.TIFFEntry(tag, type, value) : null;
}
else {
throw new IIOInvalidTreeException("Expected \"TIFFIFD\" or \"TIFFField\" node: " + name, node);
}
}
private short getTIFFType(final Node node) throws IIOInvalidTreeException {
Node containerNode = node.getFirstChild();
if (containerNode == null) {
throw new IIOInvalidTreeException("Missing value wrapper node", node);
}
String nodeName = containerNode.getNodeName();
if (!nodeName.startsWith("TIFF")) {
throw new IIOInvalidTreeException("Unexpected value wrapper node, expected type", containerNode);
}
String typeName = nodeName.substring(4);
if (typeName.equals("Undefined")) {
return TIFF.TYPE_UNDEFINED;
}
typeName = typeName.substring(0, typeName.length() - 1).toUpperCase();
for (int i = 1; i < TIFF.TYPE_NAMES.length; i++) {
if (typeName.equals(TIFF.TYPE_NAMES[i])) {
return (short) i;
}
}
throw new IIOInvalidTreeException("Unknown TIFF type: " + typeName, containerNode);
}
private Object getValue(final Node node, final short type) throws IIOInvalidTreeException {
Node child = node.getFirstChild();
if (child != null) {
String typeName = child.getNodeName();
if (type == TIFF.TYPE_UNDEFINED) {
String values = getAttribute(child, "value");
String[] vals = values.split(",\\s?");
byte[] bytes = new byte[vals.length];
for (int i = 0; i < vals.length; i++) {
bytes[i] = Byte.parseByte(vals[i]);
}
return bytes;
}
else {
NodeList valueNodes = child.getChildNodes();
// Create array for each type
int count = valueNodes.getLength();
Object value = createArrayForType(type, count);
// Parse each value
for (int i = 0; i < count; i++) {
Node valueNode = valueNodes.item(i);
if (!typeName.startsWith(valueNode.getNodeName())) {
throw new IIOInvalidTreeException("Value node does not match container node", child);
}
String stringValue = getAttribute(valueNode, "value");
// NOTE: The reason for parsing "wider" type, is to allow for unsigned values
switch (type) {
case TIFF.TYPE_BYTE:
case TIFF.TYPE_SBYTE:
((byte[]) value)[i] = (byte) Short.parseShort(stringValue);
break;
case TIFF.TYPE_ASCII:
((String[]) value)[i] = stringValue;
break;
case TIFF.TYPE_SHORT:
case TIFF.TYPE_SSHORT:
((short[]) value)[i] = (short) Integer.parseInt(stringValue);
break;
case TIFF.TYPE_LONG:
case TIFF.TYPE_SLONG:
((int[]) value)[i] = (int) Long.parseLong(stringValue);
break;
case TIFF.TYPE_RATIONAL:
case TIFF.TYPE_SRATIONAL:
String[] numDenom = stringValue.split("/");
((Rational[]) value)[i] = numDenom.length > 1
? new Rational(Long.parseLong(numDenom[0]), Long.parseLong(numDenom[1]))
: new Rational(Long.parseLong(numDenom[0]));
break;
case TIFF.TYPE_FLOAT:
((float[]) value)[i] = Float.parseFloat(stringValue);
break;
case TIFF.TYPE_DOUBLE:
((double[]) value)[i] = Double.parseDouble(stringValue);
break;
default:
throw new AssertionError("Unsupported TIFF type: " + type);
}
}
// Normalize value
if (count == 0) {
return null;
}
if (count == 1) {
return Array.get(value, 0);
}
return value;
}
}
throw new IIOInvalidTreeException("Empty TIFField node", node);
}
private Object createArrayForType(final short type, final int length) {
switch (type) {
case TIFF.TYPE_ASCII:
return new String[length];
case TIFF.TYPE_BYTE:
case TIFF.TYPE_SBYTE:
case TIFF.TYPE_UNDEFINED: // Not used here, but for completeness
return new byte[length];
case TIFF.TYPE_SHORT:
case TIFF.TYPE_SSHORT:
return new short[length];
case TIFF.TYPE_LONG:
case TIFF.TYPE_SLONG:
return new int[length];
case TIFF.TYPE_IFD:
return new long[length];
case TIFF.TYPE_RATIONAL:
case TIFF.TYPE_SRATIONAL:
return new Rational[length];
case TIFF.TYPE_FLOAT:
return new float[length];
case TIFF.TYPE_DOUBLE:
return new double[length];
default:
throw new AssertionError("Unsupported TIFF type: " + type);
}
}
private String getAttribute(final Node node, final String attribute) {
return node instanceof Element ? ((Element) node).getAttribute(attribute) : null;
}
@Override
public void reset() {
super.reset();
ifd = original;
}
Directory getIFD() {
return ifd;
}
// TODO: Replace with IFD class when moved to new package and made public!
private final static class TIFFIFD extends AbstractDirectory {
public TIFFIFD(final Collection<Entry> entries) {
super(entries);
}
}
}

293
imageio/imageio-tiff/src/main/java/com/twelvemonkeys/imageio/plugins/tiff/TIFFImageReader.java
View File

@@ -36,7 +36,10 @@ import com.twelvemonkeys.imageio.metadata.Entry;
import com.twelvemonkeys.imageio.metadata.exif.EXIFReader;
import com.twelvemonkeys.imageio.metadata.exif.Rational;
import com.twelvemonkeys.imageio.metadata.exif.TIFF;
import com.twelvemonkeys.imageio.metadata.iptc.IPTCReader;
import com.twelvemonkeys.imageio.metadata.jpeg.JPEG;
import com.twelvemonkeys.imageio.metadata.psd.PSDReader;
import com.twelvemonkeys.imageio.metadata.xmp.XMPReader;
import com.twelvemonkeys.imageio.stream.ByteArrayImageInputStream;
import com.twelvemonkeys.imageio.stream.SubImageInputStream;
import com.twelvemonkeys.imageio.util.IIOUtil;
@@ -58,13 +61,16 @@ import javax.imageio.spi.ImageReaderSpi;
import javax.imageio.spi.ServiceRegistry;
import javax.imageio.stream.ImageInputStream;
import java.awt.*;
import java.awt.color.CMMException;
import java.awt.color.ColorSpace;
import java.awt.color.ICC_Profile;
import java.awt.image.*;
import java.io.*;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.charset.StandardCharsets;
import java.util.*;
import java.util.zip.Inflater;
import java.util.zip.InflaterInputStream;
@@ -82,15 +88,16 @@ import java.util.zip.InflaterInputStream;
* In addition, it supports many common TIFF extensions such as:
* <ul>
* <li>Tiling</li>
* <li>Class F (Facsimile), CCITT T.4 and T.6 compression (types 3 and 4), 1 bit per sample</li>
* <li>LZW Compression (type 5)</li>
* <li>"Old-style" JPEG Compression (type 6), as a best effort, as the spec is not well-defined</li>
* <li>JPEG Compression (type 7)</li>
* <li>ZLib (aka Adobe-style Deflate) Compression (type 8)</li>
* <li>Deflate Compression (type 32946)</li>
* <li>Horizontal differencing Predictor (type 2) for LZW, ZLib, Deflate and PackBits compression</li>
* <li>Alpha channel (ExtraSamples type 1/Associated Alpha)</li>
* <li>CMYK data (PhotometricInterpretation type 5/Separated)</li>
* <li>YCbCr data (PhotometricInterpretation type 6/YCbCr) for JPEG</li>
* <li>Alpha channel (ExtraSamples types 1/Associated Alpha and 2/Unassociated Alpha)</li>
* <li>Class S, CMYK data (PhotometricInterpretation type 5/Separated)</li>
* <li>Class Y, YCbCr data (PhotometricInterpretation type 6/YCbCr for both JPEG and other compressions</li>
* <li>Planar data (PlanarConfiguration type 2/Planar)</li>
* <li>ICC profiles (ICCProfile)</li>
* <li>BitsPerSample values up to 16 for most PhotometricInterpretations</li>
@@ -119,7 +126,6 @@ public class TIFFImageReader extends ImageReaderBase {
// TODO: Implement readAsRenderedImage to allow tiled RenderedImage?
// For some layouts, we could do reads super-fast with a memory mapped buffer.
// TODO: Implement readAsRaster directly
// TODO: IIOMetadata (stay close to Sun's TIFF metadata)
// http://download.java.net/media/jai-imageio/javadoc/1.1/com/sun/media/imageio/plugins/tiff/package-summary.html#ImageMetadata
// TODOs Extension support
@@ -136,6 +142,7 @@ public class TIFFImageReader extends ImageReaderBase {
// Support Compression 2 (CCITT Modified Huffman RLE) for bi-level images
// Source region
// Subsampling
// IIOMetadata (stay close to Sun's TIFF metadata)
final static boolean DEBUG = "true".equalsIgnoreCase(System.getProperty("com.twelvemonkeys.imageio.plugins.tiff.debug"));
@@ -167,6 +174,73 @@ public class TIFFImageReader extends ImageReaderBase {
for (int i = 0; i < IFDs.directoryCount(); i++) {
System.err.printf("IFD %d: %s\n", i, IFDs.getDirectory(i));
}
Entry tiffXMP = IFDs.getEntryById(TIFF.TAG_XMP);
if (tiffXMP != null) {
byte[] value = (byte[]) tiffXMP.getValue();
// The XMPReader doesn't like null-termination...
int len = value.length;
for (int i = len - 1; i > 0; i--) {
if (value[i] == 0) {
len--;
}
else {
break;
}
}
Directory xmp = new XMPReader().read(new ByteArrayImageInputStream(value, 0, len));
System.err.println("-----------------------------------------------------------------------------");
System.err.println("xmp: " + xmp);
}
Entry tiffIPTC = IFDs.getEntryById(TIFF.TAG_IPTC);
if (tiffIPTC != null) {
Object value = tiffIPTC.getValue();
if (value instanceof short[]) {
System.err.println("short[]: " + value);
}
if (value instanceof long[]) {
// As seen in a Magick produced image...
System.err.println("long[]: " + value);
long[] longs = (long[]) value;
value = new byte[longs.length * 8];
ByteBuffer.wrap((byte[]) value).asLongBuffer().put(longs);
}
if (value instanceof float[]) {
System.err.println("float[]: " + value);
}
if (value instanceof double[]) {
System.err.println("double[]: " + value);
}
Directory iptc = new IPTCReader().read(new ByteArrayImageInputStream((byte[]) value));
System.err.println("-----------------------------------------------------------------------------");
System.err.println("iptc: " + iptc);
}
Entry tiffPSD = IFDs.getEntryById(TIFF.TAG_PHOTOSHOP);
if (tiffPSD != null) {
Directory psd = new PSDReader().read(new ByteArrayImageInputStream((byte[]) tiffPSD.getValue()));
System.err.println("-----------------------------------------------------------------------------");
System.err.println("psd: " + psd);
}
Entry tiffPSD2 = IFDs.getEntryById(TIFF.TAG_PHOTOSHOP_IMAGE_SOURCE_DATA);
if (tiffPSD2 != null) {
byte[] value = (byte[]) tiffPSD2.getValue();
String foo = "Adobe Photoshop Document Data Block";
if (Arrays.equals(foo.getBytes(StandardCharsets.US_ASCII), Arrays.copyOf(value, foo.length()))) {
System.err.println("foo: " + foo);
// int offset = foo.length() + 1;
// ImageInputStream input = new ByteArrayImageInputStream(value, offset, value.length - offset);
// input.setByteOrder(ByteOrder.LITTLE_ENDIAN); // TODO: WHY???!
// Directory psd2 = new PSDReader().read(input);
// System.err.println("-----------------------------------------------------------------------------");
// System.err.println("psd2: " + psd2);
}
}
}
}
}
@@ -260,7 +334,8 @@ public class TIFFImageReader extends ImageReaderBase {
switch (samplesPerPixel) {
case 1:
// TIFF 6.0 Spec says: 1, 4 or 8 for baseline (1 for bi-level, 4/8 for gray)
// ImageTypeSpecifier supports 1, 2, 4, 8 or 16 bits, we'll go with that for now
// ImageTypeSpecifier supports 1, 2, 4, 8 or 16 bits per sample, we'll support 32 bits as well.
// (Chunky or planar makes no difference for a single channel).
if (profile != null && profile.getColorSpaceType() != ColorSpace.TYPE_GRAY) {
processWarningOccurred(String.format("Embedded ICC color profile (type %s), is incompatible with image data (GRAY/type 6). Ignoring profile.", profile.getColorSpaceType()));
profile = null;
@@ -274,10 +349,46 @@ public class TIFFImageReader extends ImageReaderBase {
else if (bitsPerSample == 1 || bitsPerSample == 2 || bitsPerSample == 4 || bitsPerSample == 8 || bitsPerSample == 16 || bitsPerSample == 32) {
return ImageTypeSpecifiers.createInterleaved(cs, new int[] {0}, dataType, false, false);
}
default:
// TODO: If ExtraSamples is used, PlanarConfiguration must be taken into account also for gray data
throw new IIOException(String.format("Unsupported SamplesPerPixel/BitsPerSample combination for Bi-level/Gray TIFF (expected 1/1, 1/2, 1/4, 1/8 or 1/16): %d/%d", samplesPerPixel, bitsPerSample));
throw new IIOException(String.format("Unsupported BitsPerSample for Bi-level/Gray TIFF (expected 1, 2, 4, 8, 16 or 32): %d", bitsPerSample));
case 2:
// Gray + alpha. We'll support:
// * 8, 16 or 32 bits per sample
// * Associated (pre-multiplied) or unassociated (non-pre-multiplied) alpha
// * Chunky (interleaved) or planar (banded) data
if (profile != null && profile.getColorSpaceType() != ColorSpace.TYPE_GRAY) {
processWarningOccurred(String.format("Embedded ICC color profile (type %s), is incompatible with image data (GRAY/type 6). Ignoring profile.", profile.getColorSpaceType()));
profile = null;
}
cs = profile == null ? ColorSpace.getInstance(ColorSpace.CS_GRAY) : ColorSpaces.createColorSpace(profile);
// ExtraSamples 0=unspecified, 1=associated (pre-multiplied), 2=unassociated (TODO: Support unspecified, not alpha)
long[] extraSamples = getValueAsLongArray(TIFF.TAG_EXTRA_SAMPLES, "ExtraSamples", true);
if (cs == ColorSpace.getInstance(ColorSpace.CS_GRAY) && (bitsPerSample == 8 || bitsPerSample == 16 || bitsPerSample == 32)) {
switch (planarConfiguration) {
case TIFFBaseline.PLANARCONFIG_CHUNKY:
return ImageTypeSpecifiers.createGrayscale(bitsPerSample, dataType, extraSamples[0] == 1);
case TIFFExtension.PLANARCONFIG_PLANAR:
return ImageTypeSpecifiers.createBanded(cs, new int[] {0, 1}, new int[] {0, 0}, dataType, true, extraSamples[0] == 1);
}
}
else if (bitsPerSample == 8 || bitsPerSample == 16 || bitsPerSample == 32) {
switch (planarConfiguration) {
case TIFFBaseline.PLANARCONFIG_CHUNKY:
return ImageTypeSpecifiers.createInterleaved(cs, new int[] {0, 1}, dataType, true, extraSamples[0] == 1);
case TIFFExtension.PLANARCONFIG_PLANAR:
return ImageTypeSpecifiers.createBanded(cs, new int[] {0, 1}, new int[] {0, 0}, dataType, true, extraSamples[0] == 1);
}
}
throw new IIOException(String.format("Unsupported BitsPerSample for Gray + Alpha TIFF (expected 8, 16 or 32): %d", bitsPerSample));
// TODO: More samples might be ok, if multiple alpha or unknown samples
default:
throw new IIOException(String.format("Unsupported SamplesPerPixel/BitsPerSample combination for Bi-level/Gray TIFF (expected 1/1, 1/2, 1/4, 1/8, 1/16 or 1/32, or 2/8, 2/16 or 2/32): %d/%d", samplesPerPixel, bitsPerSample));
}
case TIFFExtension.PHOTOMETRIC_YCBCR:
@@ -324,6 +435,11 @@ public class TIFFImageReader extends ImageReaderBase {
return ImageTypeSpecifiers.createBanded(cs, new int[] {0, 1, 2, 3}, new int[] {0, 0, 0, 0}, dataType, true, extraSamples[0] == 1);
}
}
else if (bitsPerSample == 4) {
long[] extraSamples = getValueAsLongArray(TIFF.TAG_EXTRA_SAMPLES, "ExtraSamples", true);
return ImageTypeSpecifier.createPacked(cs, 0xF000, 0xF00, 0xF0, 0xF, DataBuffer.TYPE_USHORT, extraSamples[0] == 1);
}
// TODO: More samples might be ok, if multiple alpha or unknown samples
default:
throw new IIOException(String.format("Unsupported SamplesPerPixels/BitsPerSample combination for RGB TIFF (expected 3/8, 4/8, 3/16 or 4/16): %d/%d", samplesPerPixel, bitsPerSample));
@@ -411,14 +527,32 @@ public class TIFFImageReader extends ImageReaderBase {
case TIFFBaseline.SAMPLEFORMAT_UINT:
return bitsPerSample <= 8 ? DataBuffer.TYPE_BYTE : bitsPerSample <= 16 ? DataBuffer.TYPE_USHORT : DataBuffer.TYPE_INT;
case TIFFExtension.SAMPLEFORMAT_INT:
if (bitsPerSample == 16) {
return DataBuffer.TYPE_SHORT;
switch (bitsPerSample) {
case 8:
return DataBuffer.TYPE_BYTE;
case 16:
return DataBuffer.TYPE_SHORT;
case 32:
return DataBuffer.TYPE_INT;
}
throw new IIOException("Unsupported BitPerSample for SampleFormat 2/Signed Integer (expected 16): " + bitsPerSample);
throw new IIOException("Unsupported BitsPerSample for SampleFormat 2/Signed Integer (expected 8/16/32): " + bitsPerSample);
case TIFFExtension.SAMPLEFORMAT_FP:
throw new IIOException("Unsupported TIFF SampleFormat: (3/Floating point)");
if (bitsPerSample == 32) {
return DataBuffer.TYPE_FLOAT;
}
throw new IIOException("Unsupported BitsPerSample for SampleFormat 3/Floating Point (expected 32): " + bitsPerSample);
case TIFFExtension.SAMPLEFORMAT_UNDEFINED:
throw new IIOException("Unsupported TIFF SampleFormat (4/Undefined)");
// Spec says:
// A field value of “undefined” is a statement by the writer that it did not know how
// to interpret the data samples; for example, if it were copying an existing image. A
// reader would typically treat an image with “undefined” data as if the field were
// not present (i.e. as unsigned integer data).
// TODO: We should probably issue a warning instead, and assume SAMPLEFORMAT_UINT
throw new IIOException("Unsupported TIFF SampleFormat: 4 (Undefined)");
default:
throw new IIOException("Unknown TIFF SampleFormat (expected 1, 2, 3 or 4): " + sampleFormat);
}
@@ -585,7 +719,8 @@ public class TIFFImageReader extends ImageReaderBase {
int tilesAcross = (width + stripTileWidth - 1) / stripTileWidth;
int tilesDown = (height + stripTileHeight - 1) / stripTileHeight;
WritableRaster rowRaster = rawType.getColorModel().createCompatibleWritableRaster(stripTileWidth, 1);
// WritableRaster rowRaster = rawType.getColorModel().createCompatibleWritableRaster(stripTileWidth, 1);
WritableRaster rowRaster = rawType.createBufferedImage(stripTileWidth, 1).getRaster();
Rectangle clip = new Rectangle(srcRegion);
int row = 0;
@@ -888,7 +1023,7 @@ public class TIFFImageReader extends ImageReaderBase {
imageInput.seek(realJPEGOffset);
stream = new SubImageInputStream(imageInput, jpegLenght != -1 ? jpegLenght : Short.MAX_VALUE);
stream = new SubImageInputStream(imageInput, jpegLenght != -1 ? jpegLenght : Integer.MAX_VALUE);
jpegReader.setInput(stream);
// Read data
@@ -1259,6 +1394,46 @@ public class TIFFImageReader extends ImageReaderBase {
}
break;
case DataBuffer.TYPE_FLOAT:
float[] rowDataFloat = ((DataBufferFloat) tileRowRaster.getDataBuffer()).getData();
for (int row = startRow; row < startRow + rowsInTile; row++) {
if (row >= srcRegion.y + srcRegion.height) {
break; // We're done with this tile
}
readFully(input, rowDataFloat);
if (row >= srcRegion.y) {
// normalizeBlack(interpretation, rowDataFloat);
// Subsample horizontal
if (xSub != 1) {
for (int x = srcRegion.x / xSub * numBands; x < ((srcRegion.x + srcRegion.width) / xSub) * numBands; x += numBands) {
System.arraycopy(rowDataFloat, x * xSub, rowDataFloat, x, numBands);
}
}
raster.setDataElements(startCol, row - srcRegion.y, tileRowRaster);
}
// Else skip data
}
break;
}
}
// TODO: Candidate util method (with off/len + possibly byte order)
private void readFully(final DataInput input, final float[] rowDataFloat) throws IOException {
if (input instanceof ImageInputStream) {
ImageInputStream imageInputStream = (ImageInputStream) input;
imageInputStream.readFully(rowDataFloat, 0, rowDataFloat.length);
}
else {
for (int k = 0; k < rowDataFloat.length; k++) {
rowDataFloat[k] = input.readFloat();
}
}
}
@@ -1322,7 +1497,7 @@ public class TIFFImageReader extends ImageReaderBase {
case TIFFBaseline.COMPRESSION_PACKBITS:
return new DecoderStream(stream, new PackBitsDecoder(), 1024);
case TIFFExtension.COMPRESSION_LZW:
return new DecoderStream(stream, LZWDecoder.create(LZWDecoder.isOldBitReversedStream(stream)), width * bands);
return new DecoderStream(stream, LZWDecoder.create(LZWDecoder.isOldBitReversedStream(stream)), Math.max(width * bands, 1024));
case TIFFExtension.COMPRESSION_ZLIB:
// TIFFphotoshop.pdf (aka TIFF specification, supplement 2) says ZLIB (8) and DEFLATE (32946) algorithms are identical
case TIFFExtension.COMPRESSION_DEFLATE:
@@ -1394,14 +1569,24 @@ public class TIFFImageReader extends ImageReaderBase {
return value;
}
public ICC_Profile getICCProfile() {
private ICC_Profile getICCProfile() throws IOException {
Entry entry = currentIFD.getEntryById(TIFF.TAG_ICC_PROFILE);
if (entry == null) {
return null;
if (entry != null) {
byte[] value = (byte[]) entry.getValue();
try {
// WEIRDNESS: Reading profile from InputStream is somehow more compatible
// than reading from byte array (chops off extra bytes + validates profile).
ICC_Profile profile = ICC_Profile.getInstance(new ByteArrayInputStream(value));
return ColorSpaces.validateProfile(profile);
}
catch (CMMException | IllegalArgumentException ignore) {
processWarningOccurred("Ignoring broken/incompatible ICC profile: " + ignore.getMessage());
}
}
byte[] value = (byte[]) entry.getValue();
return ICC_Profile.getInstance(value);
return null;
}
// TODO: Tiling support
@@ -1500,27 +1685,30 @@ public class TIFFImageReader extends ImageReaderBase {
// param.setSourceSubsampling(sub, sub, 0, 0);
// }
long start = System.currentTimeMillis();
try {
long start = System.currentTimeMillis();
// int width = reader.getWidth(imageNo);
// int height = reader.getHeight(imageNo);
// param.setSourceRegion(new Rectangle(width / 4, height / 4, width / 2, height / 2));
// param.setSourceRegion(new Rectangle(100, 300, 400, 400));
// param.setSourceRegion(new Rectangle(3, 3, 9, 9));
// param.setDestinationOffset(new Point(50, 150));
// param.setSourceSubsampling(2, 2, 0, 0);
BufferedImage image = reader.read(imageNo, param);
System.err.println("Read time: " + (System.currentTimeMillis() - start) + " ms");
BufferedImage image = reader.read(imageNo, param);
System.err.println("Read time: " + (System.currentTimeMillis() - start) + " ms");
IIOMetadata metadata = reader.getImageMetadata(imageNo);
if (metadata != null) {
if (metadata.getNativeMetadataFormatName() != null) {
new XMLSerializer(System.out, "UTF-8").serialize(metadata.getAsTree(metadata.getNativeMetadataFormatName()), false);
IIOMetadata metadata = reader.getImageMetadata(imageNo);
if (metadata != null) {
if (metadata.getNativeMetadataFormatName() != null) {
new XMLSerializer(System.out, "UTF-8").serialize(metadata.getAsTree(metadata.getNativeMetadataFormatName()), false);
}
/*else*/
if (metadata.isStandardMetadataFormatSupported()) {
new XMLSerializer(System.out, "UTF-8").serialize(metadata.getAsTree(IIOMetadataFormatImpl.standardMetadataFormatName), false);
}
}
/*else*/ if (metadata.isStandardMetadataFormatSupported()) {
new XMLSerializer(System.out, "UTF-8").serialize(metadata.getAsTree(IIOMetadataFormatImpl.standardMetadataFormatName), false);
}
}
System.err.println("image: " + image);
System.err.println("image: " + image);
// File tempFile = File.createTempFile("lzw-", ".bin");
// byte[] data = ((DataBufferByte) image.getRaster().getDataBuffer()).getData();
@@ -1536,7 +1724,7 @@ public class TIFFImageReader extends ImageReaderBase {
//
// System.err.println("tempFile: " + tempFile.getAbsolutePath());
// image = new ResampleOp(reader.getWidth(0) / 4, reader.getHeight(0) / 4, ResampleOp.FILTER_LANCZOS).filter(image, null);
// image = new ResampleOp(reader.getWidth(0) / 4, reader.getHeight(0) / 4, ResampleOp.FILTER_LANCZOS).filter(image, null);
//
// int maxW = 800;
// int maxH = 800;
@@ -1553,30 +1741,35 @@ public class TIFFImageReader extends ImageReaderBase {
// // System.err.println("Scale time: " + (System.currentTimeMillis() - start) + " ms");
// }
if (image.getType() == BufferedImage.TYPE_CUSTOM) {
start = System.currentTimeMillis();
image = new ColorConvertOp(null).filter(image, new BufferedImage(image.getWidth(), image.getHeight(), BufferedImage.TYPE_INT_ARGB));
System.err.println("Conversion time: " + (System.currentTimeMillis() - start) + " ms");
}
if (image.getType() == BufferedImage.TYPE_CUSTOM) {
start = System.currentTimeMillis();
image = new ColorConvertOp(null).filter(image, new BufferedImage(image.getWidth(), image.getHeight(), BufferedImage.TYPE_INT_ARGB));
System.err.println("Conversion time: " + (System.currentTimeMillis() - start) + " ms");
}
showIt(image, String.format("Image: %s [%d x %d]", file.getName(), reader.getWidth(imageNo), reader.getHeight(imageNo)));
showIt(image, String.format("Image: %s [%d x %d]", file.getName(), reader.getWidth(imageNo), reader.getHeight(imageNo)));
try {
int numThumbnails = reader.getNumThumbnails(0);
for (int thumbnailNo = 0; thumbnailNo < numThumbnails; thumbnailNo++) {
BufferedImage thumbnail = reader.readThumbnail(imageNo, thumbnailNo);
// System.err.println("thumbnail: " + thumbnail);
showIt(thumbnail, String.format("Thumbnail: %s [%d x %d]", file.getName(), thumbnail.getWidth(), thumbnail.getHeight()));
try {
int numThumbnails = reader.getNumThumbnails(0);
for (int thumbnailNo = 0; thumbnailNo < numThumbnails; thumbnailNo++) {
BufferedImage thumbnail = reader.readThumbnail(imageNo, thumbnailNo);
// System.err.println("thumbnail: " + thumbnail);
showIt(thumbnail, String.format("Thumbnail: %s [%d x %d]", file.getName(), thumbnail.getWidth(), thumbnail.getHeight()));
}
}
catch (IIOException e) {
System.err.println("Could not read thumbnails: " + e.getMessage());
e.printStackTrace();
}
}
catch (IIOException e) {
System.err.println("Could not read thumbnails: " + e.getMessage());
e.printStackTrace();
catch (Throwable t) {
System.err.println(file + " image " + imageNo + " can't be read:");
t.printStackTrace();
}
}
}
catch (Throwable t) {
System.err.println(file);
System.err.println(file + " can't be read:");
t.printStackTrace();
}
finally {

192
imageio/imageio-tiff/src/main/java/com/twelvemonkeys/imageio/plugins/tiff/TIFFImageWriter.java
View File

@@ -31,6 +31,7 @@ package com.twelvemonkeys.imageio.plugins.tiff;
import com.twelvemonkeys.image.ImageUtil;
import com.twelvemonkeys.imageio.ImageWriterBase;
import com.twelvemonkeys.imageio.metadata.AbstractEntry;
import com.twelvemonkeys.imageio.metadata.Directory;
import com.twelvemonkeys.imageio.metadata.Entry;
import com.twelvemonkeys.imageio.metadata.exif.EXIFWriter;
import com.twelvemonkeys.imageio.metadata.exif.Rational;
@@ -39,9 +40,12 @@ import com.twelvemonkeys.imageio.stream.SubImageOutputStream;
import com.twelvemonkeys.imageio.util.IIOUtil;
import com.twelvemonkeys.io.enc.EncoderStream;
import com.twelvemonkeys.io.enc.PackBitsEncoder;
import com.twelvemonkeys.lang.Validate;
import javax.imageio.*;
import javax.imageio.metadata.IIOInvalidTreeException;
import javax.imageio.metadata.IIOMetadata;
import javax.imageio.metadata.IIOMetadataFormatImpl;
import javax.imageio.spi.ImageWriterSpi;
import javax.imageio.stream.ImageInputStream;
import javax.imageio.stream.ImageOutputStream;
@@ -50,10 +54,9 @@ import java.awt.color.ColorSpace;
import java.awt.color.ICC_ColorSpace;
import java.awt.image.*;
import java.io.*;
import java.lang.reflect.Array;
import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.*;
import java.util.zip.Deflater;
import java.util.zip.DeflaterOutputStream;
@@ -65,13 +68,16 @@ import java.util.zip.DeflaterOutputStream;
* @version $Id: TIFFImageWriter.java,v 1.0 18.09.13 12:46 haraldk Exp$
*/
public final class TIFFImageWriter extends ImageWriterBase {
// Short term
// TODO: Support more of the ImageIO metadata (ie. compression from metadata, etc)
// Long term
// TODO: Support tiling
// TODO: Support thumbnails
// TODO: Support ImageIO metadata
// TODO: Support CCITT Modified Huffman compression (2)
// TODO: Full "Baseline TIFF" support (pending CCITT compression 2)
// TODO: CCITT compressions T.4 and T.6
// TODO: Support JPEG compression of CMYK data (pending JPEGImageWriter CMYK write support)
// ----
// TODO: Support storing multiple images in one stream (multi-page TIFF)
// TODO: Support use-case: Transcode multi-layer PSD to multi-page TIFF with metadata
@@ -91,6 +97,7 @@ public final class TIFFImageWriter extends ImageWriterBase {
// Support LZW compression (5)
// Support JPEG compression (7) - might need extra input to allow multiple images with single DQT
// Use sensible defaults for compression based on input? None is sensible... :-)
// Support resolution, resolution unit and software tags from ImageIO metadata
public static final Rational STANDARD_DPI = new Rational(72);
@@ -98,14 +105,81 @@ public final class TIFFImageWriter extends ImageWriterBase {
super(provider);
}
@Override
public void setOutput(final Object output) {
super.setOutput(output);
// TODO: Allow appending/partly overwrite of existing file...
}
static final class TIFFEntry extends AbstractEntry {
TIFFEntry(Object identifier, Object value) {
// TODO: Expose a merge of this and the EXIFEntry class...
private final short type;
private static short guessType(final Object val) {
// TODO: This code is duplicated in EXIFWriter.getType, needs refactor!
Object value = Validate.notNull(val);
boolean array = value.getClass().isArray();
if (array) {
value = Array.get(value, 0);
}
// Note: This "narrowing" is to keep data consistent between read/write.
// TODO: Check for negative values and use signed types?
if (value instanceof Byte) {
return TIFF.TYPE_BYTE;
}
if (value instanceof Short) {
if (!array && (Short) value < Byte.MAX_VALUE) {
return TIFF.TYPE_BYTE;
}
return TIFF.TYPE_SHORT;
}
if (value instanceof Integer) {
if (!array && (Integer) value < Short.MAX_VALUE) {
return TIFF.TYPE_SHORT;
}
return TIFF.TYPE_LONG;
}
if (value instanceof Long) {
if (!array && (Long) value < Integer.MAX_VALUE) {
return TIFF.TYPE_LONG;
}
}
if (value instanceof Rational) {
return TIFF.TYPE_RATIONAL;
}
if (value instanceof String) {
return TIFF.TYPE_ASCII;
}
// TODO: More types
throw new UnsupportedOperationException(String.format("Method guessType not implemented for value of type %s", value.getClass()));
}
TIFFEntry(final int identifier, final Object value) {
this(identifier, guessType(value), value);
}
TIFFEntry(int identifier, short type, Object value) {
super(identifier, value);
this.type = type;
}
@Override
public String getTypeName() {
return TIFF.TYPE_NAMES[type];
}
}
@Override
public void write(IIOMetadata streamMetadata, IIOImage image, ImageWriteParam param) throws IOException {
public void write(final IIOMetadata streamMetadata, final IIOImage image, final ImageWriteParam param) throws IOException {
// TODO: Validate input
assertOutput();
@@ -120,6 +194,14 @@ public final class TIFFImageWriter extends ImageWriterBase {
ColorModel colorModel = renderedImage.getColorModel();
int numComponents = colorModel.getNumComponents();
TIFFImageMetadata metadata;
if (image.getMetadata() != null) {
metadata = convertImageMetadata(image.getMetadata(), ImageTypeSpecifier.createFromRenderedImage(renderedImage), param);
}
else {
metadata = initMeta(null, ImageTypeSpecifier.createFromRenderedImage(renderedImage), param);
}
SampleModel sampleModel = renderedImage.getSampleModel();
int[] bandOffsets;
@@ -140,7 +222,7 @@ public final class TIFFImageWriter extends ImageWriterBase {
throw new IllegalArgumentException("Unknown bit/bandOffsets for sample model: " + sampleModel);
}
List<Entry> entries = new ArrayList<>();
Set<Entry> entries = new LinkedHashSet<>();
entries.add(new TIFFEntry(TIFF.TAG_IMAGE_WIDTH, renderedImage.getWidth()));
entries.add(new TIFFEntry(TIFF.TAG_IMAGE_HEIGHT, renderedImage.getHeight()));
// entries.add(new TIFFEntry(TIFF.TAG_ORIENTATION, 1)); // (optional)
@@ -157,10 +239,12 @@ public final class TIFFImageWriter extends ImageWriterBase {
}
// Write compression field from param or metadata
// TODO: Support COPY_FROM_METADATA
int compression = TIFFImageWriteParam.getCompressionType(param);
entries.add(new TIFFEntry(TIFF.TAG_COMPRESSION, compression));
// TODO: Let param/metadata control predictor
// TODO: Depending on param.getCompressionMode(): DISABLED/EXPLICIT/COPY_FROM_METADATA/DEFAULT
switch (compression) {
case TIFFExtension.COMPRESSION_ZLIB:
case TIFFExtension.COMPRESSION_DEFLATE:
@@ -169,7 +253,7 @@ public final class TIFFImageWriter extends ImageWriterBase {
default:
}
// TODO: We might want to support CMYK in JPEG as well...
// TODO: We might want to support CMYK in JPEG as well... Pending JPEG CMYK write support.
int photometric = compression == TIFFExtension.COMPRESSION_JPEG ?
TIFFExtension.PHOTOMETRIC_YCBCR :
getPhotometricInterpretation(colorModel);
@@ -189,15 +273,24 @@ public final class TIFFImageWriter extends ImageWriterBase {
}
}
// Default sample format SAMPLEFORMAT_UINT need not be written
if (sampleModel.getDataType() == DataBuffer.TYPE_SHORT /* TODO: if (isSigned(sampleModel.getDataType) or getSampleFormat(sampleModel) != 0 */) {
entries.add(new TIFFEntry(TIFF.TAG_SAMPLE_FORMAT, TIFFExtension.SAMPLEFORMAT_INT));
}
// TODO: Float values!
entries.add(new TIFFEntry(TIFF.TAG_SOFTWARE, "TwelveMonkeys ImageIO TIFF writer")); // TODO: Get from metadata (optional) + fill in version number
// Get Software from metadata, or use default
Entry software = metadata.getIFD().getEntryById(TIFF.TAG_SOFTWARE);
entries.add(software != null ? software : new TIFFEntry(TIFF.TAG_SOFTWARE, "TwelveMonkeys ImageIO TIFF writer " + originatingProvider.getVersion()));
entries.add(new TIFFEntry(TIFF.TAG_X_RESOLUTION, STANDARD_DPI));
entries.add(new TIFFEntry(TIFF.TAG_Y_RESOLUTION, STANDARD_DPI));
entries.add(new TIFFEntry(TIFF.TAG_RESOLUTION_UNIT, TIFFBaseline.RESOLUTION_UNIT_DPI));
// Get X/YResolution and ResolutionUnit from metadata if set, otherwise use defaults
// TODO: Add logic here OR in metadata merging, to make sure these 3 values are consistent.
Entry xRes = metadata.getIFD().getEntryById(TIFF.TAG_X_RESOLUTION);
entries.add(xRes != null ? xRes : new TIFFEntry(TIFF.TAG_X_RESOLUTION, STANDARD_DPI));
Entry yRes = metadata.getIFD().getEntryById(TIFF.TAG_Y_RESOLUTION);
entries.add(yRes != null ? yRes : new TIFFEntry(TIFF.TAG_Y_RESOLUTION, STANDARD_DPI));
Entry resUnit = metadata.getIFD().getEntryById(TIFF.TAG_RESOLUTION_UNIT);
entries.add(resUnit != null ? resUnit : new TIFFEntry(TIFF.TAG_RESOLUTION_UNIT, TIFFBaseline.RESOLUTION_UNIT_DPI));
// TODO: RowsPerStrip - can be entire image (or even 2^32 -1), but it's recommended to write "about 8K bytes" per strip
entries.add(new TIFFEntry(TIFF.TAG_ROWS_PER_STRIP, Integer.MAX_VALUE)); // TODO: Allowed but not recommended
@@ -208,7 +301,8 @@ public final class TIFFImageWriter extends ImageWriterBase {
TIFFEntry dummyStripOffsets = new TIFFEntry(TIFF.TAG_STRIP_OFFSETS, -1);
entries.add(dummyStripOffsets); // Updated later
// TODO: If tiled, write tile indexes etc, or always do that?
// TODO: If tiled, write tile indexes etc
// Depending on param.getTilingMode
EXIFWriter exifWriter = new EXIFWriter();
@@ -233,6 +327,7 @@ public final class TIFFImageWriter extends ImageWriterBase {
// TODO: Create compressor stream per Tile/Strip
if (compression == TIFFExtension.COMPRESSION_JPEG) {
Iterator<ImageWriter> writers = ImageIO.getImageWritersByFormatName("JPEG");
if (!writers.hasNext()) {
// This can only happen if someone deliberately uninstalled it
throw new IIOException("No JPEG ImageWriter found!");
@@ -607,13 +702,75 @@ public final class TIFFImageWriter extends ImageWriterBase {
// Metadata
@Override
public IIOMetadata getDefaultImageMetadata(ImageTypeSpecifier imageType, ImageWriteParam param) {
return null;
public TIFFImageMetadata getDefaultImageMetadata(final ImageTypeSpecifier imageType, final ImageWriteParam param) {
return initMeta(null, imageType, param);
}
@Override
public IIOMetadata convertImageMetadata(IIOMetadata inData, ImageTypeSpecifier imageType, ImageWriteParam param) {
return null;
public TIFFImageMetadata convertImageMetadata(final IIOMetadata inData,
final ImageTypeSpecifier imageType,
final ImageWriteParam param) {
Validate.notNull(inData, "inData");
Validate.notNull(imageType, "imageType");
Directory ifd;
if (inData instanceof TIFFImageMetadata) {
ifd = ((TIFFImageMetadata) inData).getIFD();
}
else {
TIFFImageMetadata outData = new TIFFImageMetadata(Collections.<Entry>emptySet());
try {
if (Arrays.asList(inData.getMetadataFormatNames()).contains(TIFFMedataFormat.SUN_NATIVE_IMAGE_METADATA_FORMAT_NAME)) {
outData.setFromTree(TIFFMedataFormat.SUN_NATIVE_IMAGE_METADATA_FORMAT_NAME, inData.getAsTree(TIFFMedataFormat.SUN_NATIVE_IMAGE_METADATA_FORMAT_NAME));
}
else if (inData.isStandardMetadataFormatSupported()) {
outData.setFromTree(IIOMetadataFormatImpl.standardMetadataFormatName, inData.getAsTree(IIOMetadataFormatImpl.standardMetadataFormatName));
}
else {
// Unknown format, we can't convert it
return null;
}
}
catch (IIOInvalidTreeException e) {
// TODO: How to issue warning when warning requires imageIndex??? Use -1?
}
ifd = outData.getIFD();
}
// Overwrite in values with values from imageType and param as needed
return initMeta(ifd, imageType, param);
}
private TIFFImageMetadata initMeta(final Directory ifd, final ImageTypeSpecifier imageType, final ImageWriteParam param) {
Validate.notNull(imageType, "imageType");
Map<Integer, Entry> entries = new LinkedHashMap<>(ifd != null ? ifd.size() + 10 : 20);
if (ifd != null) {
for (Entry entry : ifd) {
entries.put((Integer) entry.getIdentifier(), entry);
}
}
// TODO: Set values from imageType
entries.put(TIFF.TAG_PHOTOMETRIC_INTERPRETATION, new TIFFEntry(TIFF.TAG_PHOTOMETRIC_INTERPRETATION, TIFF.TYPE_SHORT, getPhotometricInterpretation(imageType.getColorModel())));
// TODO: Set values from param if != null + combined values...
return new TIFFImageMetadata(entries.values());
}
@Override
public IIOMetadata getDefaultStreamMetadata(final ImageWriteParam param) {
return super.getDefaultStreamMetadata(param);
}
@Override
public IIOMetadata convertStreamMetadata(final IIOMetadata inData, final ImageWriteParam param) {
return super.convertStreamMetadata(inData, param);
}
// Param
@@ -762,5 +919,4 @@ public final class TIFFImageWriter extends ImageWriterBase {
TIFFImageReader.showIt(read, output.getName());
}
}

2
imageio/imageio-tiff/src/main/java/com/twelvemonkeys/imageio/plugins/tiff/TIFFProviderInfo.java
View File

@@ -41,7 +41,7 @@ final class TIFFProviderInfo extends ReaderWriterProviderInfo {
protected TIFFProviderInfo() {
super(
TIFFProviderInfo.class,
new String[] {"tiff", "TIFF"},
new String[] {"tiff", "TIFF", "tif", "TIF"},
new String[] {"tif", "tiff"},
new String[] {
"image/tiff", "image/x-tiff"

599
imageio/imageio-tiff/src/test/java/com/twelvemonkeys/imageio/plugins/tiff/TIFFImageMetadataTest.java Normal file
View File

@@ -0,0 +1,599 @@
package com.twelvemonkeys.imageio.plugins.tiff;
import com.twelvemonkeys.imageio.metadata.Directory;
import com.twelvemonkeys.imageio.metadata.Entry;
import com.twelvemonkeys.imageio.metadata.exif.EXIFReader;
import com.twelvemonkeys.imageio.metadata.exif.Rational;
import com.twelvemonkeys.imageio.metadata.exif.TIFF;
import com.twelvemonkeys.imageio.stream.URLImageInputStreamSpi;
import com.twelvemonkeys.lang.StringUtil;
import org.junit.Test;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import javax.imageio.ImageIO;
import javax.imageio.metadata.IIOInvalidTreeException;
import javax.imageio.metadata.IIOMetadata;
import javax.imageio.metadata.IIOMetadataFormatImpl;
import javax.imageio.metadata.IIOMetadataNode;
import javax.imageio.spi.IIORegistry;
import javax.imageio.stream.ImageInputStream;
import java.io.IOException;
import java.net.URL;
import java.util.Collections;
import static org.junit.Assert.*;
/**
* TIFFImageMetadataTest.
*
* @author <a href="mailto:harald.kuhr@gmail.com">Harald Kuhr</a>
* @author last modified by $Author: harald.kuhr$
* @version $Id: TIFFImageMetadataTest.java,v 1.0 30/07/15 harald.kuhr Exp$
*/
public class TIFFImageMetadataTest {
static {
IIORegistry.getDefaultInstance().registerServiceProvider(new URLImageInputStreamSpi());
ImageIO.setUseCache(false);
}
// TODO: Candidate super method
private URL getClassLoaderResource(final String resource) {
return getClass().getResource(resource);
}
// TODO: Candidate abstract super method
private IIOMetadata createMetadata(final String resource) throws IOException {
try (ImageInputStream input = ImageIO.createImageInputStream(getClassLoaderResource(resource))) {
Directory ifd = new EXIFReader().read(input);
// System.err.println("ifd: " + ifd);
return new TIFFImageMetadata(ifd);
}
}
@Test
public void testMetadataStandardFormat() throws IOException {
IIOMetadata metadata = createMetadata("/tiff/smallliz.tif");
Node root = metadata.getAsTree(IIOMetadataFormatImpl.standardMetadataFormatName);
// Root: "javax_imageio_1.0"
assertNotNull(root);
assertEquals(IIOMetadataFormatImpl.standardMetadataFormatName, root.getNodeName());
assertEquals(6, root.getChildNodes().getLength());
// "Chroma"
Node chroma = root.getFirstChild();
assertEquals("Chroma", chroma.getNodeName());
assertEquals(3, chroma.getChildNodes().getLength());
Node colorSpaceType = chroma.getFirstChild();
assertEquals("ColorSpaceType", colorSpaceType.getNodeName());
assertEquals("YCbCr", ((Element) colorSpaceType).getAttribute("value"));
Node numChannels = colorSpaceType.getNextSibling();
assertEquals("NumChannels", numChannels.getNodeName());
assertEquals("3", ((Element) numChannels).getAttribute("value"));
Node blackIsZero = numChannels.getNextSibling();
assertEquals("BlackIsZero", blackIsZero.getNodeName());
assertEquals(0, blackIsZero.getAttributes().getLength());
// "Compression"
Node compression = chroma.getNextSibling();
assertEquals("Compression", compression.getNodeName());
assertEquals(2, compression.getChildNodes().getLength());
Node compressionTypeName = compression.getFirstChild();
assertEquals("CompressionTypeName", compressionTypeName.getNodeName());
assertEquals("Old JPEG", ((Element) compressionTypeName).getAttribute("value"));
Node lossless = compressionTypeName.getNextSibling();
assertEquals("Lossless", lossless.getNodeName());
assertEquals("FALSE", ((Element) lossless).getAttribute("value"));
// "Data"
Node data = compression.getNextSibling();
assertEquals("Data", data.getNodeName());
assertEquals(4, data.getChildNodes().getLength());
Node planarConfiguration = data.getFirstChild();
assertEquals("PlanarConfiguration", planarConfiguration.getNodeName());
assertEquals("PixelInterleaved", ((Element) planarConfiguration).getAttribute("value"));
Node sampleFormat = planarConfiguration.getNextSibling();
assertEquals("SampleFormat", sampleFormat.getNodeName());
assertEquals("UnsignedIntegral", ((Element) sampleFormat).getAttribute("value"));
Node bitsPerSample = sampleFormat.getNextSibling();
assertEquals("BitsPerSample", bitsPerSample.getNodeName());
assertEquals("8 8 8", ((Element) bitsPerSample).getAttribute("value"));
Node sampleMSB = bitsPerSample.getNextSibling();
assertEquals("SampleMSB", sampleMSB.getNodeName());
assertEquals("0 0 0", ((Element) sampleMSB).getAttribute("value"));
// "Dimension"
Node dimension = data.getNextSibling();
assertEquals("Dimension", dimension.getNodeName());
assertEquals(3, dimension.getChildNodes().getLength());
Node pixelAspectRatio = dimension.getFirstChild();
assertEquals("PixelAspectRatio", pixelAspectRatio.getNodeName());
assertEquals("1.0", ((Element) pixelAspectRatio).getAttribute("value"));
Node horizontalPixelSize = pixelAspectRatio.getNextSibling();
assertEquals("HorizontalPixelSize", horizontalPixelSize.getNodeName());
assertEquals("0.254", ((Element) horizontalPixelSize).getAttribute("value"));
Node verticalPixelSize = horizontalPixelSize.getNextSibling();
assertEquals("VerticalPixelSize", verticalPixelSize.getNodeName());
assertEquals("0.254", ((Element) verticalPixelSize).getAttribute("value"));
// "Document"
Node document = dimension.getNextSibling();
assertEquals("Document", document.getNodeName());
assertEquals(1, document.getChildNodes().getLength());
Node formatVersion = document.getFirstChild();
assertEquals("FormatVersion", formatVersion.getNodeName());
assertEquals("6.0", ((Element) formatVersion).getAttribute("value"));
// "Text"
Node text = document.getNextSibling();
assertEquals("Text", text.getNodeName());
assertEquals(1, text.getChildNodes().getLength());
// NOTE: Could be multiple "TextEntry" elements, with different "keyword" attributes
Node textEntry = text.getFirstChild();
assertEquals("TextEntry", textEntry.getNodeName());
assertEquals("Software", ((Element) textEntry).getAttribute("keyword"));
assertEquals("HP IL v1.1", ((Element) textEntry).getAttribute("value"));
}
@Test
public void testMetadataNativeFormat() throws IOException {
IIOMetadata metadata = createMetadata("/tiff/quad-lzw.tif");
Node root = metadata.getAsTree(TIFFMedataFormat.SUN_NATIVE_IMAGE_METADATA_FORMAT_NAME);
// Root: "com_sun_media_imageio_plugins_tiff_image_1.0"
assertNotNull(root);
assertEquals(TIFFMedataFormat.SUN_NATIVE_IMAGE_METADATA_FORMAT_NAME, root.getNodeName());
assertEquals(1, root.getChildNodes().getLength());
// IFD: "TIFFIFD"
Node ifd = root.getFirstChild();
assertEquals("TIFFIFD", ifd.getNodeName());
NodeList entries = ifd.getChildNodes();
assertEquals(13, entries.getLength());
String[] stripOffsets = {
"8", "150", "292", "434", "576", "718", "860", "1002", "1144", "1286",
"1793", "3823", "7580", "12225", "17737", "23978", "30534", "36863", "42975", "49180",
"55361", "61470", "67022", "71646", "74255", "75241", "75411", "75553", "75695", "75837",
"75979", "76316", "77899", "80466", "84068", "88471", "93623", "99105", "104483", "109663",
"114969", "120472", "126083", "131289", "135545", "138810", "140808", "141840", "141982", "142124",
"142266", "142408", "142615", "144074", "146327", "149721", "154066", "158927", "164022", "169217",
"174409", "179657", "185166", "190684", "196236", "201560", "206064", "209497", "211612", "212419",
"212561", "212703", "212845", "212987", "213129", "213271", "213413"
};
String[] stripByteCounts = {
"142", "142", "142", "142", "142", "142", "142", "142", "142", "507",
"2030", "3757", "4645", "5512", "6241", "6556", "6329", "6112", "6205", "6181",
"6109", "5552", "4624", "2609", "986", "170", "142", "142", "142", "142",
"337", "1583", "2567", "3602", "4403", "5152", "5482", "5378", "5180", "5306",
"5503", "5611", "5206", "4256", "3265", "1998", "1032", "142", "142", "142",
"142", "207", "1459", "2253", "3394", "4345", "4861", "5095", "5195", "5192",
"5248", "5509", "5518", "5552", "5324", "4504", "3433", "2115", "807", "142",
"142", "142", "142", "142", "142", "142", "128"
};
// The 13 entries
assertSingleNodeWithValue(entries, TIFF.TAG_IMAGE_WIDTH, TIFF.TYPE_SHORT, "512");
assertSingleNodeWithValue(entries, TIFF.TAG_IMAGE_HEIGHT, TIFF.TYPE_SHORT, "384");
assertSingleNodeWithValue(entries, TIFF.TAG_BITS_PER_SAMPLE, TIFF.TYPE_SHORT, "8", "8", "8");
assertSingleNodeWithValue(entries, TIFF.TAG_COMPRESSION, TIFF.TYPE_SHORT, "5");
assertSingleNodeWithValue(entries, TIFF.TAG_PHOTOMETRIC_INTERPRETATION, TIFF.TYPE_SHORT, "2");
assertSingleNodeWithValue(entries, TIFF.TAG_STRIP_OFFSETS, TIFF.TYPE_LONG, stripOffsets);
assertSingleNodeWithValue(entries, TIFF.TAG_SAMPLES_PER_PIXEL, TIFF.TYPE_SHORT, "3");
assertSingleNodeWithValue(entries, TIFF.TAG_ROWS_PER_STRIP, TIFF.TYPE_LONG, "5");
assertSingleNodeWithValue(entries, TIFF.TAG_STRIP_BYTE_COUNTS, TIFF.TYPE_LONG, stripByteCounts);
assertSingleNodeWithValue(entries, TIFF.TAG_PLANAR_CONFIGURATION, TIFF.TYPE_SHORT, "1");
assertSingleNodeWithValue(entries, TIFF.TAG_X_POSITION, TIFF.TYPE_RATIONAL, "0");
assertSingleNodeWithValue(entries, TIFF.TAG_Y_POSITION, TIFF.TYPE_RATIONAL, "0");
assertSingleNodeWithValue(entries, 32995, TIFF.TYPE_SHORT, "0"); // Matteing tag, obsoleted by ExtraSamples tag in TIFF 6.0
}
@Test
public void testTreeDetached() throws IOException {
IIOMetadata metadata = createMetadata("/tiff/sm_colors_tile.tif");
Node nativeTree = metadata.getAsTree(TIFFMedataFormat.SUN_NATIVE_IMAGE_METADATA_FORMAT_NAME);
assertNotNull(nativeTree);
Node nativeTree2 = metadata.getAsTree(TIFFMedataFormat.SUN_NATIVE_IMAGE_METADATA_FORMAT_NAME);
assertNotNull(nativeTree2);
assertNotSame(nativeTree, nativeTree2);
assertNodeEquals("Unmodified trees differs", nativeTree, nativeTree2); // Both not modified
// Modify one of the trees
Node ifdNode = nativeTree2.getFirstChild();
ifdNode.removeChild(ifdNode.getFirstChild());
IIOMetadataNode tiffField = new IIOMetadataNode("TIFFField");
ifdNode.appendChild(tiffField);
assertNodeNotEquals("Modified tree does not differ", nativeTree, nativeTree2);
}
@Test
public void testMergeTree() throws IOException {
TIFFImageMetadata metadata = (TIFFImageMetadata) createMetadata("/tiff/sm_colors_tile.tif");
String nativeFormat = TIFFMedataFormat.SUN_NATIVE_IMAGE_METADATA_FORMAT_NAME;
Node nativeTree = metadata.getAsTree(nativeFormat);
assertNotNull(nativeTree);
IIOMetadataNode newTree = new IIOMetadataNode("com_sun_media_imageio_plugins_tiff_image_1.0");
IIOMetadataNode ifdNode = new IIOMetadataNode("TIFFIFD");
newTree.appendChild(ifdNode);
createTIFFFieldNode(ifdNode, TIFF.TAG_RESOLUTION_UNIT, TIFF.TYPE_SHORT, TIFFBaseline.RESOLUTION_UNIT_DPI);
createTIFFFieldNode(ifdNode, TIFF.TAG_X_RESOLUTION, TIFF.TYPE_RATIONAL, new Rational(300));
createTIFFFieldNode(ifdNode, TIFF.TAG_Y_RESOLUTION, TIFF.TYPE_RATIONAL, new Rational(30001, 100));
metadata.mergeTree(nativeFormat, newTree);
Directory ifd = metadata.getIFD();
assertNotNull(ifd.getEntryById(TIFF.TAG_X_RESOLUTION));
assertEquals(new Rational(300), ifd.getEntryById(TIFF.TAG_X_RESOLUTION).getValue());
assertNotNull(ifd.getEntryById(TIFF.TAG_Y_RESOLUTION));
assertEquals(new Rational(30001, 100), ifd.getEntryById(TIFF.TAG_Y_RESOLUTION).getValue());
assertNotNull(ifd.getEntryById(TIFF.TAG_RESOLUTION_UNIT));
assertEquals(TIFFBaseline.RESOLUTION_UNIT_DPI, ((Number) ifd.getEntryById(TIFF.TAG_RESOLUTION_UNIT).getValue()).intValue());
Node mergedTree = metadata.getAsTree(nativeFormat);
NodeList fields = mergedTree.getFirstChild().getChildNodes();
// Validate there's one and only one resolution unit, x res and y res
// Validate resolution unit == 1, x res & y res
assertSingleNodeWithValue(fields, TIFF.TAG_RESOLUTION_UNIT, TIFF.TYPE_SHORT, String.valueOf(TIFFBaseline.RESOLUTION_UNIT_DPI));
assertSingleNodeWithValue(fields, TIFF.TAG_X_RESOLUTION, TIFF.TYPE_RATIONAL, "300");
assertSingleNodeWithValue(fields, TIFF.TAG_Y_RESOLUTION, TIFF.TYPE_RATIONAL, "30001/100");
}
@Test
public void testMergeTreeStandardFormat() throws IOException {
TIFFImageMetadata metadata = (TIFFImageMetadata) createMetadata("/tiff/zackthecat.tif");
String standardFormat = IIOMetadataFormatImpl.standardMetadataFormatName;
Node standardTree = metadata.getAsTree(standardFormat);
assertNotNull(standardTree);
IIOMetadataNode newTree = new IIOMetadataNode(standardFormat);
IIOMetadataNode dimensionNode = new IIOMetadataNode("Dimension");
newTree.appendChild(dimensionNode);
IIOMetadataNode horizontalPixelSize = new IIOMetadataNode("HorizontalPixelSize");
dimensionNode.appendChild(horizontalPixelSize);
horizontalPixelSize.setAttribute("value", String.valueOf(300 / 25.4));
IIOMetadataNode verticalPixelSize = new IIOMetadataNode("VerticalPixelSize");
dimensionNode.appendChild(verticalPixelSize);
verticalPixelSize.setAttribute("value", String.valueOf(300 / 25.4));
metadata.mergeTree(standardFormat, newTree);
Directory ifd = metadata.getIFD();
assertNotNull(ifd.getEntryById(TIFF.TAG_X_RESOLUTION));
assertEquals(new Rational(300), ifd.getEntryById(TIFF.TAG_X_RESOLUTION).getValue());
assertNotNull(ifd.getEntryById(TIFF.TAG_Y_RESOLUTION));
assertEquals(new Rational(300), ifd.getEntryById(TIFF.TAG_Y_RESOLUTION).getValue());
// Should keep DPI as unit
assertNotNull(ifd.getEntryById(TIFF.TAG_RESOLUTION_UNIT));
assertEquals(TIFFBaseline.RESOLUTION_UNIT_DPI, ((Number) ifd.getEntryById(TIFF.TAG_RESOLUTION_UNIT).getValue()).intValue());
}
@Test
public void testMergeTreeStandardFormatAspectOnly() throws IOException {
TIFFImageMetadata metadata = (TIFFImageMetadata) createMetadata("/tiff/sm_colors_tile.tif");
String standardFormat = IIOMetadataFormatImpl.standardMetadataFormatName;
Node standardTree = metadata.getAsTree(standardFormat);
assertNotNull(standardTree);
IIOMetadataNode newTree = new IIOMetadataNode(standardFormat);
IIOMetadataNode dimensionNode = new IIOMetadataNode("Dimension");
newTree.appendChild(dimensionNode);
IIOMetadataNode aspectRatio = new IIOMetadataNode("PixelAspectRatio");
dimensionNode.appendChild(aspectRatio);
aspectRatio.setAttribute("value", String.valueOf(3f / 2f));
metadata.mergeTree(standardFormat, newTree);
Directory ifd = metadata.getIFD();
assertNotNull(ifd.getEntryById(TIFF.TAG_X_RESOLUTION));
assertEquals(new Rational(3, 2), ifd.getEntryById(TIFF.TAG_X_RESOLUTION).getValue());
assertNotNull(ifd.getEntryById(TIFF.TAG_Y_RESOLUTION));
assertEquals(new Rational(1), ifd.getEntryById(TIFF.TAG_Y_RESOLUTION).getValue());
assertNotNull(ifd.getEntryById(TIFF.TAG_RESOLUTION_UNIT));
assertEquals(TIFFBaseline.RESOLUTION_UNIT_NONE, ((Number) ifd.getEntryById(TIFF.TAG_RESOLUTION_UNIT).getValue()).intValue());
}
@Test(expected = IllegalArgumentException.class)
public void testMergeTreeUnsupportedFormat() throws IOException {
IIOMetadata metadata = createMetadata("/tiff/sm_colors_tile.tif");
String nativeFormat = "com_foo_bar_tiff_42";
metadata.mergeTree(nativeFormat, new IIOMetadataNode(nativeFormat));
}
@Test(expected = IIOInvalidTreeException.class)
public void testMergeTreeFormatMisMatch() throws IOException {
IIOMetadata metadata = createMetadata("/tiff/sm_colors_tile.tif");
String nativeFormat = TIFFMedataFormat.SUN_NATIVE_IMAGE_METADATA_FORMAT_NAME;
metadata.mergeTree(nativeFormat, new IIOMetadataNode("com_foo_bar_tiff_42"));
}
@Test(expected = IIOInvalidTreeException.class)
public void testMergeTreeInvalid() throws IOException {
IIOMetadata metadata = createMetadata("/tiff/sm_colors_tile.tif");
String nativeFormat = TIFFMedataFormat.SUN_NATIVE_IMAGE_METADATA_FORMAT_NAME;
metadata.mergeTree(nativeFormat, new IIOMetadataNode(nativeFormat)); // Requires at least one child node
}
// TODO: Test that failed merge leaves metadata unchanged
@Test
public void testSetFromTreeEmpty() throws IOException {
// Read from file, set empty to see that all is cleared
TIFFImageMetadata metadata = (TIFFImageMetadata) createMetadata("/tiff/sm_colors_tile.tif");
String nativeFormat = TIFFMedataFormat.SUN_NATIVE_IMAGE_METADATA_FORMAT_NAME;
IIOMetadataNode root = new IIOMetadataNode(nativeFormat);
root.appendChild(new IIOMetadataNode("TIFFIFD"));
metadata.setFromTree(nativeFormat, root);
Directory ifd = metadata.getIFD();
assertNotNull(ifd);
assertEquals(0, ifd.size());
Node tree = metadata.getAsTree(nativeFormat);
assertNotNull(tree);
assertNotNull(tree.getFirstChild());
assertEquals(1, tree.getChildNodes().getLength());
}
@Test
public void testSetFromTree() throws IOException {
String softwareString = "12M UberTIFF 1.0";
TIFFImageMetadata metadata = new TIFFImageMetadata(Collections.<Entry>emptySet());
String nativeFormat = TIFFMedataFormat.SUN_NATIVE_IMAGE_METADATA_FORMAT_NAME;
IIOMetadataNode root = new IIOMetadataNode(nativeFormat);
IIOMetadataNode ifdNode = new IIOMetadataNode("TIFFIFD");
root.appendChild(ifdNode);
createTIFFFieldNode(ifdNode, TIFF.TAG_SOFTWARE, TIFF.TYPE_ASCII, softwareString);
metadata.setFromTree(nativeFormat, root);
Directory ifd = metadata.getIFD();
assertNotNull(ifd);
assertEquals(1, ifd.size());
assertNotNull(ifd.getEntryById(TIFF.TAG_SOFTWARE));
assertEquals(softwareString, ifd.getEntryById(TIFF.TAG_SOFTWARE).getValue());
Node tree = metadata.getAsTree(nativeFormat);
assertNotNull(tree);
assertNotNull(tree.getFirstChild());
assertEquals(1, tree.getChildNodes().getLength());
}
@Test
public void testSetFromTreeStandardFormat() throws IOException {
String softwareString = "12M UberTIFF 1.0";
String copyrightString = "Copyright (C) TwelveMonkeys, 2015";
TIFFImageMetadata metadata = new TIFFImageMetadata(Collections.<Entry>emptySet());
String standardFormat = IIOMetadataFormatImpl.standardMetadataFormatName;
IIOMetadataNode root = new IIOMetadataNode(standardFormat);
IIOMetadataNode textNode = new IIOMetadataNode("Text");
root.appendChild(textNode);
IIOMetadataNode textEntry = new IIOMetadataNode("TextEntry");
textNode.appendChild(textEntry);
textEntry.setAttribute("keyword", "SOFTWARE"); // Spelling should not matter
textEntry.setAttribute("value", softwareString);
textEntry = new IIOMetadataNode("TextEntry");
textNode.appendChild(textEntry);
textEntry.setAttribute("keyword", "copyright"); // Spelling should not matter
textEntry.setAttribute("value", copyrightString);
metadata.setFromTree(standardFormat, root);
Directory ifd = metadata.getIFD();
assertNotNull(ifd);
assertEquals(2, ifd.size());
assertNotNull(ifd.getEntryById(TIFF.TAG_SOFTWARE));
assertEquals(softwareString, ifd.getEntryById(TIFF.TAG_SOFTWARE).getValue());
assertNotNull(ifd.getEntryById(TIFF.TAG_COPYRIGHT));
assertEquals(copyrightString, ifd.getEntryById(TIFF.TAG_COPYRIGHT).getValue());
}
@Test(expected = IllegalArgumentException.class)
public void testSetFromTreeUnsupportedFormat() throws IOException {
IIOMetadata metadata = createMetadata("/tiff/sm_colors_tile.tif");
String nativeFormat = "com_foo_bar_tiff_42";
metadata.setFromTree(nativeFormat, new IIOMetadataNode(nativeFormat));
}
@Test(expected = IIOInvalidTreeException.class)
public void testSetFromTreeFormatMisMatch() throws IOException {
IIOMetadata metadata = createMetadata("/tiff/sm_colors_tile.tif");
String nativeFormat = TIFFMedataFormat.SUN_NATIVE_IMAGE_METADATA_FORMAT_NAME;
metadata.setFromTree(nativeFormat, new IIOMetadataNode("com_foo_bar_tiff_42"));
}
@Test(expected = IIOInvalidTreeException.class)
public void testSetFromTreeInvalid() throws IOException {
IIOMetadata metadata = createMetadata("/tiff/sm_colors_tile.tif");
String nativeFormat = TIFFMedataFormat.SUN_NATIVE_IMAGE_METADATA_FORMAT_NAME;
metadata.setFromTree(nativeFormat, new IIOMetadataNode(nativeFormat)); // Requires at least one child node
}
private void assertSingleNodeWithValue(final NodeList fields, final int tag, int type, final String... expectedValue) {
String tagNumber = String.valueOf(tag);
String typeName = StringUtil.capitalize(TIFF.TYPE_NAMES[type].toLowerCase());
boolean foundTag = false;
for (int i = 0; i < fields.getLength(); i++) {
Element field = (Element) fields.item(i);
if (tagNumber.equals(field.getAttribute("number"))) {
assertFalse("Duplicate tag " + tagNumber + " found", foundTag);
assertEquals(1, field.getChildNodes().getLength());
Node containerNode = field.getFirstChild();
assertEquals("TIFF" + typeName + "s", containerNode.getNodeName());
NodeList valueNodes = containerNode.getChildNodes();
assertEquals("Unexpected number of values for tag " + tagNumber, expectedValue.length, valueNodes.getLength());
for (int j = 0; j < expectedValue.length; j++) {
Element valueNode = (Element) valueNodes.item(j);
assertEquals("TIFF" + typeName, valueNode.getNodeName());
assertEquals("Unexpected tag " + tagNumber + " value", expectedValue[j], valueNode.getAttribute("value"));
}
foundTag = true;
}
}
assertTrue("No tag " + tagNumber + " found", foundTag);
}
// TODO: Test that failed set leaves metadata unchanged
static void createTIFFFieldNode(final IIOMetadataNode parentIFDNode, int tag, short type, Object value) {
IIOMetadataNode fieldNode = new IIOMetadataNode("TIFFField");
parentIFDNode.appendChild(fieldNode);
fieldNode.setAttribute("number", String.valueOf(tag));
switch (type) {
case TIFF.TYPE_ASCII:
createTIFFFieldContainerNode(fieldNode, "Ascii", value);
break;
case TIFF.TYPE_BYTE:
createTIFFFieldContainerNode(fieldNode, "Byte", value);
break;
case TIFF.TYPE_SHORT:
createTIFFFieldContainerNode(fieldNode, "Short", value);
break;
case TIFF.TYPE_RATIONAL:
createTIFFFieldContainerNode(fieldNode, "Rational", value);
break;
default:
throw new IllegalArgumentException("Unsupported type: " + type);
}
}
static void createTIFFFieldContainerNode(final IIOMetadataNode fieldNode, final String type, final Object value) {
IIOMetadataNode containerNode = new IIOMetadataNode("TIFF" + type + "s");
fieldNode.appendChild(containerNode);
IIOMetadataNode valueNode = new IIOMetadataNode("TIFF" + type);
valueNode.setAttribute("value", String.valueOf(value));
containerNode.appendChild(valueNode);
}
private void assertNodeNotEquals(final String message, final Node expected, final Node actual) {
// Lame, lazy implementation...
try {
assertNodeEquals(message, expected, actual);
}
catch (AssertionError ignore) {
return;
}
fail(message);
}
private void assertNodeEquals(final String message, final Node expected, final Node actual) {
assertEquals(message + " class differs", expected.getClass(), actual.getClass());
assertEquals(message, expected.getNodeValue(), actual.getNodeValue());
if (expected instanceof IIOMetadataNode) {
IIOMetadataNode expectedIIO = (IIOMetadataNode) expected;
IIOMetadataNode actualIIO = (IIOMetadataNode) actual;
assertEquals(message, expectedIIO.getUserObject(), actualIIO.getUserObject());
}
NodeList expectedChildNodes = expected.getChildNodes();
NodeList actualChildNodes = actual.getChildNodes();
assertEquals(message + " child length differs: " + toString(expectedChildNodes) + " != " + toString(actualChildNodes),
expectedChildNodes.getLength(), actualChildNodes.getLength());
for (int i = 0; i < expectedChildNodes.getLength(); i++) {
Node expectedChild = expectedChildNodes.item(i);
Node actualChild = actualChildNodes.item(i);
assertEquals(message + " node name differs", expectedChild.getLocalName(), actualChild.getLocalName());
assertNodeEquals(message + "/" + expectedChild.getLocalName(), expectedChild, actualChild);
}
}
private String toString(final NodeList list) {
if (list.getLength() == 0) {
return "[]";
}
StringBuilder builder = new StringBuilder("[");
for (int i = 0; i < list.getLength(); i++) {
if (i > 0) {
builder.append(", ");
}
Node node = list.item(i);
builder.append(node.getLocalName());
}
builder.append("]");
return builder.toString();
}
}

56
imageio/imageio-tiff/src/test/java/com/twelvemonkeys/imageio/plugins/tiff/TIFFImageReaderTest.java
View File

@@ -80,7 +80,22 @@ public class TIFFImageReaderTest extends ImageReaderAbstractTest<TIFFImageReader
new TestData(getClassLoaderResource("/tiff/lzw-long-strings-sample.tif"), new Dimension(316, 173)), // RGBA, LZW compressed w/predictor
new TestData(getClassLoaderResource("/tiff/part.tif"), new Dimension(50, 50)), // Gray/BlackIsZero, uncompressed, striped signed int (SampleFormat 2)
new TestData(getClassLoaderResource("/tiff/cmyk_jpeg_no_profile.tif"), new Dimension(150, 63)), // CMYK, JPEG compressed, no ICC profile
new TestData(getClassLoaderResource("/tiff/cmyk_jpeg.tif"), new Dimension(100, 100)) // CMYK, JPEG compressed, with ICC profile
new TestData(getClassLoaderResource("/tiff/cmyk_jpeg.tif"), new Dimension(100, 100)), // CMYK, JPEG compressed, with ICC profile
new TestData(getClassLoaderResource("/tiff/grayscale-alpha.tiff"), new Dimension(248, 351)), // Gray + unassociated alpha
new TestData(getClassLoaderResource("/tiff/signed-integral-8bit.tif"), new Dimension(439, 167)), // Gray, 8 bit *signed* integral
new TestData(getClassLoaderResource("/tiff/floatingpoint-32bit.tif"), new Dimension(300, 100)), // RGB, 32 bit floating point
new TestData(getClassLoaderResource("/tiff/general-cmm-error.tif"), new Dimension(1181, 860)), // RGB, LZW compression with broken/incompatible ICC profile
new TestData(getClassLoaderResource("/tiff/lzw-rgba-padded-icc.tif"), new Dimension(19, 11)), // RGBA, LZW compression with padded ICC profile
new TestData(getClassLoaderResource("/tiff/lzw-rgba-4444.tif"), new Dimension(64, 64)), // RGBA, LZW compression with UINT 4/4/4/4 + gray 2/2
new TestData(getClassLoaderResource("/tiff/lzw-buffer-overflow.tif"), new Dimension(5, 49)), // RGBA, LZW compression, will throw IOOBE if small buffer
// CCITT
new TestData(getClassLoaderResource("/tiff/ccitt/group3_1d.tif"), new Dimension(6, 4)), // B/W, CCITT T4 1D
new TestData(getClassLoaderResource("/tiff/ccitt/group3_1d_fill.tif"), new Dimension(6, 4)), // B/W, CCITT T4 1D
new TestData(getClassLoaderResource("/tiff/ccitt/group3_2d.tif"), new Dimension(6, 4)), // B/W, CCITT T4 2D
new TestData(getClassLoaderResource("/tiff/ccitt/group3_2d_fill.tif"), new Dimension(6, 4)), // B/W, CCITT T4 2D
new TestData(getClassLoaderResource("/tiff/ccitt/group3_2d_lsb2msb.tif"), new Dimension(6, 4)), // B/W, CCITT T4 2D, LSB
new TestData(getClassLoaderResource("/tiff/ccitt/group4.tif"), new Dimension(6, 4)), // B/W, CCITT T6 1D
new TestData(getClassLoaderResource("/tiff/fivepages-scan-causingerrors.tif"), new Dimension(2480, 3518)) // B/W, CCITT T4
);
}
@@ -141,9 +156,8 @@ public class TIFFImageReaderTest extends ImageReaderAbstractTest<TIFFImageReader
@Test
public void testReadOldStyleJPEGGrayscale() throws IOException {
TestData testData = new TestData(getClassLoaderResource("/tiff/grayscale-old-style-jpeg.tiff"), new Dimension(600, 600));
ImageInputStream stream = testData.getInputStream();
try {
try (ImageInputStream stream = testData.getInputStream()) {
TIFFImageReader reader = createReader();
reader.setInput(stream);
BufferedImage image = reader.read(0);
@@ -151,18 +165,13 @@ public class TIFFImageReaderTest extends ImageReaderAbstractTest<TIFFImageReader
assertNotNull(image);
assertEquals(testData.getDimension(0), new Dimension(image.getWidth(), image.getHeight()));
}
finally {
stream.close();
}
}
@Test
public void testReadIncompatibleICCProfileIgnoredWithWarning() throws IOException {
TestData testData = new TestData(getClassLoaderResource("/tiff/rgb-with-embedded-cmyk-icc.tif"), new Dimension(1500, 1500));
ImageInputStream stream = testData.getInputStream();
try {
try (ImageInputStream stream = testData.getInputStream()) {
TIFFImageReader reader = createReader();
reader.setInput(stream);
@@ -175,18 +184,13 @@ public class TIFFImageReaderTest extends ImageReaderAbstractTest<TIFFImageReader
assertEquals(testData.getDimension(0), new Dimension(image.getWidth(), image.getHeight()));
verify(warningListener, atLeastOnce()).warningOccurred(eq(reader), contains("ICC"));
}
finally {
stream.close();
}
}
@Test
public void testColorMap8Bit() throws IOException {
TestData testData = new TestData(getClassLoaderResource("/tiff/scan-lzw-8bit-colormap.tiff"), new Dimension(2550, 3300));
ImageInputStream stream = testData.getInputStream();
try {
try (ImageInputStream stream = testData.getInputStream()) {
TIFFImageReader reader = createReader();
reader.setInput(stream);
@@ -202,8 +206,26 @@ public class TIFFImageReaderTest extends ImageReaderAbstractTest<TIFFImageReader
assertEquals(0xffffffff, image.getRGB(0, 0)); // The pixel at 0, 0 should be white, not black
verify(warningListener, atLeastOnce()).warningOccurred(eq(reader), contains("ColorMap"));
}
finally {
stream.close();
}
@Test
public void testBadICCProfile() throws IOException {
TestData testData = new TestData(getClassLoaderResource("/tiff/general-cmm-error.tif"), new Dimension(1181, 864));
try (ImageInputStream stream = testData.getInputStream()) {
TIFFImageReader reader = createReader();
reader.setInput(stream);
IIOReadWarningListener warningListener = mock(IIOReadWarningListener.class);
reader.addIIOReadWarningListener(warningListener);
ImageReadParam param = reader.getDefaultReadParam();
param.setSourceRegion(new Rectangle(8, 8));
BufferedImage image = reader.read(0, param);
assertNotNull(image);
assertEquals(new Dimension(8, 8), new Dimension(image.getWidth(), image.getHeight()));
verify(warningListener, atLeastOnce()).warningOccurred(eq(reader), contains("ICC profile"));
}
}
}

231
imageio/imageio-tiff/src/test/java/com/twelvemonkeys/imageio/plugins/tiff/TIFFImageWriterTest.java
View File

@@ -28,15 +28,33 @@
package com.twelvemonkeys.imageio.plugins.tiff;
import com.twelvemonkeys.imageio.metadata.Directory;
import com.twelvemonkeys.imageio.metadata.Entry;
import com.twelvemonkeys.imageio.metadata.exif.EXIFReader;
import com.twelvemonkeys.imageio.metadata.exif.Rational;
import com.twelvemonkeys.imageio.metadata.exif.TIFF;
import com.twelvemonkeys.imageio.stream.ByteArrayImageInputStream;
import com.twelvemonkeys.imageio.util.ImageWriterAbstractTestCase;
import org.junit.Test;
import javax.imageio.IIOImage;
import javax.imageio.ImageIO;
import javax.imageio.ImageTypeSpecifier;
import javax.imageio.ImageWriter;
import java.awt.*;
import javax.imageio.metadata.IIOMetadata;
import javax.imageio.metadata.IIOMetadataFormatImpl;
import javax.imageio.metadata.IIOMetadataNode;
import javax.imageio.stream.ImageOutputStream;
import java.awt.image.BufferedImage;
import java.awt.image.RenderedImage;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.util.Arrays;
import java.util.List;
import static com.twelvemonkeys.imageio.plugins.tiff.TIFFImageMetadataTest.createTIFFFieldNode;
import static org.junit.Assert.*;
/**
* TIFFImageWriterTest
*
@@ -55,19 +73,208 @@ public class TIFFImageWriterTest extends ImageWriterAbstractTestCase {
@Override
protected List<? extends RenderedImage> getTestData() {
BufferedImage image = new BufferedImage(300, 200, BufferedImage.TYPE_INT_ARGB);
Graphics2D graphics = image.createGraphics();
try {
graphics.setColor(Color.RED);
graphics.fillRect(0, 0, 100, 200);
graphics.setColor(Color.BLUE);
graphics.fillRect(100, 0, 100, 200);
graphics.clearRect(200, 0, 100, 200);
return Arrays.asList(
new BufferedImage(300, 200, BufferedImage.TYPE_INT_RGB),
new BufferedImage(300, 200, BufferedImage.TYPE_INT_ARGB),
new BufferedImage(300, 200, BufferedImage.TYPE_3BYTE_BGR),
new BufferedImage(300, 200, BufferedImage.TYPE_4BYTE_ABGR),
new BufferedImage(300, 200, BufferedImage.TYPE_BYTE_GRAY),
new BufferedImage(300, 200, BufferedImage.TYPE_USHORT_GRAY),
// new BufferedImage(300, 200, BufferedImage.TYPE_BYTE_BINARY), // TODO!
new BufferedImage(300, 200, BufferedImage.TYPE_BYTE_INDEXED)
);
}
// TODO: Test write bilevel stays bilevel
// TODO: Test write indexed stays indexed
@Test
public void testWriteWithCustomResolutionNative() throws IOException {
// Issue 139 Writing TIFF files with custom resolution value
Rational resolutionValue = new Rational(1200);
int resolutionUnitValue = TIFFBaseline.RESOLUTION_UNIT_CENTIMETER;
RenderedImage image = getTestData(0);
ImageWriter writer = createImageWriter();
ByteArrayOutputStream buffer = new ByteArrayOutputStream();
try (ImageOutputStream stream = ImageIO.createImageOutputStream(buffer)) {
writer.setOutput(stream);
String nativeFormat = TIFFMedataFormat.SUN_NATIVE_IMAGE_METADATA_FORMAT_NAME;
IIOMetadata metadata = writer.getDefaultImageMetadata(ImageTypeSpecifier.createFromRenderedImage(image), null);
IIOMetadataNode customMeta = new IIOMetadataNode(nativeFormat);
IIOMetadataNode ifd = new IIOMetadataNode("TIFFIFD");
customMeta.appendChild(ifd);
createTIFFFieldNode(ifd, TIFF.TAG_RESOLUTION_UNIT, TIFF.TYPE_SHORT, resolutionUnitValue);
createTIFFFieldNode(ifd, TIFF.TAG_X_RESOLUTION, TIFF.TYPE_RATIONAL, resolutionValue);
createTIFFFieldNode(ifd, TIFF.TAG_Y_RESOLUTION, TIFF.TYPE_RATIONAL, resolutionValue);
metadata.mergeTree(nativeFormat, customMeta);
writer.write(null, new IIOImage(image, null, metadata), null);
}
finally {
graphics.dispose();
catch (IOException e) {
e.printStackTrace();
fail(e.getMessage());
}
return Arrays.asList(image);
assertTrue("No image data written", buffer.size() > 0);
Directory ifds = new EXIFReader().read(new ByteArrayImageInputStream(buffer.toByteArray()));
Entry resolutionUnit = ifds.getEntryById(TIFF.TAG_RESOLUTION_UNIT);
assertNotNull(resolutionUnit);
assertEquals(resolutionUnitValue, ((Number) resolutionUnit.getValue()).intValue());
Entry xResolution = ifds.getEntryById(TIFF.TAG_X_RESOLUTION);
assertNotNull(xResolution);
assertEquals(resolutionValue, xResolution.getValue());
Entry yResolution = ifds.getEntryById(TIFF.TAG_Y_RESOLUTION);
assertNotNull(yResolution);
assertEquals(resolutionValue, yResolution.getValue());
}
@Test
public void testWriteWithCustomSoftwareNative() throws IOException {
String softwareString = "12M TIFF Test 1.0 (build $foo$)";
RenderedImage image = getTestData(0);
ImageWriter writer = createImageWriter();
ByteArrayOutputStream buffer = new ByteArrayOutputStream();
try (ImageOutputStream stream = ImageIO.createImageOutputStream(buffer)) {
writer.setOutput(stream);
String nativeFormat = TIFFMedataFormat.SUN_NATIVE_IMAGE_METADATA_FORMAT_NAME;
IIOMetadata metadata = writer.getDefaultImageMetadata(ImageTypeSpecifier.createFromRenderedImage(image), null);
IIOMetadataNode customMeta = new IIOMetadataNode(nativeFormat);
IIOMetadataNode ifd = new IIOMetadataNode("TIFFIFD");
customMeta.appendChild(ifd);
createTIFFFieldNode(ifd, TIFF.TAG_SOFTWARE, TIFF.TYPE_ASCII, softwareString);
metadata.mergeTree(nativeFormat, customMeta);
writer.write(null, new IIOImage(image, null, metadata), null);
}
catch (IOException e) {
e.printStackTrace();
fail(e.getMessage());
}
assertTrue("No image data written", buffer.size() > 0);
Directory ifds = new EXIFReader().read(new ByteArrayImageInputStream(buffer.toByteArray()));
Entry software = ifds.getEntryById(TIFF.TAG_SOFTWARE);
assertNotNull(software);
assertEquals(softwareString, software.getValueAsString());
}
@Test
public void testWriteWithCustomResolutionStandard() throws IOException {
// Issue 139 Writing TIFF files with custom resolution value
double resolutionValue = 300 / 25.4; // 300 dpi, 1 inch = 2.54 cm or 25.4 mm
int resolutionUnitValue = TIFFBaseline.RESOLUTION_UNIT_CENTIMETER;
Rational expectedResolutionValue = new Rational(Math.round(resolutionValue * 10 * TIFFImageMetadata.RATIONAL_SCALE_FACTOR), TIFFImageMetadata.RATIONAL_SCALE_FACTOR);
RenderedImage image = getTestData(0);
ImageWriter writer = createImageWriter();
ByteArrayOutputStream buffer = new ByteArrayOutputStream();
try (ImageOutputStream stream = ImageIO.createImageOutputStream(buffer)) {
writer.setOutput(stream);
String standardFormat = IIOMetadataFormatImpl.standardMetadataFormatName;
IIOMetadata metadata = writer.getDefaultImageMetadata(ImageTypeSpecifier.createFromRenderedImage(image), null);
IIOMetadataNode customMeta = new IIOMetadataNode(standardFormat);
IIOMetadataNode dimension = new IIOMetadataNode("Dimension");
customMeta.appendChild(dimension);
IIOMetadataNode xSize = new IIOMetadataNode("HorizontalPixelSize");
dimension.appendChild(xSize);
xSize.setAttribute("value", String.valueOf(resolutionValue));
IIOMetadataNode ySize = new IIOMetadataNode("VerticalPixelSize");
dimension.appendChild(ySize);
ySize.setAttribute("value", String.valueOf(resolutionValue));
metadata.mergeTree(standardFormat, customMeta);
writer.write(null, new IIOImage(image, null, metadata), null);
}
catch (IOException e) {
e.printStackTrace();
fail(e.getMessage());
}
assertTrue("No image data written", buffer.size() > 0);
Directory ifds = new EXIFReader().read(new ByteArrayImageInputStream(buffer.toByteArray()));
Entry resolutionUnit = ifds.getEntryById(TIFF.TAG_RESOLUTION_UNIT);
assertNotNull(resolutionUnit);
assertEquals(resolutionUnitValue, ((Number) resolutionUnit.getValue()).intValue());
Entry xResolution = ifds.getEntryById(TIFF.TAG_X_RESOLUTION);
assertNotNull(xResolution);
assertEquals(expectedResolutionValue, xResolution.getValue());
Entry yResolution = ifds.getEntryById(TIFF.TAG_Y_RESOLUTION);
assertNotNull(yResolution);
assertEquals(expectedResolutionValue, yResolution.getValue());
}
@Test
public void testWriteWithCustomSoftwareStandard() throws IOException {
String softwareString = "12M TIFF Test 1.0 (build $foo$)";
RenderedImage image = getTestData(0);
ImageWriter writer = createImageWriter();
ByteArrayOutputStream buffer = new ByteArrayOutputStream();
try (ImageOutputStream stream = ImageIO.createImageOutputStream(buffer)) {
writer.setOutput(stream);
String standardFormat = IIOMetadataFormatImpl.standardMetadataFormatName;
IIOMetadata metadata = writer.getDefaultImageMetadata(ImageTypeSpecifier.createFromRenderedImage(image), null);
IIOMetadataNode customMeta = new IIOMetadataNode(standardFormat);
IIOMetadataNode dimension = new IIOMetadataNode("Text");
customMeta.appendChild(dimension);
IIOMetadataNode textEntry = new IIOMetadataNode("TextEntry");
dimension.appendChild(textEntry);
textEntry.setAttribute("keyword", "Software");
textEntry.setAttribute("value", softwareString);
metadata.mergeTree(standardFormat, customMeta);
writer.write(null, new IIOImage(image, null, metadata), null);
}
catch (IOException e) {
e.printStackTrace();
fail(e.getMessage());
}
assertTrue("No image data written", buffer.size() > 0);
Directory ifds = new EXIFReader().read(new ByteArrayImageInputStream(buffer.toByteArray()));
Entry software = ifds.getEntryById(TIFF.TAG_SOFTWARE);
assertNotNull(software);
assertEquals(softwareString, software.getValueAsString());
}
}

BIN
imageio/imageio-tiff/src/test/resources/tiff/fivepages-scan-causingerrors.tif Normal file
View File

Binary file not shown.

BIN
imageio/imageio-tiff/src/test/resources/tiff/floatingpoint-32bit.tif Normal file
View File

Binary file not shown.

BIN
imageio/imageio-tiff/src/test/resources/tiff/general-cmm-error.tif Normal file
View File

Binary file not shown.

BIN
imageio/imageio-tiff/src/test/resources/tiff/grayscale-alpha.tiff Normal file
View File

Binary file not shown.

BIN
imageio/imageio-tiff/src/test/resources/tiff/lzw-buffer-overflow.tif Normal file
View File

Binary file not shown.

BIN
imageio/imageio-tiff/src/test/resources/tiff/lzw-rgba-4444.tif Normal file
View File

Binary file not shown.

BIN
imageio/imageio-tiff/src/test/resources/tiff/lzw-rgba-padded-icc.tif Normal file
View File

Binary file not shown.

BIN
imageio/imageio-tiff/src/test/resources/tiff/signed-integral-8bit.tif Normal file
View File

Binary file not shown.