1 /*

     2  * Copyright (c) 2000, 2016, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.  Oracle designates this

     8  * particular file as subject to the "Classpath" exception as provided

     9  * by Oracle in the LICENSE file that accompanied this code.

    10  *

    11  * This code is distributed in the hope that it will be useful, but WITHOUT

    12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    14  * version 2 for more details (a copy is included in the LICENSE file that

    15  * accompanied this code).

    16  *

    17  * You should have received a copy of the GNU General Public License version

    18  * 2 along with this work; if not, write to the Free Software Foundation,

    19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    20  *

    21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    22  * or visit www.oracle.com if you need additional information or have any

    23  * questions.

    24  */

    25 

    26 package com.sun.imageio.plugins.jpeg;

    27 

    28 import javax.imageio.IIOException;

    29 import javax.imageio.ImageReader;

    30 import javax.imageio.ImageReadParam;

    31 import javax.imageio.ImageTypeSpecifier;

    32 import javax.imageio.metadata.IIOMetadata;

    33 import javax.imageio.spi.ImageReaderSpi;

    34 import javax.imageio.stream.ImageInputStream;

    35 import javax.imageio.plugins.jpeg.JPEGImageReadParam;

    36 import javax.imageio.plugins.jpeg.JPEGQTable;

    37 import javax.imageio.plugins.jpeg.JPEGHuffmanTable;

    38 

    39 import java.awt.Point;

    40 import java.awt.Rectangle;

    41 import java.awt.color.ColorSpace;

    42 import java.awt.color.ICC_Profile;

    43 import java.awt.color.ICC_ColorSpace;

    44 import java.awt.color.CMMException;

    45 import java.awt.image.BufferedImage;

    46 import java.awt.image.Raster;

    47 import java.awt.image.WritableRaster;

    48 import java.awt.image.DataBuffer;

    49 import java.awt.image.DataBufferByte;

    50 import java.awt.image.ColorModel;

    51 import java.awt.image.IndexColorModel;

    52 import java.awt.image.ColorConvertOp;

    53 import java.io.IOException;

    54 import java.util.List;

    55 import java.util.Iterator;

    56 import java.util.ArrayList;

    57 import java.util.NoSuchElementException;

    58 

    59 import sun.java2d.Disposer;

    60 import sun.java2d.DisposerRecord;

    61 

    62 public class JPEGImageReader extends ImageReader {

    63 

    64     private boolean debug = false;

    65 

    66     /**

    67      * The following variable contains a pointer to the IJG library

    68      * structure for this reader.  It is assigned in the constructor

    69      * and then is passed in to every native call.  It is set to 0

    70      * by dispose to avoid disposing twice.

    71      */

    72     private long structPointer = 0;

    73 

    74     /** The input stream we read from */

    75     private ImageInputStream iis = null;

    76 

    77     /**

    78      * List of stream positions for images, reinitialized every time

    79      * a new input source is set.

    80      */

    81     private List<Long> imagePositions = null;

    82 

    83     /**

    84      * The number of images in the stream, or 0.

    85      */

    86     private int numImages = 0;

    87 

    88     static {

    89         java.security.AccessController.doPrivileged(

    90             new java.security.PrivilegedAction<Void>() {

    91                 public Void run() {

    92                     System.loadLibrary("javajpeg");

    93                     return null;

    94                 }

    95             });

    96         initReaderIDs(ImageInputStream.class,

    97                       JPEGQTable.class,

    98                       JPEGHuffmanTable.class);

    99     }

   100 

   101     // The following warnings are converted to strings when used

   102     // as keys to get localized resources from JPEGImageReaderResources

   103     // and its children.

   104 

   105     /**

   106      * Warning code to be passed to warningOccurred to indicate

   107      * that the EOI marker is missing from the end of the stream.

   108      * This usually signals that the stream is corrupted, but

   109      * everything up to the last MCU should be usable.

   110      */

   111     protected static final int WARNING_NO_EOI = 0;

   112 

   113     /**

   114      * Warning code to be passed to warningOccurred to indicate

   115      * that a JFIF segment was encountered inside a JFXX JPEG

   116      * thumbnail and is being ignored.

   117      */

   118     protected static final int WARNING_NO_JFIF_IN_THUMB = 1;

   119 

   120     /**

   121      * Warning code to be passed to warningOccurred to indicate

   122      * that embedded ICC profile is invalid and will be ignored.

   123      */

   124     protected static final int WARNING_IGNORE_INVALID_ICC = 2;

   125 

   126     private static final int MAX_WARNING = WARNING_IGNORE_INVALID_ICC;

   127 

   128     /**

   129      * Image index of image for which header information

   130      * is available.

   131      */

   132     private int currentImage = -1;

   133 

   134     // The following is copied out from C after reading the header.

   135     // Unlike metadata, which may never be retrieved, we need this

   136     // if we are to read an image at all.

   137 

   138     /** Set by setImageData native code callback */

   139     private int width;

   140     /** Set by setImageData native code callback */

   141     private int height;

   142     /**

   143      * Set by setImageData native code callback.  A modified

   144      * IJG+NIFTY colorspace code.

   145      */

   146     private int colorSpaceCode;

   147     /**

   148      * Set by setImageData native code callback.  A modified

   149      * IJG+NIFTY colorspace code.

   150      */

   151     private int outColorSpaceCode;

   152     /** Set by setImageData native code callback */

   153     private int numComponents;

   154     /** Set by setImageData native code callback */

   155     private ColorSpace iccCS = null;

   156 

   157 

   158     /** If we need to post-convert in Java, convert with this op */

   159     private ColorConvertOp convert = null;

   160 

   161     /** The image we are going to fill */

   162     private BufferedImage image = null;

   163 

   164     /** An intermediate Raster to hold decoded data */

   165     private WritableRaster raster = null;

   166 

   167     /** A view of our target Raster that we can setRect to */

   168     private WritableRaster target = null;

   169 

   170     /** The databuffer for the above Raster */

   171     private DataBufferByte buffer = null;

   172 

   173     /** The region in the destination where we will write pixels */

   174     private Rectangle destROI = null;

   175 

   176     /** The list of destination bands, if any */

   177     private int [] destinationBands = null;

   178 

   179     /** Stream metadata, cached, even when the stream is changed. */

   180     private JPEGMetadata streamMetadata = null;

   181 

   182     /** Image metadata, valid for the imageMetadataIndex only. */

   183     private JPEGMetadata imageMetadata = null;

   184     private int imageMetadataIndex = -1;

   185 

   186     /**

   187      * Set to true every time we seek in the stream; used to

   188      * invalidate the native buffer contents in C.

   189      */

   190     private boolean haveSeeked = false;

   191 

   192     /**

   193      * Tables that have been read from a tables-only image at the

   194      * beginning of a stream.

   195      */

   196     private JPEGQTable [] abbrevQTables = null;

   197     private JPEGHuffmanTable[] abbrevDCHuffmanTables = null;

   198     private JPEGHuffmanTable[] abbrevACHuffmanTables = null;

   199 

   200     private int minProgressivePass = 0;

   201     private int maxProgressivePass = Integer.MAX_VALUE;

   202 

   203     /**

   204      * Variables used by progress monitoring.

   205      */

   206     private static final int UNKNOWN = -1;  // Number of passes

   207     private static final int MIN_ESTIMATED_PASSES = 10; // IJG default

   208     private int knownPassCount = UNKNOWN;

   209     private int pass = 0;

   210     private float percentToDate = 0.0F;

   211     private float previousPassPercentage = 0.0F;

   212     private int progInterval = 0;

   213 

   214     /**

   215      * Set to true once stream has been checked for stream metadata

   216      */

   217     private boolean tablesOnlyChecked = false;

   218 

   219     /** The referent to be registered with the Disposer. */

   220     private Object disposerReferent = new Object();

   221 

   222     /** The DisposerRecord that handles the actual disposal of this reader. */

   223     private DisposerRecord disposerRecord;

   224 

   225     /** Sets up static C structures. */

   226     private static native void initReaderIDs(Class<?> iisClass,

   227                                              Class<?> qTableClass,

   228                                              Class<?> huffClass);

   229 

   230     public JPEGImageReader(ImageReaderSpi originator) {

   231         super(originator);

   232         structPointer = initJPEGImageReader();

   233         disposerRecord = new JPEGReaderDisposerRecord(structPointer);

   234         Disposer.addRecord(disposerReferent, disposerRecord);

   235     }

   236 

   237     /** Sets up per-reader C structure and returns a pointer to it. */

   238     private native long initJPEGImageReader();

   239 

   240     /**

   241      * Called by the native code or other classes to signal a warning.

   242      * The code is used to lookup a localized message to be used when

   243      * sending warnings to listeners.

   244      */

   245     protected void warningOccurred(int code) {

   246         cbLock.lock();

   247         try {

   248             if ((code < 0) || (code > MAX_WARNING)){

   249                 throw new InternalError("Invalid warning index");

   250             }

   251             processWarningOccurred

   252                 ("com.sun.imageio.plugins.jpeg.JPEGImageReaderResources",

   253                  Integer.toString(code));

   254         } finally {

   255             cbLock.unlock();

   256         }

   257     }

   258 

   259     /**

   260      * The library has it's own error facility that emits warning messages.

   261      * This routine is called by the native code when it has already

   262      * formatted a string for output.

   263      * XXX  For truly complete localization of all warning messages,

   264      * the sun_jpeg_output_message routine in the native code should

   265      * send only the codes and parameters to a method here in Java,

   266      * which will then format and send the warnings, using localized

   267      * strings.  This method will have to deal with all the parameters

   268      * and formats (%u with possibly large numbers, %02d, %02x, etc.)

   269      * that actually occur in the JPEG library.  For now, this prevents

   270      * library warnings from being printed to stderr.

   271      */

   272     protected void warningWithMessage(String msg) {

   273         cbLock.lock();

   274         try {

   275             processWarningOccurred(msg);

   276         } finally {

   277             cbLock.unlock();

   278         }

   279     }

   280 

   281     public void setInput(Object input,

   282                          boolean seekForwardOnly,

   283                          boolean ignoreMetadata)

   284     {

   285         setThreadLock();

   286         try {

   287             cbLock.check();

   288 

   289             super.setInput(input, seekForwardOnly, ignoreMetadata);

   290             this.ignoreMetadata = ignoreMetadata;

   291             resetInternalState();

   292             iis = (ImageInputStream) input; // Always works

   293             setSource(structPointer);

   294         } finally {

   295             clearThreadLock();

   296         }

   297     }

   298 

   299     /**

   300      * This method is called from native code in order to fill

   301      * native input buffer.

   302      *

   303      * We block any attempt to change the reading state during this

   304      * method, in order to prevent a corruption of the native decoder

   305      * state.

   306      *

   307      * @return number of bytes read from the stream.

   308      */

   309     private int readInputData(byte[] buf, int off, int len) throws IOException {

   310         cbLock.lock();

   311         try {

   312             return iis.read(buf, off, len);

   313         } finally {

   314             cbLock.unlock();

   315         }

   316     }

   317 

   318     /**

   319      * This method is called from the native code in order to

   320      * skip requested number of bytes in the input stream.

   321      *

   322      * @param n

   323      * @return

   324      * @throws IOException

   325      */

   326     private long skipInputBytes(long n) throws IOException {

   327         cbLock.lock();

   328         try {

   329             return iis.skipBytes(n);

   330         } finally {

   331             cbLock.unlock();

   332         }

   333     }

   334 

   335     private native void setSource(long structPointer);

   336 

   337     private void checkTablesOnly() throws IOException {

   338         if (debug) {

   339             System.out.println("Checking for tables-only image");

   340         }

   341         long savePos = iis.getStreamPosition();

   342         if (debug) {

   343             System.out.println("saved pos is " + savePos);

   344             System.out.println("length is " + iis.length());

   345         }

   346         // Read the first header

   347         boolean tablesOnly = readNativeHeader(true);

   348         if (tablesOnly) {

   349             if (debug) {

   350                 System.out.println("tables-only image found");

   351                 long pos = iis.getStreamPosition();

   352                 System.out.println("pos after return from native is " + pos);

   353             }

   354             // This reads the tables-only image twice, once from C

   355             // and once from Java, but only if ignoreMetadata is false

   356             if (ignoreMetadata == false) {

   357                 iis.seek(savePos);

   358                 haveSeeked = true;

   359                 streamMetadata = new JPEGMetadata(true, false,

   360                                                   iis, this);

   361                 long pos = iis.getStreamPosition();

   362                 if (debug) {

   363                     System.out.println

   364                         ("pos after constructing stream metadata is " + pos);

   365                 }

   366             }

   367             // Now we are at the first image if there are any, so add it

   368             // to the list

   369             if (hasNextImage()) {

   370                 imagePositions.add(iis.getStreamPosition());

   371             }

   372         } else { // Not tables only, so add original pos to the list

   373             imagePositions.add(savePos);

   374             // And set current image since we've read it now

   375             currentImage = 0;

   376         }

   377         if (seekForwardOnly) {

   378             Long pos = imagePositions.get(imagePositions.size()-1);

   379             iis.flushBefore(pos.longValue());

   380         }

   381         tablesOnlyChecked = true;

   382     }

   383 

   384     public int getNumImages(boolean allowSearch) throws IOException {

   385         setThreadLock();

   386         try { // locked thread

   387             cbLock.check();

   388 

   389             return getNumImagesOnThread(allowSearch);

   390         } finally {

   391             clearThreadLock();

   392         }

   393     }

   394 

   395     private void skipPastImage(int imageIndex) {

   396         cbLock.lock();

   397         try {

   398             gotoImage(imageIndex);

   399             skipImage();

   400         } catch (IOException | IndexOutOfBoundsException e) {

   401         } finally {

   402             cbLock.unlock();

   403         }

   404     }

   405 

   406     @SuppressWarnings("fallthrough")

   407     private int getNumImagesOnThread(boolean allowSearch)

   408       throws IOException {

   409         if (numImages != 0) {

   410             return numImages;

   411         }

   412         if (iis == null) {

   413             throw new IllegalStateException("Input not set");

   414         }

   415         if (allowSearch == true) {

   416             if (seekForwardOnly) {

   417                 throw new IllegalStateException(

   418                     "seekForwardOnly and allowSearch can't both be true!");

   419             }

   420             // Otherwise we have to read the entire stream

   421 

   422             if (!tablesOnlyChecked) {

   423                 checkTablesOnly();

   424             }

   425 

   426             iis.mark();

   427 

   428             gotoImage(0);

   429 

   430             JPEGBuffer buffer = new JPEGBuffer(iis);

   431             buffer.loadBuf(0);

   432 

   433             boolean done = false;

   434             while (!done) {

   435                 done = buffer.scanForFF(this);

   436                 switch (buffer.buf[buffer.bufPtr] & 0xff) {

   437                 case JPEG.SOI:

   438                     numImages++;

   439                     // FALL THROUGH to decrement buffer vars

   440                     // This first set doesn't have a length

   441                 case 0: // not a marker, just a data 0xff

   442                 case JPEG.RST0:

   443                 case JPEG.RST1:

   444                 case JPEG.RST2:

   445                 case JPEG.RST3:

   446                 case JPEG.RST4:

   447                 case JPEG.RST5:

   448                 case JPEG.RST6:

   449                 case JPEG.RST7:

   450                 case JPEG.EOI:

   451                     buffer.bufAvail--;

   452                     buffer.bufPtr++;

   453                     break;

   454                     // All the others have a length

   455                 default:

   456                     buffer.bufAvail--;

   457                     buffer.bufPtr++;

   458                     buffer.loadBuf(2);

   459                     int length = ((buffer.buf[buffer.bufPtr++] & 0xff) << 8) |

   460                         (buffer.buf[buffer.bufPtr++] & 0xff);

   461                     buffer.bufAvail -= 2;

   462                     length -= 2; // length includes itself

   463                     buffer.skipData(length);

   464                 }

   465             }

   466 

   467 

   468             iis.reset();

   469 

   470             return numImages;

   471         }

   472 

   473         return -1;  // Search is necessary for JPEG

   474     }

   475 

   476     /**

   477      * Sets the input stream to the start of the requested image.

   478      * <pre>

   479      * @exception IllegalStateException if the input source has not been

   480      * set.

   481      * @exception IndexOutOfBoundsException if the supplied index is

   482      * out of bounds.

   483      * </pre>

   484      */

   485     private void gotoImage(int imageIndex) throws IOException {

   486         if (iis == null) {

   487             throw new IllegalStateException("Input not set");

   488         }

   489         if (imageIndex < minIndex) {

   490             throw new IndexOutOfBoundsException();

   491         }

   492         if (!tablesOnlyChecked) {

   493             checkTablesOnly();

   494         }

   495         if (imageIndex < imagePositions.size()) {

   496             iis.seek(imagePositions.get(imageIndex).longValue());

   497         } else {

   498             // read to start of image, saving positions

   499             // First seek to the last position we already have, and skip the

   500             // entire image

   501             Long pos = imagePositions.get(imagePositions.size()-1);

   502             iis.seek(pos.longValue());

   503             skipImage();

   504             // Now add all intervening positions, skipping images

   505             for (int index = imagePositions.size();

   506                  index <= imageIndex;

   507                  index++) {

   508                 // Is there an image?

   509                 if (!hasNextImage()) {

   510                     throw new IndexOutOfBoundsException();

   511                 }

   512                 pos = iis.getStreamPosition();

   513                 imagePositions.add(pos);

   514                 if (seekForwardOnly) {

   515                     iis.flushBefore(pos.longValue());

   516                 }

   517                 if (index < imageIndex) {

   518                     skipImage();

   519                 }  // Otherwise we are where we want to be

   520             }

   521         }

   522 

   523         if (seekForwardOnly) {

   524             minIndex = imageIndex;

   525         }

   526 

   527         haveSeeked = true;  // No way is native buffer still valid

   528     }

   529 

   530     /**

   531      * Skip over a complete image in the stream, leaving the stream

   532      * positioned such that the next byte to be read is the first

   533      * byte of the next image. For JPEG, this means that we read

   534      * until we encounter an EOI marker or until the end of the stream.

   535      * We can find data same as EOI marker in some headers

   536      * or comments, so we have to skip bytes related to these headers.

   537      * If the stream ends before an EOI marker is encountered,

   538      * an IndexOutOfBoundsException is thrown.

   539      */

   540     private void skipImage() throws IOException {

   541         if (debug) {

   542             System.out.println("skipImage called");

   543         }

   544         // verify if image starts with an SOI marker

   545         int initialFF = iis.read();

   546         if (initialFF == 0xff) {

   547             int soiMarker = iis.read();

   548             if (soiMarker != JPEG.SOI) {

   549                 throw new IOException("skipImage : Invalid image doesn't "

   550                         + "start with SOI marker");

   551             }

   552         } else {

   553             throw new IOException("skipImage : Invalid image doesn't start "

   554                     + "with 0xff");

   555         }

   556         boolean foundFF = false;

   557         String IOOBE = "skipImage : Reached EOF before we got EOI marker";

   558         int markerLength = 2;

   559         for (int byteval = iis.read();

   560              byteval != -1;

   561              byteval = iis.read()) {

   562 

   563             if (foundFF == true) {

   564                 switch (byteval) {

   565                     case JPEG.EOI:

   566                         if (debug) {

   567                             System.out.println("skipImage : Found EOI at " +

   568                                     (iis.getStreamPosition() - markerLength));

   569                         }

   570                         return;

   571                     case JPEG.SOI:

   572                         throw new IOException("skipImage : Found extra SOI"

   573                                 + " marker before getting to EOI");

   574                     case 0:

   575                     case 255:

   576                     // markers which doesn't contain length data

   577                     case JPEG.RST0:

   578                     case JPEG.RST1:

   579                     case JPEG.RST2:

   580                     case JPEG.RST3:

   581                     case JPEG.RST4:

   582                     case JPEG.RST5:

   583                     case JPEG.RST6:

   584                     case JPEG.RST7:

   585                     case JPEG.TEM:

   586                         break;

   587                     // markers which contains length data

   588                     case JPEG.SOF0:

   589                     case JPEG.SOF1:

   590                     case JPEG.SOF2:

   591                     case JPEG.SOF3:

   592                     case JPEG.DHT:

   593                     case JPEG.SOF5:

   594                     case JPEG.SOF6:

   595                     case JPEG.SOF7:

   596                     case JPEG.JPG:

   597                     case JPEG.SOF9:

   598                     case JPEG.SOF10:

   599                     case JPEG.SOF11:

   600                     case JPEG.DAC:

   601                     case JPEG.SOF13:

   602                     case JPEG.SOF14:

   603                     case JPEG.SOF15:

   604                     case JPEG.SOS:

   605                     case JPEG.DQT:

   606                     case JPEG.DNL:

   607                     case JPEG.DRI:

   608                     case JPEG.DHP:

   609                     case JPEG.EXP:

   610                     case JPEG.APP0:

   611                     case JPEG.APP1:

   612                     case JPEG.APP2:

   613                     case JPEG.APP3:

   614                     case JPEG.APP4:

   615                     case JPEG.APP5:

   616                     case JPEG.APP6:

   617                     case JPEG.APP7:

   618                     case JPEG.APP8:

   619                     case JPEG.APP9:

   620                     case JPEG.APP10:

   621                     case JPEG.APP11:

   622                     case JPEG.APP12:

   623                     case JPEG.APP13:

   624                     case JPEG.APP14:

   625                     case JPEG.APP15:

   626                     case JPEG.COM:

   627                         // read length of header from next 2 bytes

   628                         int lengthHigherBits, lengthLowerBits, length;

   629                         lengthHigherBits = iis.read();

   630                         if (lengthHigherBits != (-1)) {

   631                             lengthLowerBits = iis.read();

   632                             if (lengthLowerBits != (-1)) {

   633                                 length = (lengthHigherBits << 8) |

   634                                         lengthLowerBits;

   635                                 // length contains already read 2 bytes

   636                                 length -= 2;

   637                             } else {

   638                                 throw new IndexOutOfBoundsException(IOOBE);

   639                             }

   640                         } else {

   641                             throw new IndexOutOfBoundsException(IOOBE);

   642                         }

   643                         // skip the length specified in marker

   644                         iis.skipBytes(length);

   645                         break;

   646                     case (-1):

   647                         throw new IndexOutOfBoundsException(IOOBE);

   648                     default:

   649                         throw new IOException("skipImage : Invalid marker "

   650                                 + "starting with ff "

   651                                 + Integer.toHexString(byteval));

   652                 }

   653             }

   654             foundFF = (byteval == 0xff);

   655         }

   656         throw new IndexOutOfBoundsException(IOOBE);

   657     }

   658 

   659     /**

   660      * Returns {@code true} if there is an image beyond

   661      * the current stream position.  Does not disturb the

   662      * stream position.

   663      */

   664     private boolean hasNextImage() throws IOException {

   665         if (debug) {

   666             System.out.print("hasNextImage called; returning ");

   667         }

   668         iis.mark();

   669         boolean foundFF = false;

   670         for (int byteval = iis.read();

   671              byteval != -1;

   672              byteval = iis.read()) {

   673 

   674             if (foundFF == true) {

   675                 if (byteval == JPEG.SOI) {

   676                     iis.reset();

   677                     if (debug) {

   678                         System.out.println("true");

   679                     }

   680                     return true;

   681                 }

   682             }

   683             foundFF = (byteval == 0xff) ? true : false;

   684         }

   685         // We hit the end of the stream before we hit an SOI, so no image

   686         iis.reset();

   687         if (debug) {

   688             System.out.println("false");

   689         }

   690         return false;

   691     }

   692 

   693     /**

   694      * Push back the given number of bytes to the input stream.

   695      * Called by the native code at the end of each image so

   696      * that the next one can be identified from Java.

   697      */

   698     private void pushBack(int num) throws IOException {

   699         if (debug) {

   700             System.out.println("pushing back " + num + " bytes");

   701         }

   702         cbLock.lock();

   703         try {

   704             iis.seek(iis.getStreamPosition()-num);

   705             // The buffer is clear after this, so no need to set haveSeeked.

   706         } finally {

   707             cbLock.unlock();

   708         }

   709     }

   710 

   711     /**

   712      * Reads header information for the given image, if possible.

   713      */

   714     private void readHeader(int imageIndex, boolean reset)

   715         throws IOException {

   716         gotoImage(imageIndex);

   717         readNativeHeader(reset); // Ignore return

   718         currentImage = imageIndex;

   719     }

   720 

   721     private boolean readNativeHeader(boolean reset) throws IOException {

   722         boolean retval = false;

   723         retval = readImageHeader(structPointer, haveSeeked, reset);

   724         haveSeeked = false;

   725         return retval;

   726     }

   727 

   728     /**

   729      * Read in the header information starting from the current

   730      * stream position, returning {@code true} if the

   731      * header was a tables-only image.  After this call, the

   732      * native IJG decompression struct will contain the image

   733      * information required by most query calls below

   734      * (e.g. getWidth, getHeight, etc.), if the header was not

   735      * a tables-only image.

   736      * If reset is {@code true}, the state of the IJG

   737      * object is reset so that it can read a header again.

   738      * This happens automatically if the header was a tables-only

   739      * image.

   740      */

   741     private native boolean readImageHeader(long structPointer,

   742                                            boolean clearBuffer,

   743                                            boolean reset)

   744         throws IOException;

   745 

   746     /*

   747      * Called by the native code whenever an image header has been

   748      * read.  Whether we read metadata or not, we always need this

   749      * information, so it is passed back independently of

   750      * metadata, which may never be read.

   751      */

   752     private void setImageData(int width,

   753                               int height,

   754                               int colorSpaceCode,

   755                               int outColorSpaceCode,

   756                               int numComponents,

   757                               byte [] iccData) {

   758         this.width = width;

   759         this.height = height;

   760         this.colorSpaceCode = colorSpaceCode;

   761         this.outColorSpaceCode = outColorSpaceCode;

   762         this.numComponents = numComponents;

   763 

   764         if (iccData == null) {

   765             iccCS = null;

   766             return;

   767         }

   768 

   769         ICC_Profile newProfile = null;

   770         try {

   771             newProfile = ICC_Profile.getInstance(iccData);

   772         } catch (IllegalArgumentException e) {

   773             /*

   774              * Color profile data seems to be invalid.

   775              * Ignore this profile.

   776              */

   777             iccCS = null;

   778             warningOccurred(WARNING_IGNORE_INVALID_ICC);

   779 

   780             return;

   781         }

   782         byte[] newData = newProfile.getData();

   783 

   784         ICC_Profile oldProfile = null;

   785         if (iccCS instanceof ICC_ColorSpace) {

   786             oldProfile = ((ICC_ColorSpace)iccCS).getProfile();

   787         }

   788         byte[] oldData = null;

   789         if (oldProfile != null) {

   790             oldData = oldProfile.getData();

   791         }

   792 

   793         /*

   794          * At the moment we can't rely on the ColorSpace.equals()

   795          * and ICC_Profile.equals() because they do not detect

   796          * the case when two profiles are created from same data.

   797          *

   798          * So, we have to do data comparison in order to avoid

   799          * creation of different ColorSpace instances for the same

   800          * embedded data.

   801          */

   802         if (oldData == null ||

   803             !java.util.Arrays.equals(oldData, newData))

   804         {

   805             iccCS = new ICC_ColorSpace(newProfile);

   806             // verify new color space

   807             try {

   808                 float[] colors = iccCS.fromRGB(new float[] {1f, 0f, 0f});

   809             } catch (CMMException e) {

   810                 /*

   811                  * Embedded profile seems to be corrupted.

   812                  * Ignore this profile.

   813                  */

   814                 iccCS = null;

   815                 cbLock.lock();

   816                 try {

   817                     warningOccurred(WARNING_IGNORE_INVALID_ICC);

   818                 } finally {

   819                     cbLock.unlock();

   820                 }

   821             }

   822         }

   823     }

   824 

   825     public int getWidth(int imageIndex) throws IOException {

   826         setThreadLock();

   827         try {

   828             if (currentImage != imageIndex) {

   829                 cbLock.check();

   830                 readHeader(imageIndex, true);

   831             }

   832             return width;

   833         } finally {

   834             clearThreadLock();

   835         }

   836     }

   837 

   838     public int getHeight(int imageIndex) throws IOException {

   839         setThreadLock();

   840         try {

   841             if (currentImage != imageIndex) {

   842                 cbLock.check();

   843                 readHeader(imageIndex, true);

   844             }

   845             return height;

   846         } finally {

   847             clearThreadLock();

   848         }

   849     }

   850 

   851     /////////// Color Conversion and Image Types

   852 

   853     /**

   854      * Return an ImageTypeSpecifier corresponding to the given

   855      * color space code, or null if the color space is unsupported.

   856      */

   857     private ImageTypeProducer getImageType(int code) {

   858         ImageTypeProducer ret = null;

   859 

   860         if ((code > 0) && (code < JPEG.NUM_JCS_CODES)) {

   861             ret = ImageTypeProducer.getTypeProducer(code);

   862         }

   863         return ret;

   864     }

   865 

   866     public ImageTypeSpecifier getRawImageType(int imageIndex)

   867         throws IOException {

   868         setThreadLock();

   869         try {

   870             if (currentImage != imageIndex) {

   871                 cbLock.check();

   872 

   873                 readHeader(imageIndex, true);

   874             }

   875 

   876             // Returns null if it can't be represented

   877             return getImageType(colorSpaceCode).getType();

   878         } finally {

   879             clearThreadLock();

   880         }

   881     }

   882 

   883     public Iterator<ImageTypeSpecifier> getImageTypes(int imageIndex)

   884         throws IOException {

   885         setThreadLock();

   886         try {

   887             return getImageTypesOnThread(imageIndex);

   888         } finally {

   889             clearThreadLock();

   890         }

   891     }

   892 

   893     private Iterator<ImageTypeSpecifier> getImageTypesOnThread(int imageIndex)

   894         throws IOException {

   895         if (currentImage != imageIndex) {

   896             cbLock.check();

   897             readHeader(imageIndex, true);

   898         }

   899 

   900         // We return an iterator containing the default, any

   901         // conversions that the library provides, and

   902         // all the other default types with the same number

   903         // of components, as we can do these as a post-process.

   904         // As we convert Rasters rather than images, images

   905         // with alpha cannot be converted in a post-process.

   906 

   907         // If this image can't be interpreted, this method

   908         // returns an empty Iterator.

   909 

   910         // Get the raw ITS, if there is one.  Note that this

   911         // won't always be the same as the default.

   912         ImageTypeProducer raw = getImageType(colorSpaceCode);

   913 

   914         // Given the encoded colorspace, build a list of ITS's

   915         // representing outputs you could handle starting

   916         // with the default.

   917 

   918         ArrayList<ImageTypeProducer> list = new ArrayList<ImageTypeProducer>(1);

   919 

   920         switch (colorSpaceCode) {

   921         case JPEG.JCS_GRAYSCALE:

   922             list.add(raw);

   923             list.add(getImageType(JPEG.JCS_RGB));

   924             break;

   925         case JPEG.JCS_RGB:

   926             list.add(raw);

   927             list.add(getImageType(JPEG.JCS_GRAYSCALE));

   928             list.add(getImageType(JPEG.JCS_YCC));

   929             break;

   930         case JPEG.JCS_RGBA:

   931             list.add(raw);

   932             break;

   933         case JPEG.JCS_YCC:

   934             if (raw != null) {  // Might be null if PYCC.pf not installed

   935                 list.add(raw);

   936                 list.add(getImageType(JPEG.JCS_RGB));

   937             }

   938             break;

   939         case JPEG.JCS_YCCA:

   940             if (raw != null) {  // Might be null if PYCC.pf not installed

   941                 list.add(raw);

   942             }

   943             break;

   944         case JPEG.JCS_YCbCr:

   945             // As there is no YCbCr ColorSpace, we can't support

   946             // the raw type.

   947 

   948             // due to 4705399, use RGB as default in order to avoid

   949             // slowing down of drawing operations with result image.

   950             list.add(getImageType(JPEG.JCS_RGB));

   951 

   952             if (iccCS != null) {

   953                 list.add(new ImageTypeProducer() {

   954                     protected ImageTypeSpecifier produce() {

   955                         return ImageTypeSpecifier.createInterleaved

   956                          (iccCS,

   957                           JPEG.bOffsRGB,  // Assume it's for RGB

   958                           DataBuffer.TYPE_BYTE,

   959                           false,

   960                           false);

   961                     }

   962                 });

   963 

   964             }

   965 

   966             list.add(getImageType(JPEG.JCS_GRAYSCALE));

   967             list.add(getImageType(JPEG.JCS_YCC));

   968             break;

   969         case JPEG.JCS_YCbCrA:  // Default is to convert to RGBA

   970             // As there is no YCbCr ColorSpace, we can't support

   971             // the raw type.

   972             list.add(getImageType(JPEG.JCS_RGBA));

   973             break;

   974         }

   975 

   976         return new ImageTypeIterator(list.iterator());

   977     }

   978 

   979     /**

   980      * Checks the implied color conversion between the stream and

   981      * the target image, altering the IJG output color space if necessary.

   982      * If a java color conversion is required, then this sets up

   983      * {@code convert}.

   984      * If bands are being rearranged at all (either source or destination

   985      * bands are specified in the param), then the default color

   986      * conversions are assumed to be correct.

   987      * Throws an IIOException if there is no conversion available.

   988      */

   989     private void checkColorConversion(BufferedImage image,

   990                                       ImageReadParam param)

   991         throws IIOException {

   992 

   993         // If we are rearranging channels at all, the default

   994         // conversions remain in place.  If the user wants

   995         // raw channels then he should do this while reading

   996         // a Raster.

   997         if (param != null) {

   998             if ((param.getSourceBands() != null) ||

   999                 (param.getDestinationBands() != null)) {

  1000                 // Accept default conversions out of decoder, silently

  1001                 return;

  1002             }

  1003         }

  1004 

  1005         // XXX - We do not currently support any indexed color models,

  1006         // though we could, as IJG will quantize for us.

  1007         // This is a performance and memory-use issue, as

  1008         // users can read RGB and then convert to indexed in Java.

  1009 

  1010         ColorModel cm = image.getColorModel();

  1011 

  1012         if (cm instanceof IndexColorModel) {

  1013             throw new IIOException("IndexColorModel not supported");

  1014         }

  1015 

  1016         // Now check the ColorSpace type against outColorSpaceCode

  1017         // We may want to tweak the default

  1018         ColorSpace cs = cm.getColorSpace();

  1019         int csType = cs.getType();

  1020         convert = null;

  1021         switch (outColorSpaceCode) {

  1022         case JPEG.JCS_GRAYSCALE:  // Its gray in the file

  1023             if  (csType == ColorSpace.TYPE_RGB) { // We want RGB

  1024                 // IJG can do this for us more efficiently

  1025                 setOutColorSpace(structPointer, JPEG.JCS_RGB);

  1026                 // Update java state according to changes

  1027                 // in the native part of decoder.

  1028                 outColorSpaceCode = JPEG.JCS_RGB;

  1029                 numComponents = 3;

  1030             } else if (csType != ColorSpace.TYPE_GRAY) {

  1031                 throw new IIOException("Incompatible color conversion");

  1032             }

  1033             break;

  1034         case JPEG.JCS_RGB:  // IJG wants to go to RGB

  1035             if (csType ==  ColorSpace.TYPE_GRAY) {  // We want gray

  1036                 if (colorSpaceCode == JPEG.JCS_YCbCr) {

  1037                     // If the jpeg space is YCbCr, IJG can do it

  1038                     setOutColorSpace(structPointer, JPEG.JCS_GRAYSCALE);

  1039                     // Update java state according to changes

  1040                     // in the native part of decoder.

  1041                     outColorSpaceCode = JPEG.JCS_GRAYSCALE;

  1042                     numComponents = 1;

  1043                 }

  1044             } else if ((iccCS != null) &&

  1045                        (cm.getNumComponents() == numComponents) &&

  1046                        (cs != iccCS)) {

  1047                 // We have an ICC profile but it isn't used in the dest

  1048                 // image.  So convert from the profile cs to the target cs

  1049                 convert = new ColorConvertOp(iccCS, cs, null);

  1050                 // Leave IJG conversion in place; we still need it

  1051             } else if ((iccCS == null) &&

  1052                        (!cs.isCS_sRGB()) &&

  1053                        (cm.getNumComponents() == numComponents)) {

  1054                 // Target isn't sRGB, so convert from sRGB to the target

  1055                 convert = new ColorConvertOp(JPEG.JCS.sRGB, cs, null);

  1056             } else if (csType != ColorSpace.TYPE_RGB) {

  1057                 throw new IIOException("Incompatible color conversion");

  1058             }

  1059             break;

  1060         case JPEG.JCS_RGBA:

  1061             // No conversions available; image must be RGBA

  1062             if ((csType != ColorSpace.TYPE_RGB) ||

  1063                 (cm.getNumComponents() != numComponents)) {

  1064                 throw new IIOException("Incompatible color conversion");

  1065             }

  1066             break;

  1067         case JPEG.JCS_YCC:

  1068             {

  1069                 ColorSpace YCC = JPEG.JCS.getYCC();

  1070                 if (YCC == null) { // We can't do YCC at all

  1071                     throw new IIOException("Incompatible color conversion");

  1072                 }

  1073                 if ((cs != YCC) &&

  1074                     (cm.getNumComponents() == numComponents)) {

  1075                     convert = new ColorConvertOp(YCC, cs, null);

  1076                 }

  1077             }

  1078             break;

  1079         case JPEG.JCS_YCCA:

  1080             {

  1081                 ColorSpace YCC = JPEG.JCS.getYCC();

  1082                 // No conversions available; image must be YCCA

  1083                 if ((YCC == null) || // We can't do YCC at all

  1084                     (cs != YCC) ||

  1085                     (cm.getNumComponents() != numComponents)) {

  1086                     throw new IIOException("Incompatible color conversion");

  1087                 }

  1088             }

  1089             break;

  1090         default:

  1091             // Anything else we can't handle at all

  1092             throw new IIOException("Incompatible color conversion");

  1093         }

  1094     }

  1095 

  1096     /**

  1097      * Set the IJG output space to the given value.  The library will

  1098      * perform the appropriate colorspace conversions.

  1099      */

  1100     private native void setOutColorSpace(long structPointer, int id);

  1101 

  1102     /////// End of Color Conversion & Image Types

  1103 

  1104     public ImageReadParam getDefaultReadParam() {

  1105         return new JPEGImageReadParam();

  1106     }

  1107 

  1108     public IIOMetadata getStreamMetadata() throws IOException {

  1109         setThreadLock();

  1110         try {

  1111             if (!tablesOnlyChecked) {

  1112                 cbLock.check();

  1113                 checkTablesOnly();

  1114             }

  1115             return streamMetadata;

  1116         } finally {

  1117             clearThreadLock();

  1118         }

  1119     }

  1120 

  1121     public IIOMetadata getImageMetadata(int imageIndex)

  1122         throws IOException {

  1123         setThreadLock();

  1124         try {

  1125             // imageMetadataIndex will always be either a valid index or

  1126             // -1, in which case imageMetadata will not be null.

  1127             // So we can leave checking imageIndex for gotoImage.

  1128             if ((imageMetadataIndex == imageIndex)

  1129                 && (imageMetadata != null)) {

  1130                 return imageMetadata;

  1131             }

  1132 

  1133             cbLock.check();

  1134