Backups/TwelveMonkeys
2
0
Fork 0
mirror of https://github.com/haraldk/TwelveMonkeys.git synced 2025-08-03 03:25:28 -04:00
Code Issues Projects Releases Wiki Activity

#182 Clean up after merge of #215

Browse Source
This commit is contained in:
Harald Kuhr 2016-08-10 15:36:41 +02:00
parent b1ac99ba1a
commit 15ce9d6b64
14 changed files with 1347 additions and 1358 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

208
imageio/imageio-jpeg/src/main/java/com/twelvemonkeys/imageio/plugins/jpeg/JPEGImageReader.java
View File

@ -28,6 +28,7 @@
package com.twelvemonkeys.imageio.plugins.jpeg;
import com.twelvemonkeys.imageio.AbstractMetadata;
import com.twelvemonkeys.imageio.ImageReaderBase;
import com.twelvemonkeys.imageio.color.ColorSpaces;
import com.twelvemonkeys.imageio.color.YCbCrConverter;
@ -39,16 +40,17 @@ import com.twelvemonkeys.imageio.metadata.exif.TIFF;
import com.twelvemonkeys.imageio.metadata.jpeg.JPEG;
import com.twelvemonkeys.imageio.metadata.jpeg.JPEGSegment;
import com.twelvemonkeys.imageio.metadata.jpeg.JPEGSegmentUtil;
import com.twelvemonkeys.imageio.plugins.jpeg.lossless.DataStream;
import com.twelvemonkeys.imageio.plugins.jpeg.lossless.JPEGLosslessDecoderWrapper;
import com.twelvemonkeys.imageio.util.ImageTypeSpecifiers;
import com.twelvemonkeys.imageio.util.ProgressListenerBase;
import com.twelvemonkeys.lang.Validate;
import com.twelvemonkeys.xml.XMLSerializer;
import org.w3c.dom.Node;
import javax.imageio.*;
import javax.imageio.event.IIOReadUpdateListener;
import javax.imageio.event.IIOReadWarningListener;
import javax.imageio.metadata.IIOInvalidTreeException;
import javax.imageio.metadata.IIOMetadata;
import javax.imageio.metadata.IIOMetadataFormatImpl;
import javax.imageio.metadata.IIOMetadataNode;
@ -136,6 +138,10 @@ public class JPEGImageReader extends ImageReaderBase {
map.put(JPEG.SOF14, null);
map.put(JPEG.SOF15, null);
map.put(JPEG.DQT, null);
map.put(JPEG.DHT, null);
map.put(JPEG.SOS, null);
return Collections.unmodifiableMap(map);
}
@ -201,6 +207,12 @@ public class JPEGImageReader extends ImageReaderBase {
@Override
public int getNumImages(boolean allowSearch) throws IOException {
if (allowSearch) {
if (isLossless()) {
return 1;
}
}
try {
return delegate.getNumImages(allowSearch);
}
@ -210,13 +222,43 @@ public class JPEGImageReader extends ImageReaderBase {
}
}
private boolean isLossless() throws IOException {
assertInput();
try {
SOFSegment sof = getSOF();
if (sof.marker == JPEG.SOF3) {
return true;
}
}
catch (IIOException ignore) {
// May happen if no SOF is found, in case we'll just fall through
}
return false;
}
@Override
public int getWidth(int imageIndex) throws IOException {
checkBounds(imageIndex);
SOFSegment sof = getSOF();
if (sof.marker == JPEG.SOF3) {
return sof.samplesPerLine;
}
return delegate.getWidth(imageIndex);
}
@Override
public int getHeight(int imageIndex) throws IOException {
checkBounds(imageIndex);
SOFSegment sof = getSOF();
if (sof.marker == JPEG.SOF3) {
return sof.lines;
}
return delegate.getHeight(imageIndex);
}
@ -277,7 +319,7 @@ public class JPEGImageReader extends ImageReaderBase {
return rawType;
}
}
catch (NullPointerException ignore) {
catch (IIOException | NullPointerException ignore) {
// Fall through
}
@ -340,33 +382,11 @@ public class JPEGImageReader extends ImageReaderBase {
JPEGColorSpace sourceCSType = getSourceCSType(getJFIF(), adobeDCT, sof);
//try to read an JPEG Lossless image
if(sof.marker == JPEG.SOF3){
JPEGLosslessDecoderWrapper decoder = new JPEGLosslessDecoderWrapper();
ImageInputStream inputStream = (ImageInputStream) this.getInput();
/* try to read the input stream as once. If length is not supported
* the image is read blockwise
*/
byte[] rawByteData;
long byteLength = inputStream.length();
if(byteLength > 0 && byteLength < Integer.MAX_VALUE){
rawByteData = new byte[(int)byteLength];
inputStream.read(rawByteData);
} else {
ByteArrayOutputStream bytes = new ByteArrayOutputStream(1024 * 1024 /* Provide a size close to what is likely the case for better performance*/);
byte[] buffer = new byte[1024];
int count;
while ((count = inputStream.read(buffer)) > 0) {
bytes.write(buffer, 0, count);
}
rawByteData = bytes.toByteArray();
}
//try do read the image, IOException can be thrown
return decoder.readImage(rawByteData);
if (sof.marker == JPEG.SOF3) {
// TODO: What about stream position?
// TODO: Param handling: Source region, offset, subsampling, destination, destination type, etc....
// Read image as lossless
return new JPEGLosslessDecoderWrapper().readImage(imageInput);
}
// We need to apply ICC profile unless the profile is sRGB/default gray (whatever that is)
@ -746,34 +766,35 @@ public class JPEGImageReader extends ImageReaderBase {
initHeader();
for (JPEGSegment segment : segments) {
if (JPEG.SOF0 >= segment.marker() && segment.marker() <= JPEG.SOF3 ||
JPEG.SOF5 >= segment.marker() && segment.marker() <= JPEG.SOF7 ||
JPEG.SOF9 >= segment.marker() && segment.marker() <= JPEG.SOF11 ||
JPEG.SOF13 >= segment.marker() && segment.marker() <= JPEG.SOF15) {
if (JPEG.SOF0 <= segment.marker() && segment.marker() <= JPEG.SOF3 ||
JPEG.SOF5 <= segment.marker() && segment.marker() <= JPEG.SOF7 ||
JPEG.SOF9 <= segment.marker() && segment.marker() <= JPEG.SOF11 ||
JPEG.SOF13 <= segment.marker() && segment.marker() <= JPEG.SOF15) {
DataInputStream data = new DataInputStream(segment.data());
try {
int samplePrecision = data.readUnsignedByte();
int lines = data.readUnsignedShort();
int samplesPerLine = data.readUnsignedShort();
int componentsInFrame = data.readUnsignedByte();
SOFComponent[] components = new SOFComponent[componentsInFrame];
for (int i = 0; i < componentsInFrame; i++) {
int id = data.readUnsignedByte();
int sub = data.readUnsignedByte();
int qtSel = data.readUnsignedByte();
components[i] = new SOFComponent(id, ((sub & 0xF0) >> 4), (sub & 0xF), qtSel);
}
return new SOFSegment(segment.marker(), samplePrecision, lines, samplesPerLine, components);
}
finally {
data.close();
try (DataInputStream data = new DataInputStream(segment.data())) {
return SOFSegment.read(segment.marker(), data);
}
// try {
// int samplePrecision = data.readUnsignedByte();
// int lines = data.readUnsignedShort();
// int samplesPerLine = data.readUnsignedShort();
// int componentsInFrame = data.readUnsignedByte();
//
// SOFComponent[] components = new SOFComponent[componentsInFrame];
//
// for (int i = 0; i < componentsInFrame; i++) {
// int id = data.readUnsignedByte();
// int sub = data.readUnsignedByte();
// int qtSel = data.readUnsignedByte();
//
// components[i] = new SOFComponent(id, ((sub & 0xF0) >> 4), (sub & 0xF), qtSel);
// }
//
// return new SOFSegment(segment.marker(), samplePrecision, lines, samplesPerLine, components);
// }
// finally {
// data.close();
// }
}
}
@ -960,7 +981,15 @@ public class JPEGImageReader extends ImageReaderBase {
}
@Override
public Raster readRaster(int imageIndex, ImageReadParam param) throws IOException {
public Raster readRaster(final int imageIndex, final ImageReadParam param) throws IOException {
checkBounds(imageIndex);
if (isLossless()) {
// TODO: What about stream position?
// TODO: Param handling: Reading as raster should support source region, subsampling etc.
return new JPEGLosslessDecoderWrapper().readRaster(imageInput);
}
return delegate.readRaster(imageIndex, param);
}
@ -1101,24 +1130,58 @@ public class JPEGImageReader extends ImageReaderBase {
IIOMetadata imageMetadata;
try {
imageMetadata = delegate.getImageMetadata(imageIndex);
}
catch (IndexOutOfBoundsException knownIssue) {
// TMI-101: com.sun.imageio.plugins.jpeg.JPEGBuffer doesn't do proper sanity check of input data.
throw new IIOException("Corrupt JPEG data: Bad segment length", knownIssue);
}
catch (NegativeArraySizeException knownIssue) {
// Most likely from com.sun.imageio.plugins.jpeg.SOSMarkerSegment
throw new IIOException("Corrupt JPEG data: Bad component count", knownIssue);
}
if (isLossless()) {
return new AbstractMetadata(true, JPEGImage10MetadataCleaner.JAVAX_IMAGEIO_JPEG_IMAGE_1_0, null, null, null) {
@Override
protected Node getNativeTree() {
IIOMetadataNode root = new IIOMetadataNode(JPEGImage10MetadataCleaner.JAVAX_IMAGEIO_JPEG_IMAGE_1_0);
if (imageMetadata != null && Arrays.asList(imageMetadata.getMetadataFormatNames()).contains(JPEGImage10MetadataCleaner.JAVAX_IMAGEIO_JPEG_IMAGE_1_0)) {
if (metadataCleaner == null) {
metadataCleaner = new JPEGImage10MetadataCleaner(this);
root.appendChild(new IIOMetadataNode("JPEGvariety"));
IIOMetadataNode markerSequence = new IIOMetadataNode("markerSequence");
root.appendChild(markerSequence);
for (JPEGSegment segment : segments) {
switch (segment.marker()) {
// SOF3 is the only one supported by now
case JPEG.SOF3:
markerSequence.appendChild(new IIOMetadataNode("sof"));
break;
case JPEG.DHT:
markerSequence.appendChild(new IIOMetadataNode("dht"));
break;
case JPEG.DQT:
markerSequence.appendChild(new IIOMetadataNode("dqt"));
break;
case JPEG.SOS:
markerSequence.appendChild(new IIOMetadataNode("sos"));
break;
}
}
return root;
}
};
}
else {
try {
imageMetadata = delegate.getImageMetadata(imageIndex);
}
catch (IndexOutOfBoundsException knownIssue) {
// TMI-101: com.sun.imageio.plugins.jpeg.JPEGBuffer doesn't do proper sanity check of input data.
throw new IIOException("Corrupt JPEG data: Bad segment length", knownIssue);
}
catch (NegativeArraySizeException knownIssue) {
// Most likely from com.sun.imageio.plugins.jpeg.SOSMarkerSegment
throw new IIOException("Corrupt JPEG data: Bad component count", knownIssue);
}
return metadataCleaner.cleanMetadata(imageMetadata);
if (imageMetadata != null && Arrays.asList(imageMetadata.getMetadataFormatNames()).contains(JPEGImage10MetadataCleaner.JAVAX_IMAGEIO_JPEG_IMAGE_1_0)) {
if (metadataCleaner == null) {
metadataCleaner = new JPEGImage10MetadataCleaner(this);
}
return metadataCleaner.cleanMetadata(imageMetadata);
}
}
return imageMetadata;
@ -1402,7 +1465,8 @@ public class JPEGImageReader extends ImageReaderBase {
image = reader.getImageTypes(0).next().createBufferedImage((reader.getWidth(0) + subX - 1)/ subX, (reader.getHeight(0) + subY - 1) / subY);
}
else {
image = reader.getImageTypes(0).next().createBufferedImage(reader.getWidth(0), reader.getHeight(0));
// image = reader.getImageTypes(0).next().createBufferedImage(reader.getWidth(0), reader.getHeight(0));
image = null;
}
param.setDestination(image);

21
imageio/imageio-jpeg/src/main/java/com/twelvemonkeys/imageio/plugins/jpeg/SOFSegment.java
View File

@ -28,6 +28,8 @@
package com.twelvemonkeys.imageio.plugins.jpeg;
import java.io.DataInput;
import java.io.IOException;
import java.util.Arrays;
/**
@ -63,4 +65,23 @@ final class SOFSegment {
marker & 0xff - 0xc0, marker, samplePrecision, lines, samplesPerLine, Arrays.toString(components)
);
}
public static SOFSegment read(final int marker, final DataInput data) throws IOException {
int samplePrecision = data.readUnsignedByte();
int lines = data.readUnsignedShort();
int samplesPerLine = data.readUnsignedShort();
int componentsInFrame = data.readUnsignedByte();
SOFComponent[] components = new SOFComponent[componentsInFrame];
for (int i = 0; i < componentsInFrame; i++) {
int id = data.readUnsignedByte();
int sub = data.readUnsignedByte();
int qtSel = data.readUnsignedByte();
components[i] = new SOFComponent(id, ((sub & 0xF0) >> 4), (sub & 0xF), qtSel);
}
return new SOFSegment(marker, samplePrecision, lines, samplesPerLine, components);
}
}

6
imageio/imageio-jpeg/src/main/java/com/twelvemonkeys/imageio/plugins/jpeg/lossless/ComponentSpec.java
View File

@ -32,7 +32,7 @@ package com.twelvemonkeys.imageio.plugins.jpeg.lossless;
public class ComponentSpec {
protected int hSamp; // Horizontal sampling factor
protected int quantTableSel; // Quantization table destination selector
protected int vSamp; // Vertical
protected int hSamp; // Horizontal sampling factor
protected int quantTableSel; // Quantization table destination selector
protected int vSamp; // Vertical
}

40
imageio/imageio-jpeg/src/main/java/com/twelvemonkeys/imageio/plugins/jpeg/lossless/DataStream.java
View File

@ -1,40 +0,0 @@
/*
* Copyright (C) 2015 Michael Martinez
* Changes: Added support for selection values 2-7, fixed minor bugs &
* warnings, split into multiple class files, and general clean up.
*
* 08-25-2015: Helmut Dersch agreed to a license change from LGPL to MIT.
*/
/*
* Copyright (C) Helmut Dersch
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
package com.twelvemonkeys.imageio.plugins.jpeg.lossless;
public interface DataStream {
int get16();
int get8();
}

130
imageio/imageio-jpeg/src/main/java/com/twelvemonkeys/imageio/plugins/jpeg/lossless/FrameHeader.java
View File

@ -30,99 +30,87 @@
package com.twelvemonkeys.imageio.plugins.jpeg.lossless;
import javax.imageio.stream.ImageInputStream;
import java.io.IOException;
public class FrameHeader {
private ComponentSpec components[]; // Components
private int dimX; // Number of samples per line
private int dimY; // Number of lines
private int numComp; // Number of component in the frame
private int precision; // Sample Precision (from the original image)
private ComponentSpec components[]; // Components
private int dimX; // Number of samples per line
private int dimY; // Number of lines
private int numComp; // Number of component in the frame
private int precision; // Sample Precision (from the original image)
public ComponentSpec[] getComponents() {
return components.clone();
}
public int getDimX() {
return dimX;
}
public ComponentSpec[] getComponents() {
return components.clone();
}
public int getDimY() {
return dimY;
}
public int getNumComponents() {
return numComp;
}
public int getPrecision() {
return precision;
}
public int getDimX() {
return dimX;
}
protected int read(final ImageInputStream data) throws IOException {
int count = 0;
final int length = data.readUnsignedShort();
count += 2;
precision = data.readUnsignedByte();
count++;
public int getDimY() {
return dimY;
}
dimY = data.readUnsignedShort();
count += 2;
dimX = data.readUnsignedShort();
count += 2;
numComp = data.readUnsignedByte();
count++;
public int getNumComponents() {
return numComp;
}
//components = new ComponentSpec[numComp]; // some image exceed this range...
components = new ComponentSpec[256]; // setting to 256 -- not sure what it should be.
for (int i = 1; i <= numComp; i++) {
if (count > length) {
throw new IOException("ERROR: frame format error");
}
final int c = data.readUnsignedByte();
count++;
public int getPrecision() {
return precision;
}
if (count >= length) {
throw new IOException("ERROR: frame format error [c>=Lf]");
}
final int temp = data.readUnsignedByte();
count++;
if (components[c] == null) {
components[c] = new ComponentSpec();
}
protected int read(final DataStream data) throws IOException {
int count = 0;
components[c].hSamp = temp >> 4;
components[c].vSamp = temp & 0x0F;
components[c].quantTableSel = data.readUnsignedByte();
count++;
}
final int length = data.get16();
count += 2;
if (count != length) {
throw new IOException("ERROR: frame format error [Lf!=count]");
}
precision = data.get8();
count++;
dimY = data.get16();
count += 2;
dimX = data.get16();
count += 2;
numComp = data.get8();
count++;
//components = new ComponentSpec[numComp]; // some image exceed this range...
components = new ComponentSpec[256]; // setting to 256 -- not sure what it should be.
for (int i = 1; i <= numComp; i++) {
if (count > length) {
throw new IOException("ERROR: frame format error");
}
final int c = data.get8();
count++;
if (count >= length) {
throw new IOException("ERROR: frame format error [c>=Lf]");
}
final int temp = data.get8();
count++;
if (components[c] == null) {
components[c] = new ComponentSpec();
}
components[c].hSamp = temp >> 4;
components[c].vSamp = temp & 0x0F;
components[c].quantTableSel = data.get8();
count++;
}
if (count != length) {
throw new IOException("ERROR: frame format error [Lf!=count]");
}
return 1;
}
return 1;
}
}

214
imageio/imageio-jpeg/src/main/java/com/twelvemonkeys/imageio/plugins/jpeg/lossless/HuffmanTable.java
View File

@ -30,134 +30,128 @@
package com.twelvemonkeys.imageio.plugins.jpeg.lossless;
import javax.imageio.stream.ImageInputStream;
import java.io.IOException;
public class HuffmanTable {
private final int l[][][] = new int[4][2][16];
private final int th[] = new int[4]; // 1: this table is presented
private final int v[][][][] = new int[4][2][16][200]; // tables
private final int[][] tc = new int[4][2]; // 1: this table is presented
private final int l[][][] = new int[4][2][16];
private final int th[] = new int[4]; // 1: this table is presented
private final int v[][][][] = new int[4][2][16][200]; // tables
private final int[][] tc = new int[4][2]; // 1: this table is presented
public static final int MSB = 0x80000000;
public static final int MSB = 0x80000000;
public HuffmanTable() {
tc[0][0] = 0;
tc[1][0] = 0;
tc[2][0] = 0;
tc[3][0] = 0;
tc[0][1] = 0;
tc[1][1] = 0;
tc[2][1] = 0;
tc[3][1] = 0;
th[0] = 0;
th[1] = 0;
th[2] = 0;
th[3] = 0;
}
protected int read(final ImageInputStream data, final int[][][] HuffTab) throws IOException {
int count = 0;
final int length = data.readUnsignedShort();
count += 2;
public HuffmanTable() {
tc[0][0] = 0;
tc[1][0] = 0;
tc[2][0] = 0;
tc[3][0] = 0;
tc[0][1] = 0;
tc[1][1] = 0;
tc[2][1] = 0;
tc[3][1] = 0;
th[0] = 0;
th[1] = 0;
th[2] = 0;
th[3] = 0;
}
while (count < length) {
final int temp = data.readUnsignedByte();
count++;
final int t = temp & 0x0F;
if (t > 3) {
throw new IOException("ERROR: Huffman table ID > 3");
}
final int c = temp >> 4;
if (c > 2) {
throw new IOException("ERROR: Huffman table [Table class > 2 ]");
}
th[t] = 1;
tc[t][c] = 1;
protected int read(final DataStream data, final int[][][] HuffTab) throws IOException {
int count = 0;
final int length = data.get16();
count += 2;
for (int i = 0; i < 16; i++) {
l[t][c][i] = data.readUnsignedByte();
count++;
}
while (count < length) {
final int temp = data.get8();
count++;
final int t = temp & 0x0F;
if (t > 3) {
throw new IOException("ERROR: Huffman table ID > 3");
}
for (int i = 0; i < 16; i++) {
for (int j = 0; j < l[t][c][i]; j++) {
if (count > length) {
throw new IOException("ERROR: Huffman table format error [count>Lh]");
}
v[t][c][i][j] = data.readUnsignedByte();
count++;
}
}
}
final int c = temp >> 4;
if (c > 2) {
throw new IOException("ERROR: Huffman table [Table class > 2 ]");
}
if (count != length) {
throw new IOException("ERROR: Huffman table format error [count!=Lf]");
}
th[t] = 1;
tc[t][c] = 1;
for (int i = 0; i < 4; i++) {
for (int j = 0; j < 2; j++) {
if (tc[i][j] != 0) {
buildHuffTable(HuffTab[i][j], l[i][j], v[i][j]);
}
}
}
for (int i = 0; i < 16; i++) {
l[t][c][i] = data.get8();
count++;
}
return 1;
}
for (int i = 0; i < 16; i++) {
for (int j = 0; j < l[t][c][i]; j++) {
if (count > length) {
throw new IOException("ERROR: Huffman table format error [count>Lh]");
}
v[t][c][i][j] = data.get8();
count++;
}
}
}
// Build_HuffTab()
// Parameter: t table ID
// c table class ( 0 for DC, 1 for AC )
// L[i] # of codewords which length is i
// V[i][j] Huffman Value (length=i)
// Effect:
// build up HuffTab[t][c] using L and V.
private void buildHuffTable(final int tab[], final int L[], final int V[][]) throws IOException {
int currentTable, temp;
int k;
temp = 256;
k = 0;
if (count != length) {
throw new IOException("ERROR: Huffman table format error [count!=Lf]");
}
for (int i = 0; i < 8; i++) { // i+1 is Code length
for (int j = 0; j < L[i]; j++) {
for (int n = 0; n < (temp >> (i + 1)); n++) {
tab[k] = V[i][j] | ((i + 1) << 8);
k++;
}
}
}
for (int i = 0; i < 4; i++) {
for (int j = 0; j < 2; j++) {
if (tc[i][j] != 0) {
buildHuffTable(HuffTab[i][j], l[i][j], v[i][j]);
}
}
}
for (int i = 1; k < 256; i++, k++) {
tab[k] = i | MSB;
}
return 1;
}
currentTable = 1;
k = 0;
// Build_HuffTab()
// Parameter: t table ID
// c table class ( 0 for DC, 1 for AC )
// L[i] # of codewords which length is i
// V[i][j] Huffman Value (length=i)
// Effect:
// build up HuffTab[t][c] using L and V.
private void buildHuffTable(final int tab[], final int L[], final int V[][]) throws IOException {
int currentTable, temp;
int k;
temp = 256;
k = 0;
for (int i = 0; i < 8; i++) { // i+1 is Code length
for (int j = 0; j < L[i]; j++) {
for (int n = 0; n < (temp >> (i + 1)); n++) {
tab[k] = V[i][j] | ((i + 1) << 8);
k++;
}
}
}
for (int i = 1; k < 256; i++, k++) {
tab[k] = i | MSB;
}
currentTable = 1;
k = 0;
for (int i = 8; i < 16; i++) { // i+1 is Code length
for (int j = 0; j < L[i]; j++) {
for (int n = 0; n < (temp >> (i - 7)); n++) {
tab[(currentTable * 256) + k] = V[i][j] | ((i + 1) << 8);
k++;
}
if (k >= 256) {
if (k > 256) {
throw new IOException("ERROR: Huffman table error(1)!");
}
k = 0;
currentTable++;
}
}
}
}
for (int i = 8; i < 16; i++) { // i+1 is Code length
for (int j = 0; j < L[i]; j++) {
for (int n = 0; n < (temp >> (i - 7)); n++) {
tab[(currentTable * 256) + k] = V[i][j] | ((i + 1) << 8);
k++;
}
if (k >= 256) {
if (k > 256) {
throw new IOException("ERROR: Huffman table error(1)!");
}
k = 0;
currentTable++;
}
}
}
}
}

1464
imageio/imageio-jpeg/src/main/java/com/twelvemonkeys/imageio/plugins/jpeg/lossless/JPEGLosslessDecoder.java
View File

File diff suppressed because it is too large Load Diff

225
imageio/imageio-jpeg/src/main/java/com/twelvemonkeys/imageio/plugins/jpeg/lossless/JPEGLosslessDecoderWrapper.java
View File

@ -1,130 +1,135 @@
package com.twelvemonkeys.imageio.plugins.jpeg.lossless;
import java.awt.image.BufferedImage;
import java.awt.image.DataBufferByte;
import java.awt.image.DataBufferInt;
import java.awt.image.DataBufferUShort;
import javax.imageio.stream.ImageInputStream;
import java.awt.image.*;
import java.io.ByteArrayOutputStream;
import java.io.DataInput;
import java.io.IOException;
/**
* This class provides the conversion of a byte buffer
* containing a JPEGLossless to an BufferedImage.
* This class provides the conversion of a byte buffer
* containing a JPEGLossless to an BufferedImage.
* Therefore it uses the rii-mango JPEGLosslessDecoder
* Library ( https://github.com/rii-mango/JPEGLosslessDecoder )
*
* <p>
* Take care, that only the following lossless formats are supported
* 1.2.840.10008.1.2.4.57 JPEG Lossless, Nonhierarchical (Processes 14)
* 1.2.840.10008.1.2.4.70 JPEG Lossless, Nonhierarchical (Processes 14 [Selection 1])
*
* <p>
* Currently the following conversions are supported
* - 24Bit, RGB -> BufferedImage.TYPE_INT_RGB
* - 8Bit, Grayscale -> BufferedImage.TYPE_BYTE_GRAY
* - 16Bit, Grayscale -> BufferedImage.TYPE_USHORT_GRAY
*
* @author Hermann Kroll
* - 24Bit, RGB -> BufferedImage.TYPE_INT_RGB
* - 8Bit, Grayscale -> BufferedImage.TYPE_BYTE_GRAY
* - 16Bit, Grayscale -> BufferedImage.TYPE_USHORT_GRAY
*
* @author Hermann Kroll
*/
public class JPEGLosslessDecoderWrapper {
/**
* Converts a byte buffer (containing a jpeg lossless)
* to an Java BufferedImage
* Currently the following conversions are supported
* - 24Bit, RGB -> BufferedImage.TYPE_INT_RGB
* - 8Bit, Grayscale -> BufferedImage.TYPE_BYTE_GRAY
* - 16Bit, Grayscale -> BufferedImage.TYPE_USHORT_GRAY
*
* @param data byte buffer which contains a jpeg lossless
* @return if successfully a BufferedImage is returned
* @throws IOException is thrown if the decoder failed or a conversion is not supported
*/
public BufferedImage readImage(byte[] data) throws IOException{
JPEGLosslessDecoder decoder = new JPEGLosslessDecoder(data);
int[][] decoded = decoder.decode();
int width = decoder.getDimX();
int height = decoder.getDimY();
if(decoder.getNumComponents() == 1){
switch(decoder.getPrecision())
{
case 8:
return read8Bit1ComponentGrayScale(decoded, width, height);
case 16:
return read16Bit1ComponentGrayScale(decoded, width, height);
default:
throw new IOException("JPEG Lossless with " + decoder.getPrecision() + " bit precision and 1 component cannot be decoded");
}
}
//rgb
if(decoder.getNumComponents() == 3){
switch(decoder.getPrecision())
{
case 24:
return read24Bit3ComponentRGB(decoded, width, height);
/**
* Converts a byte buffer (containing a jpeg lossless)
* to an Java BufferedImage
* Currently the following conversions are supported
* - 24Bit, RGB -> BufferedImage.TYPE_INT_RGB
* - 8Bit, Grayscale -> BufferedImage.TYPE_BYTE_GRAY
* - 16Bit, Grayscale -> BufferedImage.TYPE_USHORT_GRAY
*
* @param input input stream which contains a jpeg lossless data
* @return if successfully a BufferedImage is returned
* @throws IOException is thrown if the decoder failed or a conversion is not supported
*/
public BufferedImage readImage(final ImageInputStream input) throws IOException {
JPEGLosslessDecoder decoder = new JPEGLosslessDecoder(input);
default:
throw new IOException("JPEG Lossless with " + decoder.getPrecision() + " bit precision and 3 components cannot be decoded");
}
}
throw new IOException("JPEG Lossless with " + decoder.getPrecision() + " bit precision and " + decoder.getNumComponents() + " component(s) cannot be decoded");
}
/**
* converts the decoded buffer into a BufferedImage
* precision: 16 bit, componentCount = 1
* @param decoded data buffer
* @param width of the image
* @param height of the image
* @return a BufferedImage.TYPE_USHORT_GRAY
*/
private BufferedImage read16Bit1ComponentGrayScale(int[][] decoded, int width, int height){
BufferedImage image = new BufferedImage(width, height, BufferedImage.TYPE_USHORT_GRAY);
short[] imageBuffer = ((DataBufferUShort) image.getRaster().getDataBuffer()).getData();
int[][] decoded = decoder.decode();
int width = decoder.getDimX();
int height = decoder.getDimY();
for(int i = 0; i < imageBuffer.length; i++){
imageBuffer[i] = (short)decoded[0][i];
}
return image;
}
/**
* converts the decoded buffer into a BufferedImage
* precision: 8 bit, componentCount = 1
* @param decoded data buffer
* @param width of the image
* @param height of the image
* @return a BufferedImage.TYPE_BYTE_GRAY
*/
private BufferedImage read8Bit1ComponentGrayScale(int[][] decoded, int width, int height){
BufferedImage image = new BufferedImage(width, height, BufferedImage.TYPE_BYTE_GRAY);
byte[] imageBuffer = ((DataBufferByte) image.getRaster().getDataBuffer()).getData();
if (decoder.getNumComponents() == 1) {
switch (decoder.getPrecision()) {
case 8:
return read8Bit1ComponentGrayScale(decoded, width, height);
case 16:
return read16Bit1ComponentGrayScale(decoded, width, height);
default:
throw new IOException("JPEG Lossless with " + decoder.getPrecision() + " bit precision and 1 component cannot be decoded");
}
}
//rgb
if (decoder.getNumComponents() == 3) {
switch (decoder.getPrecision()) {
case 8:
return read24Bit3ComponentRGB(decoded, width, height);
for(int i = 0; i < imageBuffer.length; i++){
imageBuffer[i] = (byte)decoded[0][i];
}
return image;
}
/**
* converts the decoded buffer into a BufferedImage
* precision: 24 bit, componentCount = 3
* @param decoded data buffer
* @param width of the image
* @param height of the image
* @return a BufferedImage.TYPE_INT_RGB
*/
private BufferedImage read24Bit3ComponentRGB(int[][] decoded, int width, int height){
BufferedImage image = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
int[] imageBuffer = ((DataBufferInt) image.getRaster().getDataBuffer()).getData();
default:
throw new IOException("JPEG Lossless with " + decoder.getPrecision() + " bit precision and 3 components cannot be decoded");
}
}
throw new IOException("JPEG Lossless with " + decoder.getPrecision() + " bit precision and " + decoder.getNumComponents() + " component(s) cannot be decoded");
}
public Raster readRaster(final ImageInputStream input) throws IOException {
return readImage(input).getRaster();
}
/**
* converts the decoded buffer into a BufferedImage
* precision: 16 bit, componentCount = 1
*
* @param decoded data buffer
* @param width of the image
* @param height of the image
* @return a BufferedImage.TYPE_USHORT_GRAY
*/
private BufferedImage read16Bit1ComponentGrayScale(int[][] decoded, int width, int height) {
BufferedImage image = new BufferedImage(width, height, BufferedImage.TYPE_USHORT_GRAY);
short[] imageBuffer = ((DataBufferUShort) image.getRaster().getDataBuffer()).getData();
for (int i = 0; i < imageBuffer.length; i++) {
imageBuffer[i] = (short) decoded[0][i];
}
return image;
}
/**
* converts the decoded buffer into a BufferedImage
* precision: 8 bit, componentCount = 1
*
* @param decoded data buffer
* @param width of the image
* @param height of the image
* @return a BufferedImage.TYPE_BYTE_GRAY
*/
private BufferedImage read8Bit1ComponentGrayScale(int[][] decoded, int width, int height) {
BufferedImage image = new BufferedImage(width, height, BufferedImage.TYPE_BYTE_GRAY);
byte[] imageBuffer = ((DataBufferByte) image.getRaster().getDataBuffer()).getData();
for (int i = 0; i < imageBuffer.length; i++) {
imageBuffer[i] = (byte) decoded[0][i];
}
return image;
}
/**
* converts the decoded buffer into a BufferedImage
* precision: 24 bit, componentCount = 3
*
* @param decoded data buffer
* @param width of the image
* @param height of the image
* @return a BufferedImage.TYPE_INT_RGB
*/
private BufferedImage read24Bit3ComponentRGB(int[][] decoded, int width, int height) {
// TODO: Consider 3_BYTE_BGR as this is more common?
BufferedImage image = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
int[] imageBuffer = ((DataBufferInt) image.getRaster().getDataBuffer()).getData();
for (int i = 0; i < imageBuffer.length; i++) {
//convert to RGB
imageBuffer[i] = (decoded[0][i] << 16) | (decoded[1][i] << 8) | (decoded[2][i]);
}
return image;
}
for(int i = 0; i < imageBuffer.length; i++){
//convert to RGB
imageBuffer[i] = (decoded[0][i] << 16) | (decoded[1][i] << 8) | (decoded[2][i]);
}
return image;
}
}

169
imageio/imageio-jpeg/src/main/java/com/twelvemonkeys/imageio/plugins/jpeg/lossless/QuantizationTable.java
View File

@ -30,112 +30,109 @@
package com.twelvemonkeys.imageio.plugins.jpeg.lossless;
import javax.imageio.stream.ImageInputStream;
import java.io.IOException;
public class QuantizationTable {
private final int precision[] = new int[4]; // Quantization precision 8 or 16
private final int[] tq = new int[4]; // 1: this table is presented
private final int precision[] = new int[4]; // Quantization precision 8 or 16
private final int[] tq = new int[4]; // 1: this table is presented
protected final int quantTables[][] = new int[4][64]; // Tables
protected final int quantTables[][] = new int[4][64]; // Tables
public QuantizationTable() {
tq[0] = 0;
tq[1] = 0;
tq[2] = 0;
tq[3] = 0;
}
protected int read(final ImageInputStream data, final int[] table) throws IOException {
int count = 0;
final int length = data.readUnsignedShort();
count += 2;
public QuantizationTable() {
tq[0] = 0;
tq[1] = 0;
tq[2] = 0;
tq[3] = 0;
}
while (count < length) {
final int temp = data.readUnsignedByte();
count++;
final int t = temp & 0x0F;
if (t > 3) {
throw new IOException("ERROR: Quantization table ID > 3");
}
precision[t] = temp >> 4;
protected int read(final DataStream data, final int[] table) throws IOException {
int count = 0;
final int length = data.get16();
count += 2;
if (precision[t] == 0) {
precision[t] = 8;
}
else if (precision[t] == 1) {
precision[t] = 16;
}
else {
throw new IOException("ERROR: Quantization table precision error");
}
while (count < length) {
final int temp = data.get8();
count++;
final int t = temp & 0x0F;
tq[t] = 1;
if (t > 3) {
throw new IOException("ERROR: Quantization table ID > 3");
}
if (precision[t] == 8) {
for (int i = 0; i < 64; i++) {
if (count > length) {
throw new IOException("ERROR: Quantization table format error");
}
precision[t] = temp >> 4;
quantTables[t][i] = data.readUnsignedByte();
count++;
}
if (precision[t] == 0) {
precision[t] = 8;
} else if (precision[t] == 1) {
precision[t] = 16;
} else {
throw new IOException("ERROR: Quantization table precision error");
}
enhanceQuantizationTable(quantTables[t], table);
}
else {
for (int i = 0; i < 64; i++) {
if (count > length) {
throw new IOException("ERROR: Quantization table format error");
}
tq[t] = 1;
quantTables[t][i] = data.readUnsignedShort();
count += 2;
}
if (precision[t] == 8) {
for (int i = 0; i < 64; i++) {
if (count > length) {
throw new IOException("ERROR: Quantization table format error");
}
enhanceQuantizationTable(quantTables[t], table);
}
}
quantTables[t][i] = data.get8();
count++;
}
if (count != length) {
throw new IOException("ERROR: Quantization table error [count!=Lq]");
}
enhanceQuantizationTable(quantTables[t], table);
} else {
for (int i = 0; i < 64; i++) {
if (count > length) {
throw new IOException("ERROR: Quantization table format error");
}
return 1;
}
quantTables[t][i] = data.get16();
count += 2;
}
private void enhanceQuantizationTable(final int qtab[], final int[] table) {
for (int i = 0; i < 8; i++) {
qtab[table[(0 * 8) + i]] *= 90;
qtab[table[(4 * 8) + i]] *= 90;
qtab[table[(2 * 8) + i]] *= 118;
qtab[table[(6 * 8) + i]] *= 49;
qtab[table[(5 * 8) + i]] *= 71;
qtab[table[(1 * 8) + i]] *= 126;
qtab[table[(7 * 8) + i]] *= 25;
qtab[table[(3 * 8) + i]] *= 106;
}
enhanceQuantizationTable(quantTables[t], table);
}
}
for (int i = 0; i < 8; i++) {
qtab[table[0 + (8 * i)]] *= 90;
qtab[table[4 + (8 * i)]] *= 90;
qtab[table[2 + (8 * i)]] *= 118;
qtab[table[6 + (8 * i)]] *= 49;
qtab[table[5 + (8 * i)]] *= 71;
qtab[table[1 + (8 * i)]] *= 126;
qtab[table[7 + (8 * i)]] *= 25;
qtab[table[3 + (8 * i)]] *= 106;
}
if (count != length) {
throw new IOException("ERROR: Quantization table error [count!=Lq]");
}
return 1;
}
private void enhanceQuantizationTable(final int qtab[], final int[] table) {
for (int i = 0; i < 8; i++) {
qtab[table[(0 * 8) + i]] *= 90;
qtab[table[(4 * 8) + i]] *= 90;
qtab[table[(2 * 8) + i]] *= 118;
qtab[table[(6 * 8) + i]] *= 49;
qtab[table[(5 * 8) + i]] *= 71;
qtab[table[(1 * 8) + i]] *= 126;
qtab[table[(7 * 8) + i]] *= 25;
qtab[table[(3 * 8) + i]] *= 106;
}
for (int i = 0; i < 8; i++) {
qtab[table[0 + (8 * i)]] *= 90;
qtab[table[4 + (8 * i)]] *= 90;
qtab[table[2 + (8 * i)]] *= 118;
qtab[table[6 + (8 * i)]] *= 49;
qtab[table[5 + (8 * i)]] *= 71;
qtab[table[1 + (8 * i)]] *= 126;
qtab[table[7 + (8 * i)]] *= 25;
qtab[table[3 + (8 * i)]] *= 106;
}
for (int i = 0; i < 64; i++) {
qtab[i] >>= 6;
}
}
for (int i = 0; i < 64; i++) {
qtab[i] >>= 6;
}
}
}

54
imageio/imageio-jpeg/src/main/java/com/twelvemonkeys/imageio/plugins/jpeg/lossless/ScanComponent.java
View File

@ -32,43 +32,31 @@ package com.twelvemonkeys.imageio.plugins.jpeg.lossless;
public class ScanComponent {
private int acTabSel; // AC table selector
private int dcTabSel; // DC table selector
private int scanCompSel; // Scan component selector
private int acTabSel; // AC table selector
private int dcTabSel; // DC table selector
private int scanCompSel; // Scan component selector
public int getAcTabSel() {
return acTabSel;
}
public int getDcTabSel() {
return dcTabSel;
}
public int getAcTabSel() {
return acTabSel;
}
public int getScanCompSel() {
return scanCompSel;
}
public void setAcTabSel(final int acTabSel) {
this.acTabSel = acTabSel;
}
public void setDcTabSel(final int dcTabSel) {
this.dcTabSel = dcTabSel;
}
public int getDcTabSel() {
return dcTabSel;
}
public int getScanCompSel() {
return scanCompSel;
}
public void setAcTabSel(final int acTabSel) {
this.acTabSel = acTabSel;
}
public void setDcTabSel(final int dcTabSel) {
this.dcTabSel = dcTabSel;
}
public void setScanCompSel(final int scanCompSel) {
this.scanCompSel = scanCompSel;
}
public void setScanCompSel(final int scanCompSel) {
this.scanCompSel = scanCompSel;
}
}

152
imageio/imageio-jpeg/src/main/java/com/twelvemonkeys/imageio/plugins/jpeg/lossless/ScanHeader.java
View File

@ -30,117 +30,97 @@
package com.twelvemonkeys.imageio.plugins.jpeg.lossless;
import javax.imageio.stream.ImageInputStream;
import java.io.IOException;
public class ScanHeader {
private int ah;
private int al;
private int numComp; // Number of components in the scan
private int selection; // Start of spectral or predictor selection
private int spectralEnd; // End of spectral selection
private int ah;
private int al;
private int numComp; // Number of components in the scan
private int selection; // Start of spectral or predictor selection
private int spectralEnd; // End of spectral selection
protected ScanComponent components[];
protected ScanComponent components[];
public int getAh() {
return ah;
}
public int getAl() {
return al;
}
public int getAh() {
return ah;
}
public int getNumComponents() {
return numComp;
}
public int getSelection() {
return selection;
}
public int getSpectralEnd() {
return spectralEnd;
}
public int getAl() {
return al;
}
public void setAh(final int ah) {
this.ah = ah;
}
public void setAl(final int al) {
this.al = al;
}
public void setSelection(final int selection) {
this.selection = selection;
}
public int getNumComponents() {
return numComp;
}
public void setSpectralEnd(final int spectralEnd) {
this.spectralEnd = spectralEnd;
}
protected int read(final ImageInputStream data) throws IOException {
int count = 0;
final int length = data.readUnsignedShort();
count += 2;
numComp = data.readUnsignedByte();
count++;
public int getSelection() {
return selection;
}
components = new ScanComponent[numComp];
for (int i = 0; i < numComp; i++) {
components[i] = new ScanComponent();
if (count > length) {
throw new IOException("ERROR: scan header format error");
}
public int getSpectralEnd() {
return spectralEnd;
}
components[i].setScanCompSel(data.readUnsignedByte());
count++;
final int temp = data.readUnsignedByte();
count++;
components[i].setDcTabSel(temp >> 4);
components[i].setAcTabSel(temp & 0x0F);
}
public void setAh(final int ah) {
this.ah = ah;
}
setSelection(data.readUnsignedByte());
count++;
setSpectralEnd(data.readUnsignedByte());
count++;
final int temp = data.readUnsignedByte();
setAh(temp >> 4);
setAl(temp & 0x0F);
count++;
public void setAl(final int al) {
this.al = al;
}
if (count != length) {
throw new IOException("ERROR: scan header format error [count!=Ns]");
}
public void setSelection(final int selection) {
this.selection = selection;
}
public void setSpectralEnd(final int spectralEnd) {
this.spectralEnd = spectralEnd;
}
protected int read(final DataStream data) throws IOException {
int count = 0;
final int length = data.get16();
count += 2;
numComp = data.get8();
count++;
components = new ScanComponent[numComp];
for (int i = 0; i < numComp; i++) {
components[i] = new ScanComponent();
if (count > length) {
throw new IOException("ERROR: scan header format error");
}
components[i].setScanCompSel(data.get8());
count++;
final int temp = data.get8();
count++;
components[i].setDcTabSel(temp >> 4);
components[i].setAcTabSel(temp & 0x0F);
}
setSelection(data.get8());
count++;
setSpectralEnd(data.get8());
count++;
final int temp = data.get8();
setAh(temp >> 4);
setAl(temp & 0x0F);
count++;
if (count != length) {
throw new IOException("ERROR: scan header format error [count!=Ns]");
}
return 1;
}
return 1;
}
}

4
imageio/imageio-jpeg/src/test/java/com/twelvemonkeys/imageio/plugins/jpeg/JPEGImageReaderTest.java
View File

@ -94,7 +94,8 @@ public class JPEGImageReaderTest extends ImageReaderAbstractTest<JPEGImageReader
new TestData(getClassLoaderResource("/jpeg/jfif-padded-segments.jpg"), new Dimension(20, 45)),
new TestData(getClassLoaderResource("/jpeg/0x00-to-0xFF-between-segments.jpg"), new Dimension(16, 16)),
new TestData(getClassLoaderResource("/jpeg/jfif-bogus-empty-jfif-segment.jpg"), new Dimension(942, 714)),
new TestData(getClassLoaderResource("/jpeg/jfif-16bit-dqt.jpg"), new Dimension(204, 131))
new TestData(getClassLoaderResource("/jpeg/jfif-16bit-dqt.jpg"), new Dimension(204, 131)),
new TestData(getClassLoaderResource("/jpeg-lossless/testimgl.jpg"), new Dimension(227, 149))
);
// More test data in specific tests below
@ -1175,6 +1176,7 @@ public class JPEGImageReaderTest extends ImageReaderAbstractTest<JPEGImageReader
}
}
catch (IIOException e) {
e.printStackTrace();
fail(String.format("Reading metadata failed for %s image %s: %s", testData, i, e.getMessage()));
}
}

16
imageio/imageio-metadata/src/main/java/com/twelvemonkeys/imageio/metadata/jpeg/JPEG.java
View File

@ -49,6 +49,22 @@ public interface JPEG {
/** Define Huffman Tables segment marker (DHT). */
int DHT = 0xFFC4;
/** Comment (COM) */
int COM = 0xFFFE;
/** Define Number of Lines (DNL). */
int DNL = 0xFFDC;
/** Define Restart Interval (DRI). */
int DRI = 0xFFDD;
/** Define Hierarchical Progression (DHP). */
int DHP = 0xFFDE;
/** Expand reference components (EXP). */
int EXP = 0xFFDF;
/** Temporary use in arithmetic coding (TEM). */
int TEM = 0xFF01;
/** Define Define Arithmetic Coding conditioning (DAC). */
int DAC = 0xFFCC;
// App segment markers (APPn).
int APP0 = 0xFFE0;
int APP1 = 0xFFE1;

2
imageio/imageio-metadata/src/main/java/com/twelvemonkeys/imageio/metadata/jpeg/JPEGSegment.java
View File

@ -43,7 +43,7 @@ import java.util.Arrays;
public final class JPEGSegment implements Serializable {
final int marker;
final byte[] data;
final int length;
private final int length;
private transient String id;