jdk-sandbox: comparison jdk/src/share/classes/com/sun/imageio/plugins/jpeg/JPEGImageReader.java

equal deleted inserted replaced

-:e6248b598ca5
+:de653b2cab31
 import java.awt.image.ColorConvertOp;
 import java.io.IOException;
 import java.util.List;
 import java.util.Iterator;
 import java.util.ArrayList;
+import java.util.NoSuchElementException;
 import sun.java2d.Disposer;
 import sun.java2d.DisposerRecord;
 public class JPEGImageReader extends ImageReader {
 /** The referent to be registered with the Disposer. */
 private Object disposerReferent = new Object();
 /** The DisposerRecord that handles the actual disposal of this reader. */
 private DisposerRecord disposerRecord;
-/**
-* Maintain an array of the default image types corresponding to the
-* various supported IJG colorspace codes.
-*/
-private static final ImageTypeSpecifier [] defaultTypes =
-new ImageTypeSpecifier [JPEG.NUM_JCS_CODES];
-static {
-defaultTypes[JPEG.JCS_GRAYSCALE] =
-ImageTypeSpecifier.createFromBufferedImageType
-(BufferedImage.TYPE_BYTE_GRAY);
-defaultTypes[JPEG.JCS_RGB] =
-ImageTypeSpecifier.createInterleaved
-(JPEG.JCS.sRGB,
-JPEG.bOffsRGB,
-DataBuffer.TYPE_BYTE,
-false,
-false);
-defaultTypes[JPEG.JCS_RGBA] =
-ImageTypeSpecifier.createPacked
-(JPEG.JCS.sRGB,
-0xff000000,
-0x00ff0000,
-0x0000ff00,
-0x000000ff,
-DataBuffer.TYPE_INT,
-false);
-if (JPEG.JCS.YCC != null) {
-defaultTypes[JPEG.JCS_YCC] =
-ImageTypeSpecifier.createInterleaved
-(JPEG.JCS.YCC,
-JPEG.bandOffsets[2],
-DataBuffer.TYPE_BYTE,
-false,
-false);
-defaultTypes[JPEG.JCS_YCCA] =
-ImageTypeSpecifier.createInterleaved
-(JPEG.JCS.YCC,
-JPEG.bandOffsets[3],
-DataBuffer.TYPE_BYTE,
-true,
-false);
-}
-}
 /** Sets up static C structures. */
 private static native void initReaderIDs(Class iisClass,
 Class qTableClass,
 Class huffClass);
 /**
 * Return an ImageTypeSpecifier corresponding to the given
 * color space code, or null if the color space is unsupported.
 */
-private ImageTypeSpecifier getImageType(int code) {
+private ImageTypeProducer getImageType(int code) {
-ImageTypeSpecifier ret = null;
+ImageTypeProducer ret = null;
 if ((code > 0) && (code < JPEG.NUM_JCS_CODES)) {
-ret = defaultTypes[code];
+ret = ImageTypeProducer.getTypeProducer(code);
 }
 return ret;
 }
 public ImageTypeSpecifier getRawImageType(int imageIndex)
 if (currentImage != imageIndex) {
 readHeader(imageIndex, true);
 }
 // Returns null if it can't be represented
-return getImageType(colorSpaceCode);
+return getImageType(colorSpaceCode).getType();
 } finally {
 clearThreadLock();
 }
 }
 // If this image can't be interpreted, this method
 // returns an empty Iterator.
 // Get the raw ITS, if there is one.  Note that this
 // won't always be the same as the default.
-ImageTypeSpecifier raw = getImageType(colorSpaceCode);
+ImageTypeProducer raw = getImageType(colorSpaceCode);
 // Given the encoded colorspace, build a list of ITS's
 // representing outputs you could handle starting
 // with the default.
