import com.sun.media.jai.codec.SeekableStream; //导入依赖的package包/类
public static void main(String args[]) throws IOException, ImageProcessingException {
	String tiffstr = utilities.BrowserDialogs.chooseFile();
	InputStream is = new BufferedInputStream(new FileInputStream(tiffstr));
	SeekableStream seekstr = new FileCacheSeekableStream(is);
	TIFFDirectory tiffdir = new TIFFDirectory(seekstr, 0);
	for (int i = 0; i < tiffdir.getNumEntries(); i++) {
		// System.out.println(i);
		// System.out.println(tiffdir.getField(i));
	}

	boolean cSB = seekstr.canSeekBackwards();
	// System.out.println(cSB);
	File tifffile = new File(tiffstr);
	getImageTiffMetadata(tifffile);

	getExifTiffData(tifffile);
}
 

import com.sun.media.jai.codec.SeekableStream; //导入依赖的package包/类
public static BufferedImage read(File file) throws IOException {
	BufferedImage bufferedImage = null;

	try {
		// We try it with ImageIO
		bufferedImage = ImageIO.read(ImageIO
				.createImageInputStream(new FileInputStream(file)));
	} catch (CMMException ex) {
		ex.getCause();
	}

	if (bufferedImage == null) {
		RenderedOp renderedOp = JAI.create("stream", SeekableStream
				.wrapInputStream(new FileInputStream(file), true));

		if (renderedOp != null) {
			bufferedImage = renderedOp.getAsBufferedImage();
		}
	}

	return bufferedImage;
}
 

import com.sun.media.jai.codec.SeekableStream; //导入依赖的package包/类
/**
 * This method takes in an image as a byte array (currently supports GIF, JPG, PNG and
 * possibly other formats) and
 * resizes it to have a width no greater than the pMaxWidth parameter in pixels.
 * It converts the image to a standard
 * quality JPG and returns the byte array of that JPG image.
 *
 * @param pImageData
 *                the image data.
 * @param pMaxWidth
 *                the max width in pixels, 0 means do not scale.
 * @return the resized JPG image.
 * @throws IOException
 *                 if the image could not be manipulated correctly.
 */
public byte[] resizeImageAsJPG(byte[] pImageData, int pMaxWidth) throws IOException {
    InputStream imageInputStream = new ByteArrayInputStream(pImageData);
    // read in the original image from an input stream
    SeekableStream seekableImageStream = SeekableStream.wrapInputStream(imageInputStream, true);
    RenderedOp originalImage = JAI.create(JAI_STREAM_ACTION, seekableImageStream);
    ((OpImage) originalImage.getRendering()).setTileCache(null);
    int origImageWidth = originalImage.getWidth();
    // now resize the image
    double scale = 1.0;
    if (pMaxWidth > 0 && origImageWidth > pMaxWidth) {
        scale = (double) pMaxWidth / originalImage.getWidth();
    }
    ParameterBlock paramBlock = new ParameterBlock();
    paramBlock.addSource(originalImage); // The source image
    paramBlock.add(scale); // The xScale
    paramBlock.add(scale); // The yScale
    paramBlock.add(0.0); // The x translation
    paramBlock.add(0.0); // The y translation

    RenderingHints qualityHints = new RenderingHints(RenderingHints.KEY_RENDERING,
            RenderingHints.VALUE_RENDER_QUALITY);

    RenderedOp resizedImage = JAI.create(JAI_SUBSAMPLE_AVERAGE_ACTION, paramBlock, qualityHints);

    // lastly, write the newly-resized image to an output stream, in a specific encoding
    ByteArrayOutputStream encoderOutputStream = new ByteArrayOutputStream();
    JAI.create(JAI_ENCODE_ACTION, resizedImage, encoderOutputStream, JAI_ENCODE_FORMAT_JPEG, null);
    // Export to Byte Array
    byte[] resizedImageByteArray = encoderOutputStream.toByteArray();
    return resizedImageByteArray;
}
 

import com.sun.media.jai.codec.SeekableStream; //导入依赖的package包/类
/**
 * The <code>getSelectedTiffFile</code> method is used to limit the file
 * to the page limit given.
 * 
 * @param tiffFile {@link File} tiff file from which limit has to be applied
 * @param pageLimit int
 * @throws IOException if file is not found
 */
public static void getSelectedTiffFile(final File tiffFile, final int pageLimit) throws IOException {
	OutputStream out = null;
	File newTiffFile = null;
	if (null != tiffFile && getTIFFPageCount(tiffFile.getAbsolutePath()) > pageLimit) {
		try {
			final List<BufferedImage> imageList = new ArrayList<BufferedImage>();
			final SeekableStream seekableStream = new FileSeekableStream(tiffFile);
			final ImageDecoder decoder = ImageCodec.createImageDecoder("tiff", seekableStream, null);
			for (int i = 1; i < pageLimit; i++) {
				final PlanarImage planarImage = new NullOpImage(decoder.decodeAsRenderedImage(i), null, null, OpImage.OP_IO_BOUND);
				imageList.add(planarImage.getAsBufferedImage());
			}
			seekableStream.close();
			final TIFFEncodeParam params = new TIFFEncodeParam();
			params.setCompression(TIFFEncodeParam.COMPRESSION_GROUP4);
			String name = tiffFile.getName();
			final int indexOf = name.lastIndexOf(IUtilCommonConstants.DOT);
			name = name.substring(0, indexOf);
			final String finalPath = tiffFile.getParent() + File.separator + name
					+ System.currentTimeMillis() + IUtilCommonConstants.EXTENSION_TIF;
			newTiffFile = new File(finalPath);
			out = new FileOutputStream(finalPath); 
			final ImageEncoder encoder = ImageCodec.createImageEncoder("tiff", out, params);
            params.setExtraImages(imageList.iterator()); 
            encoder.encode(imageList.get(0));
		} finally {
			if (null != out) {
				out.flush();
				out.close();
			}
		}
           if (tiffFile.delete() && null != newTiffFile) {
           	newTiffFile.renameTo(tiffFile);
		} else {
			if (null != newTiffFile) {
				newTiffFile.delete();
			}
		}
	}
}
 

import com.sun.media.jai.codec.SeekableStream; //导入依赖的package包/类
public static RenderedImage loadImageFromBytes(byte[] bytes) throws IOException {
	SeekableStream ss = new ByteArraySeekableStream(bytes);
	RenderedImage image = JAI.create("stream", ss);

	return image;
}
 

import com.sun.media.jai.codec.SeekableStream; //导入依赖的package包/类
PlanarImage loadImage(URL imageURL) throws IOException {
  SeekableStream stream = new MemoryCacheSeekableStream(imageURL.openStream());
  return JAI.create("stream", stream);
}