<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2 Final//EN">
<html>
<head>
<!--
Copyright 2000 Sun Microsystems, Inc.  All Rights Reserved.
DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

This code is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License version 2 only, as
published by the Free Software Foundation.  Sun designates this
particular file as subject to the "Classpath" exception as provided
by Sun in the LICENSE file that accompanied this code.

This code is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
version 2 for more details (a copy is included in the LICENSE file that
accompanied this code).

You should have received a copy of the GNU General Public License version
2 along with this work; if not, write to the Free Software Foundation,
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
CA 95054 USA or visit www.sun.com if you need additional information or
have any questions.
-->

</head>

<body bgcolor="white">

A package of the Java Image I/O API dealing with low-level I/O from
files and streams.

<p>

The <code>ImageInputStream</code> interface unifies streaming and
file-based operations.  An abstract base class,
<code>ImageInputStreamImpl</code> is provided to simplify writing
a new <code>ImageInputStream</code> class.  Concrete implementation
classes (<code>FileImageInputStream</code>,
<code>FileCacheImageInputStream</code>, and
<code>MemoryCacheImageInputStream</code>) are provided that allow
input to come from a <code>File</code> or <code>InputStream</code>
with or without the use of a temporary cache file.

<p>

The <code>ImageOutputStream</code> interface performs an analogous
function for output.  An abstract base class,
<code>ImageOutputStreamImpl</code> is provided, along with
concrete implementation classes (<code>FileImageOutputStream</code>,
<code>FileCacheImageOutputStream</code>, and
<code>MemoryCacheImageOutputStream</code>) are provided that allow
output to go to a <code>File</code> or <code>OutputStream</code> with
or without the use of a temporary cache file.

<p>

The <code>IIOByteBuffer</code> class provides an alternative way to
perform reads of sequences of bytes that reduces the amount of
internal data copying.

@since 1.4
</body>
</html>