-ArrayList list = new ArrayList(1);
+ArrayList<ImageTypeProducer> list = new ArrayList<ImageTypeProducer>(1);
 switch (colorSpaceCode) {
 case JPEG.JCS_GRAYSCALE:
 list.add(raw);
 list.add(getImageType(JPEG.JCS_RGB));
 break;
 case JPEG.JCS_RGB:
 list.add(raw);
 list.add(getImageType(JPEG.JCS_GRAYSCALE));
-if (JPEG.JCS.YCC != null) {
+list.add(getImageType(JPEG.JCS_YCC));
-list.add(getImageType(JPEG.JCS_YCC));
-}
 break;
 case JPEG.JCS_RGBA:
 list.add(raw);
 break;
 case JPEG.JCS_YCC:
 // due to 4705399, use RGB as default in order to avoid
 // slowing down of drawing operations with result image.
 list.add(getImageType(JPEG.JCS_RGB));
 if (iccCS != null) {
-list.add(ImageTypeSpecifier.createInterleaved
+list.add(new ImageTypeProducer() {
+protected ImageTypeSpecifier produce() {
+return ImageTypeSpecifier.createInterleaved
 (iccCS,
 JPEG.bOffsRGB,  // Assume it's for RGB
 DataBuffer.TYPE_BYTE,
 false,
-false));
+false);
+}
+});
 }
 list.add(getImageType(JPEG.JCS_GRAYSCALE));
-if (JPEG.JCS.YCC != null) { // Might be null if PYCC.pf not installed
+list.add(getImageType(JPEG.JCS_YCC));
-list.add(getImageType(JPEG.JCS_YCC));
-}
 break;
 case JPEG.JCS_YCbCrA:  // Default is to convert to RGBA
 // As there is no YCbCr ColorSpace, we can't support
 // the raw type.
 list.add(getImageType(JPEG.JCS_RGBA));
 break;
 }
-return list.iterator();
+return new ImageTypeIterator(list.iterator());
 }
 /**
 * Checks the implied color conversion between the stream and
 * the target image, altering the IJG output color space if necessary.
 switch (outColorSpaceCode) {
 case JPEG.JCS_GRAYSCALE:  // Its gray in the file
 if  (csType == ColorSpace.TYPE_RGB) { // We want RGB
 // IJG can do this for us more efficiently
 setOutColorSpace(structPointer, JPEG.JCS_RGB);
+// Update java state according to changes
+// in the native part of decoder.
+outColorSpaceCode = JPEG.JCS_RGB;
+numComponents = 3;
 } else if (csType != ColorSpace.TYPE_GRAY) {
 throw new IIOException("Incompatible color conversion");
 }
 break;
 case JPEG.JCS_RGB:  // IJG wants to go to RGB
 if (csType ==  ColorSpace.TYPE_GRAY) {  // We want gray
 if (colorSpaceCode == JPEG.JCS_YCbCr) {
 // If the jpeg space is YCbCr, IJG can do it
 setOutColorSpace(structPointer, JPEG.JCS_GRAYSCALE);
+// Update java state according to changes
+// in the native part of decoder.
+outColorSpaceCode = JPEG.JCS_GRAYSCALE;
+numComponents = 1;
 }
 } else if ((iccCS != null) &&
 (cm.getNumComponents() == numComponents) &&
 (cs != iccCS)) {
 // We have an ICC profile but it isn't used in the dest
 (cm.getNumComponents() != numComponents)) {
 throw new IIOException("Incompatible color conversion");
 }
 break;
 case JPEG.JCS_YCC:
-if (JPEG.JCS.YCC == null) { // We can't do YCC at all
+{
-throw new IIOException("Incompatible color conversion");
+ColorSpace YCC = JPEG.JCS.getYCC();
-}
+if (YCC == null) { // We can't do YCC at all
-if ((cs != JPEG.JCS.YCC) &&
+throw new IIOException("Incompatible color conversion");
-(cm.getNumComponents() == numComponents)) {
+}
-convert = new ColorConvertOp(JPEG.JCS.YCC, cs, null);
+if ((cs != YCC) &&
+(cm.getNumComponents() == numComponents)) {
+convert = new ColorConvertOp(YCC, cs, null);
+}
 }
 break;
 case JPEG.JCS_YCCA:
-// No conversions available; image must be YCCA
+{
-if ((JPEG.JCS.YCC == null) || // We can't do YCC at all
+ColorSpace YCC = JPEG.JCS.getYCC();
-(cs != JPEG.JCS.YCC) ||
+// No conversions available; image must be YCCA
-(cm.getNumComponents() != numComponents)) {
+if ((YCC == null) || // We can't do YCC at all
-throw new IIOException("Incompatible color conversion");
+(cs != YCC) ||
+(cm.getNumComponents() != numComponents)) {
+throw new IIOException("Incompatible color conversion");
+}
 }
 break;
 default:
 // Anything else we can't handle at all
 throw new IIOException("Incompatible color conversion");
 if (theLockCount == 0) {
 theThread = null;
 }
 }
 }
+/**
+* An internal helper class that wraps producer's iterator
+* and extracts specifier instances on demand.
+*/
+class ImageTypeIterator implements Iterator<ImageTypeSpecifier> {
+private Iterator<ImageTypeProducer> producers;
+private ImageTypeSpecifier theNext = null;
+public ImageTypeIterator(Iterator<ImageTypeProducer> producers) {
+this.producers = producers;
+}
+public boolean hasNext() {
+if (theNext != null) {
+return true;
+}
+if (!producers.hasNext()) {
+return false;
+}
+do {
+theNext = producers.next().getType();
+} while (theNext == null && producers.hasNext());
+return (theNext != null);
+}
+public ImageTypeSpecifier next() {
+if (theNext != null || hasNext()) {
+ImageTypeSpecifier t = theNext;
+theNext = null;
+return t;
+} else {
+throw new NoSuchElementException();
+}
+}
+public void remove() {
+producers.remove();
+}
+}
+/**
+* An internal helper class that provides means for deferred creation
+* of ImageTypeSpecifier instance required to describe available
+* destination types.
+*
+* This implementation only supports standard
+* jpeg color spaces (defined by corresponding JCS color space code).
+*
+* To support other color spaces one can override produce() method to
+* return custom instance of ImageTypeSpecifier.
+*/
+class ImageTypeProducer {
+private ImageTypeSpecifier type = null;
+boolean failed = false;
+private int csCode;
+public ImageTypeProducer(int csCode) {
+this.csCode = csCode;
+}
+public ImageTypeProducer() {
+csCode = -1; // undefined
+}
+public synchronized ImageTypeSpecifier getType() {
+if (!failed && type == null) {
+try {
+type = produce();
+} catch (Throwable e) {
+failed = true;
+}
+}
+return type;
+}
+private static final ImageTypeProducer [] defaultTypes =
+new ImageTypeProducer [JPEG.NUM_JCS_CODES];
+public synchronized static ImageTypeProducer getTypeProducer(int csCode) {
+if (csCode < 0 || csCode >= JPEG.NUM_JCS_CODES) {
+return null;
+}
+if (defaultTypes[csCode] == null) {
+defaultTypes[csCode] = new ImageTypeProducer(csCode);
+}
+return defaultTypes[csCode];
+}
+protected ImageTypeSpecifier produce() {
+switch (csCode) {
+case JPEG.JCS_GRAYSCALE:
+return ImageTypeSpecifier.createFromBufferedImageType
+(BufferedImage.TYPE_BYTE_GRAY);
+case JPEG.JCS_RGB:
+return ImageTypeSpecifier.createInterleaved(JPEG.JCS.sRGB,
+JPEG.bOffsRGB,
+DataBuffer.TYPE_BYTE,
+false,
+false);
+case JPEG.JCS_RGBA:
+return ImageTypeSpecifier.createPacked(JPEG.JCS.sRGB,
+0xff000000,
+0x00ff0000,
+0x0000ff00,
+0x000000ff,
+DataBuffer.TYPE_INT,
+false);
+case JPEG.JCS_YCC:
+if (JPEG.JCS.getYCC() != null) {
+return ImageTypeSpecifier.createInterleaved(
+JPEG.JCS.getYCC(),
+JPEG.bandOffsets[2],
+DataBuffer.TYPE_BYTE,
+false,
+false);
+} else {
+return null;
+}
+case JPEG.JCS_YCCA:
+if (JPEG.JCS.getYCC() != null) {
+return ImageTypeSpecifier.createInterleaved(
+JPEG.JCS.getYCC(),
+JPEG.bandOffsets[3],
+DataBuffer.TYPE_BYTE,
+true,
+false);
+} else {
+return null;
+}
+default:
+return null;
+}
+}
+}

changeset 3009	de653b2cab31
parent 2381	0afc5d868c46
child 3013	d661931d1ca0