auto import from //depot/cupcake/@135843
diff --git a/awt/javax/imageio/stream/FileCacheImageInputStream.java b/awt/javax/imageio/stream/FileCacheImageInputStream.java
new file mode 100644
index 0000000..710ac66
--- /dev/null
+++ b/awt/javax/imageio/stream/FileCacheImageInputStream.java
@@ -0,0 +1,137 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package javax.imageio.stream;
+
+import java.io.*;
+
+/**
+ * The FileCacheImageInputStream class is an implementation of ImageInputStream
+ * which reads from its InputStream and uses a temporary file as a cache.
+ *
+ * @since Android 1.0
+ */
+public class FileCacheImageInputStream extends ImageInputStreamImpl {
+
+ /**
+ * The is.
+ */
+ private InputStream is;
+
+ /**
+ * The file.
+ */
+ private File file;
+
+ /**
+ * The raf.
+ */
+ private RandomAccessFile raf;
+
+ /**
+ * Instantiates a new FileCacheImageInputStream from the specified
+ * InputStream and using the specified File as its cache directory.
+ *
+ * @param stream
+ * the InputStream for reading.
+ * @param cacheDir
+ * the cache directory where the cache file will be created.
+ * @throws IOException
+ * if an I/O exception has occurred.
+ */
+ public FileCacheImageInputStream(InputStream stream, File cacheDir) throws IOException {
+ if (stream == null) {
+ throw new IllegalArgumentException("stream == null!");
+ }
+ is = stream;
+
+ if (cacheDir == null || cacheDir.isDirectory()) {
+ file = File.createTempFile(FileCacheImageOutputStream.IIO_TEMP_FILE_PREFIX, null,
+ cacheDir);
+ file.deleteOnExit();
+ } else {
+ throw new IllegalArgumentException("Not a directory!");
+ }
+
+ raf = new RandomAccessFile(file, "rw");
+ }
+
+ @Override
+ public int read() throws IOException {
+ bitOffset = 0;
+
+ if (streamPos >= raf.length()) {
+ int b = is.read();
+
+ if (b < 0) {
+ return -1;
+ }
+
+ raf.seek(streamPos++);
+ raf.write(b);
+ return b;
+ }
+
+ raf.seek(streamPos++);
+ return raf.read();
+ }
+
+ @Override
+ public int read(byte[] b, int off, int len) throws IOException {
+ bitOffset = 0;
+
+ if (streamPos >= raf.length()) {
+ int nBytes = is.read(b, off, len);
+
+ if (nBytes < 0) {
+ return -1;
+ }
+
+ raf.seek(streamPos);
+ raf.write(b, off, nBytes);
+ streamPos += nBytes;
+ return nBytes;
+ }
+
+ raf.seek(streamPos);
+ int nBytes = raf.read(b, off, len);
+ streamPos += nBytes;
+ return nBytes;
+ }
+
+ @Override
+ public boolean isCached() {
+ return true;
+ }
+
+ @Override
+ public boolean isCachedFile() {
+ return true;
+ }
+
+ @Override
+ public boolean isCachedMemory() {
+ return false;
+ }
+
+ @Override
+ public void close() throws IOException {
+ super.close();
+ raf.close();
+ file.delete();
+ }
+}
diff --git a/awt/javax/imageio/stream/FileCacheImageOutputStream.java b/awt/javax/imageio/stream/FileCacheImageOutputStream.java
new file mode 100644
index 0000000..135afab
--- /dev/null
+++ b/awt/javax/imageio/stream/FileCacheImageOutputStream.java
@@ -0,0 +1,196 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package javax.imageio.stream;
+
+import java.io.IOException;
+import java.io.File;
+import java.io.OutputStream;
+import java.io.RandomAccessFile;
+
+/**
+ * The FileCacheImageOutputStream class is an implementation of
+ * ImageOutputStream that writes to its OutputStream using a temporary file as a
+ * cache.
+ *
+ * @since Android 1.0
+ */
+public class FileCacheImageOutputStream extends ImageOutputStreamImpl {
+
+ /**
+ * The Constant IIO_TEMP_FILE_PREFIX.
+ */
+ static final String IIO_TEMP_FILE_PREFIX = "iioCache";
+
+ /**
+ * The Constant MAX_BUFFER_LEN.
+ */
+ static final int MAX_BUFFER_LEN = 1048575; // 1 MB - is it not too much?
+
+ /**
+ * The os.
+ */
+ private OutputStream os;
+
+ /**
+ * The file.
+ */
+ private File file;
+
+ /**
+ * The raf.
+ */
+ private RandomAccessFile raf;
+
+ /**
+ * Instantiates a FileCacheImageOutputStream.
+ *
+ * @param stream
+ * the OutputStream for writing.
+ * @param cacheDir
+ * the cache directory where the cache file will be created.
+ * @throws IOException
+ * if an I/O exception has occurred.
+ */
+ public FileCacheImageOutputStream(OutputStream stream, File cacheDir) throws IOException {
+ if (stream == null) {
+ throw new IllegalArgumentException("stream == null!");
+ }
+ os = stream;
+
+ if (cacheDir == null || cacheDir.isDirectory()) {
+ file = File.createTempFile(IIO_TEMP_FILE_PREFIX, null, cacheDir);
+ file.deleteOnExit();
+ } else {
+ throw new IllegalArgumentException("Not a directory!");
+ }
+
+ raf = new RandomAccessFile(file, "rw");
+ }
+
+ @Override
+ public void close() throws IOException {
+ flushBefore(raf.length());
+ super.close();
+ raf.close();
+ file.delete();
+ }
+
+ @Override
+ public boolean isCached() {
+ return true;
+ }
+
+ @Override
+ public boolean isCachedFile() {
+ return true;
+ }
+
+ @Override
+ public boolean isCachedMemory() {
+ return false;
+ }
+
+ @Override
+ public void write(int b) throws IOException {
+ flushBits(); // See the flushBits method description
+
+ raf.write(b);
+ streamPos++;
+ }
+
+ @Override
+ public void write(byte[] b, int off, int len) throws IOException {
+ flushBits(); // See the flushBits method description
+
+ raf.write(b, off, len);
+ streamPos += len;
+ }
+
+ @Override
+ public int read() throws IOException {
+ bitOffset = 0; // Should reset
+
+ int res = raf.read();
+ if (res >= 0) {
+ streamPos++;
+ }
+
+ return res;
+ }
+
+ @Override
+ public int read(byte[] b, int off, int len) throws IOException {
+ bitOffset = 0;
+
+ int numRead = raf.read(b, off, len);
+ if (numRead > 0) {
+ streamPos += numRead;
+ }
+
+ return numRead;
+ }
+
+ @Override
+ public void flushBefore(long pos) throws IOException {
+ long readFromPos = flushedPos;
+ super.flushBefore(pos);
+
+ long bytesToRead = pos - readFromPos;
+ raf.seek(readFromPos);
+
+ if (bytesToRead < MAX_BUFFER_LEN) {
+ byte buffer[] = new byte[(int)bytesToRead];
+ raf.readFully(buffer);
+ os.write(buffer);
+ } else {
+ byte buffer[] = new byte[MAX_BUFFER_LEN];
+ while (bytesToRead > 0) {
+ int count = (int)Math.min(MAX_BUFFER_LEN, bytesToRead);
+ raf.readFully(buffer, 0, count);
+ os.write(buffer, 0, count);
+ bytesToRead -= count;
+ }
+ }
+
+ os.flush();
+
+ if (pos != streamPos) {
+ raf.seek(streamPos); // Reset the position
+ }
+ }
+
+ @Override
+ public void seek(long pos) throws IOException {
+ if (pos < flushedPos) {
+ throw new IndexOutOfBoundsException();
+ }
+
+ raf.seek(pos);
+ streamPos = raf.getFilePointer();
+ bitOffset = 0;
+ }
+
+ @Override
+ public long length() {
+ try {
+ return raf.length();
+ } catch (IOException e) {
+ return -1L;
+ }
+ }
+}
diff --git a/awt/javax/imageio/stream/FileImageInputStream.java b/awt/javax/imageio/stream/FileImageInputStream.java
new file mode 100644
index 0000000..b9b6002
--- /dev/null
+++ b/awt/javax/imageio/stream/FileImageInputStream.java
@@ -0,0 +1,122 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package javax.imageio.stream;
+
+import java.io.IOException;
+import java.io.RandomAccessFile;
+import java.io.File;
+import java.io.FileNotFoundException;
+
+/**
+ * The FileImageInputStream class implements ImageInputStream and obtains its
+ * input data from a File or RandomAccessFile.
+ *
+ * @since Android 1.0
+ */
+public class FileImageInputStream extends ImageInputStreamImpl {
+
+ /**
+ * The raf.
+ */
+ RandomAccessFile raf;
+
+ /**
+ * Instantiates a new FileImageInputStream from the specified File.
+ *
+ * @param f
+ * the File of input data.
+ * @throws FileNotFoundException
+ * if the specified file doesn't exist.
+ * @throws IOException
+ * if an I/O exception has occurred.
+ */
+ @SuppressWarnings( {
+ "DuplicateThrows"
+ })
+ public FileImageInputStream(File f) throws FileNotFoundException, IOException {
+ if (f == null) {
+ throw new IllegalArgumentException("f == null!");
+ }
+
+ raf = new RandomAccessFile(f, "r");
+ }
+
+ /**
+ * Instantiates a new FileImageInputStream from the specified
+ * RandomAccessFile.
+ *
+ * @param raf
+ * the RandomAccessFile of input data.
+ */
+ public FileImageInputStream(RandomAccessFile raf) {
+ if (raf == null) {
+ throw new IllegalArgumentException("raf == null!");
+ }
+
+ this.raf = raf;
+ }
+
+ @Override
+ public int read() throws IOException {
+ bitOffset = 0;
+
+ int res = raf.read();
+ if (res != -1) {
+ streamPos++;
+ }
+ return res;
+ }
+
+ @Override
+ public int read(byte[] b, int off, int len) throws IOException {
+ bitOffset = 0;
+
+ int numRead = raf.read(b, off, len);
+ if (numRead >= 0) {
+ streamPos += numRead;
+ }
+
+ return numRead;
+ }
+
+ @Override
+ public long length() {
+ try {
+ return raf.length();
+ } catch (IOException e) {
+ return -1L;
+ }
+ }
+
+ @Override
+ public void seek(long pos) throws IOException {
+ if (pos < getFlushedPosition()) {
+ throw new IndexOutOfBoundsException();
+ }
+
+ raf.seek(pos);
+ streamPos = raf.getFilePointer();
+ bitOffset = 0;
+ }
+
+ @Override
+ public void close() throws IOException {
+ super.close();
+ raf.close();
+ }
+}
diff --git a/awt/javax/imageio/stream/FileImageOutputStream.java b/awt/javax/imageio/stream/FileImageOutputStream.java
new file mode 100644
index 0000000..2730ba6
--- /dev/null
+++ b/awt/javax/imageio/stream/FileImageOutputStream.java
@@ -0,0 +1,128 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * @author Rustem V. Rafikov
+ * @version $Revision: 1.3 $
+ */
+
+package javax.imageio.stream;
+
+import java.io.*;
+
+/**
+ * The FileImageOutputStream class implements ImageOutputStream and writes the
+ * output data to a File or RandomAccessFile.
+ *
+ * @since Android 1.0
+ */
+public class FileImageOutputStream extends ImageOutputStreamImpl {
+
+ /**
+ * The file.
+ */
+ RandomAccessFile file;
+
+ /**
+ * Instantiates a new FileImageOutputStream with the specified File.
+ *
+ * @param f
+ * the output File.
+ * @throws FileNotFoundException
+ * if the file not found.
+ * @throws IOException
+ * if an I/O exception has occurred.
+ */
+ public FileImageOutputStream(File f) throws FileNotFoundException, IOException {
+ this(f != null ? new RandomAccessFile(f, "rw") : null);
+ }
+
+ /**
+ * Instantiates a new FileImageOutputStream with the specified
+ * RandomAccessFile.
+ *
+ * @param raf
+ * the output RandomAccessFile.
+ */
+ public FileImageOutputStream(RandomAccessFile raf) {
+ if (raf == null) {
+ throw new IllegalArgumentException("file should not be NULL");
+ }
+ file = raf;
+ }
+
+ @Override
+ public void write(int b) throws IOException {
+ checkClosed();
+ // according to the spec for ImageOutputStreamImpl#flushBits()
+ flushBits();
+ file.write(b);
+ streamPos++;
+ }
+
+ @Override
+ public void write(byte[] b, int off, int len) throws IOException {
+ checkClosed();
+ // according to the spec for ImageOutputStreamImpl#flushBits()
+ flushBits();
+ file.write(b, off, len);
+ streamPos += len;
+ }
+
+ @Override
+ public int read() throws IOException {
+ checkClosed();
+ int rt = file.read();
+ if (rt != -1) {
+ streamPos++;
+ }
+ return rt;
+ }
+
+ @Override
+ public int read(byte[] b, int off, int len) throws IOException {
+ checkClosed();
+ int rt = file.read(b, off, len);
+ if (rt != -1) {
+ streamPos += rt;
+ }
+ return rt;
+ }
+
+ @Override
+ public long length() {
+ try {
+ checkClosed();
+ return file.length();
+ } catch (IOException e) {
+ return super.length(); // -1L
+ }
+ }
+
+ @Override
+ public void seek(long pos) throws IOException {
+ // -- checkClosed() is performed in super.seek()
+ super.seek(pos);
+ file.seek(pos);
+ streamPos = file.getFilePointer();
+ }
+
+ @Override
+ public void close() throws IOException {
+ super.close();
+ file.close();
+ }
+}
diff --git a/awt/javax/imageio/stream/IIOByteBuffer.java b/awt/javax/imageio/stream/IIOByteBuffer.java
new file mode 100644
index 0000000..867d808
--- /dev/null
+++ b/awt/javax/imageio/stream/IIOByteBuffer.java
@@ -0,0 +1,124 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * @author Sergey I. Salishev
+ * @version $Revision: 1.2 $
+ */
+
+package javax.imageio.stream;
+
+//
+// @author Sergey I. Salishev
+// @version $Revision: 1.2 $
+//
+
+/**
+ * The IIOByteBuffer class represents a byte array with offset and length that
+ * is used by ImageInputStream for obtaining a sequence of bytes.
+ *
+ * @since Android 1.0
+ */
+public class IIOByteBuffer {
+
+ /**
+ * The data.
+ */
+ private byte[] data;
+
+ /**
+ * The offset.
+ */
+ private int offset;
+
+ /**
+ * The length.
+ */
+ private int length;
+
+ /**
+ * Instantiates a new IIOByteBuffer.
+ *
+ * @param data
+ * the byte array.
+ * @param offset
+ * the offset in the array.
+ * @param length
+ * the length of array.
+ */
+ public IIOByteBuffer(byte[] data, int offset, int length) {
+ this.data = data;
+ this.offset = offset;
+ this.length = length;
+ }
+
+ /**
+ * Gets the byte array of this IIOByteBuffer.
+ *
+ * @return the byte array.
+ */
+ public byte[] getData() {
+ return data;
+ }
+
+ /**
+ * Gets the length in the array which will be used.
+ *
+ * @return the length of the data.
+ */
+ public int getLength() {
+ return length;
+ }
+
+ /**
+ * Gets the offset of this IIOByteBuffer.
+ *
+ * @return the offset of this IIOByteBuffer.
+ */
+ public int getOffset() {
+ return offset;
+ }
+
+ /**
+ * Sets the new data array to this IIOByteBuffer object.
+ *
+ * @param data
+ * the new data array.
+ */
+ public void setData(byte[] data) {
+ this.data = data;
+ }
+
+ /**
+ * Sets the length of data which will be used.
+ *
+ * @param length
+ * the new length.
+ */
+ public void setLength(int length) {
+ this.length = length;
+ }
+
+ /**
+ * Sets the offset in the data array of this IIOByteBuffer.
+ *
+ * @param offset
+ * the new offset.
+ */
+ public void setOffset(int offset) {
+ this.offset = offset;
+ }
+}
diff --git a/awt/javax/imageio/stream/ImageInputStream.java b/awt/javax/imageio/stream/ImageInputStream.java
new file mode 100644
index 0000000..3dec5d2
--- /dev/null
+++ b/awt/javax/imageio/stream/ImageInputStream.java
@@ -0,0 +1,502 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * @author Rustem V. Rafikov
+ * @version $Revision: 1.2 $
+ */
+
+package javax.imageio.stream;
+
+import java.io.DataInput;
+import java.io.IOException;
+import java.nio.ByteOrder;
+
+/**
+ * The ImageInputStream represents input stream interface that is used by
+ * ImageReaders.
+ *
+ * @since Android 1.0
+ */
+public interface ImageInputStream extends DataInput {
+
+ /**
+ * Sets the specified byte order for reading of data values from this
+ * stream.
+ *
+ * @param byteOrder
+ * the byte order.
+ */
+ void setByteOrder(ByteOrder byteOrder);
+
+ /**
+ * Gets the byte order.
+ *
+ * @return the byte order.
+ */
+ ByteOrder getByteOrder();
+
+ /**
+ * Reads a byte from the stream.
+ *
+ * @return the byte of the stream, or -1 for EOF indicating.
+ * @throws IOException
+ * if an I/O exception has occurred.
+ */
+ int read() throws IOException;
+
+ /**
+ * Reads number of bytes which is equal to the specified array's length and
+ * stores a result to this array.
+ *
+ * @param b
+ * the byte array.
+ * @return the number of read bytes, or -1 indicated EOF.
+ * @throws IOException
+ * if an I/O exception has occurred.
+ */
+ int read(byte[] b) throws IOException;
+
+ /**
+ * Reads the number of bytes specified by len parameter from the stream and
+ * stores a result to the specified array with the specified offset.
+ *
+ * @param b
+ * the byte array.
+ * @param off
+ * the offset.
+ * @param len
+ * the number of bytes to be read.
+ * @return the number of read bytes, or -1 indicated EOF.
+ * @throws IOException
+ * if an I/O exception has occurred.
+ */
+ int read(byte[] b, int off, int len) throws IOException;
+
+ /**
+ * Reads the number of bytes specified by len parameter from the stream, and
+ * modifies the specified IIOByteBuffer with the byte array, offset, and
+ * length.
+ *
+ * @param buf
+ * the IIOByteBuffer.
+ * @param len
+ * the number of bytes to be read.
+ * @throws IOException
+ * if an I/O exception has occurred.
+ */
+ void readBytes(IIOByteBuffer buf, int len) throws IOException;
+
+ /**
+ * Reads a byte from the stream and returns a boolean true value if it is
+ * non zero, false if it is zero.
+ *
+ * @return the boolean value for read byte.
+ * @throws IOException
+ * if an I/O exception has occurred.
+ */
+ boolean readBoolean() throws IOException;
+
+ /**
+ * Reads a byte from the stream and returns its value as signed byte.
+ *
+ * @return the signed byte value for read byte.
+ * @throws IOException
+ * if an I/O exception has occurred.
+ */
+ byte readByte() throws IOException;
+
+ /**
+ * Reads a byte from the stream and returns its value as an integer.
+ *
+ * @return the unsigned byte value for read byte as an integer.
+ * @throws IOException
+ * if an I/O exception has occurred.
+ */
+ int readUnsignedByte() throws IOException;
+
+ /**
+ * Reads 2 bytes from the stream, and returns the result as a short.
+ *
+ * @return the signed short value from the stream.
+ * @throws IOException
+ * if an I/O exception has occurred.
+ */
+ short readShort() throws IOException;
+
+ /**
+ * Reads 2 bytes from the stream and returns its value as an unsigned short.
+ *
+ * @return a unsigned short value coded in an integer.
+ * @throws IOException
+ * if an I/O exception has occurred.
+ */
+ int readUnsignedShort() throws IOException;
+
+ /**
+ * Reads 2 bytes from the stream and returns their unsigned char value.
+ *
+ * @return the unsigned char value.
+ * @throws IOException
+ * if an I/O exception has occurred.
+ */
+ char readChar() throws IOException;
+
+ /**
+ * Reads 4 bytes from the stream, and returns the result as an integer.
+ *
+ * @return the signed integer value from the stream.
+ * @throws IOException
+ * if an I/O exception has occurred.
+ */
+ int readInt() throws IOException;
+
+ /**
+ * Reads 4 bytes from the stream and returns its value as long.
+ *
+ * @return the unsigned integer value as long.
+ * @throws IOException
+ * if an I/O exception has occurred.
+ */
+ long readUnsignedInt() throws IOException;
+
+ /**
+ * Reads 8 bytes from the stream, and returns the result as a long.
+ *
+ * @return the long value from the stream.
+ * @throws IOException
+ * if an I/O exception has occurred.
+ */
+ long readLong() throws IOException;
+
+ /**
+ * Reads 4 bytes from the stream, and returns the result as a float.
+ *
+ * @return the float value from the stream.
+ * @throws IOException
+ * if an I/O exception has occurred.
+ */
+ float readFloat() throws IOException;
+
+ /**
+ * Reads 8 bytes from the stream, and returns the result as a double.
+ *
+ * @return the double value from the stream.
+ * @throws IOException
+ * if an I/O exception has occurred.
+ */
+ double readDouble() throws IOException;
+
+ /**
+ * Reads a line from the stream.
+ *
+ * @return the string contained the line from the stream.
+ * @throws IOException
+ * if an I/O exception has occurred.
+ */
+ String readLine() throws IOException;
+
+ /**
+ * Reads bytes from the stream in a string that has been encoded in a
+ * modified UTF-8 format.
+ *
+ * @return the string read from stream and modified UTF-8 format.
+ * @throws IOException
+ * if an I/O exception has occurred.
+ */
+ String readUTF() throws IOException;
+
+ /**
+ * Reads the specified number of bytes from the stream, and stores the
+ * result into the specified array starting at the specified index offset.
+ *
+ * @param b
+ * the byte array.
+ * @param off
+ * the offset.
+ * @param len
+ * the number of bytes to be read.
+ * @throws IOException
+ * if an I/O exception has occurred.
+ */
+ void readFully(byte[] b, int off, int len) throws IOException;
+
+ /**
+ * Reads number of bytes from the stream which is equal to the specified
+ * array's length, and stores them into this array.
+ *
+ * @param b
+ * the byte array.
+ * @throws IOException
+ * if an I/O exception has occurred.
+ */
+ void readFully(byte[] b) throws IOException;
+
+ /**
+ * Reads the specified number of shorts from the stream, and stores the
+ * result into the specified array starting at the specified index offset.
+ *
+ * @param s
+ * the short array.
+ * @param off
+ * the offset.
+ * @param len
+ * the number of shorts to be read.
+ * @throws IOException
+ * if an I/O exception has occurred.
+ */
+ void readFully(short[] s, int off, int len) throws IOException;
+
+ /**
+ * Reads the specified number of chars from the stream, and stores the
+ * result into the specified array starting at the specified index offset.
+ *
+ * @param c
+ * the char array.
+ * @param off
+ * the offset.
+ * @param len
+ * the number of chars to be read.
+ * @throws IOException
+ * if an I/O exception has occurred.
+ */
+ void readFully(char[] c, int off, int len) throws IOException;
+
+ /**
+ * Reads the specified number of integer from the stream, and stores the
+ * result into the specified array starting at the specified index offset.
+ *
+ * @param i
+ * the integer array.
+ * @param off
+ * the offset.
+ * @param len
+ * the number of integer to be read.
+ * @throws IOException
+ * if an I/O exception has occurred.
+ */
+ void readFully(int[] i, int off, int len) throws IOException;
+
+ /**
+ * Reads the specified number of longs from the stream, and stores the
+ * result into the specified array starting at the specified index offset.
+ *
+ * @param l
+ * the long array.
+ * @param off
+ * the offset.
+ * @param len
+ * the number of longs to be read.
+ * @throws IOException
+ * if an I/O exception has occurred.
+ */
+ void readFully(long[] l, int off, int len) throws IOException;
+
+ /**
+ * Reads the specified number of floats from the stream, and stores the
+ * result into the specified array starting at the specified index offset.
+ *
+ * @param f
+ * the float array.
+ * @param off
+ * the offset.
+ * @param len
+ * the number of floats to be read.
+ * @throws IOException
+ * if an I/O exception has occurred.
+ */
+ void readFully(float[] f, int off, int len) throws IOException;
+
+ /**
+ * Reads the specified number of doubles from the stream, and stores the
+ * result into the specified array starting at the specified index offset.
+ *
+ * @param d
+ * the double array.
+ * @param off
+ * the offset.
+ * @param len
+ * the number of doubles to be read.
+ * @throws IOException
+ * if an I/O exception has occurred.
+ */
+ void readFully(double[] d, int off, int len) throws IOException;
+
+ /**
+ * Gets the stream position.
+ *
+ * @return the stream position.
+ * @throws IOException
+ * if an I/O exception has occurred.
+ */
+ long getStreamPosition() throws IOException;
+
+ /**
+ * Gets the bit offset.
+ *
+ * @return the bit offset.
+ * @throws IOException
+ * if an I/O exception has occurred.
+ */
+ int getBitOffset() throws IOException;
+
+ /**
+ * Sets the bit offset to an integer between 0 and 7.
+ *
+ * @param bitOffset
+ * the bit offset.
+ * @throws IOException
+ * if an I/O exception has occurred.
+ */
+ void setBitOffset(int bitOffset) throws IOException;
+
+ /**
+ * Reads a bit from the stream and returns the value 0 or 1.
+ *
+ * @return the value of single bit: 0 or 1.
+ * @throws IOException
+ * if an I/O exception has occurred.
+ */
+ int readBit() throws IOException;
+
+ /**
+ * Read the specified number of bits and returns their values as long.
+ *
+ * @param numBits
+ * the number of bits to be read.
+ * @return the bit string as a long.
+ * @throws IOException
+ * if an I/O exception has occurred.
+ */
+ long readBits(int numBits) throws IOException;
+
+ /**
+ * Returns the length of the stream.
+ *
+ * @return the length of the stream, or -1 if unknown.
+ * @throws IOException
+ * if an I/O exception has occurred.
+ */
+ long length() throws IOException;
+
+ /**
+ * Skips the specified number of bytes by moving stream position.
+ *
+ * @param n
+ * the number of bytes.
+ * @return the actual skipped number of bytes.
+ * @throws IOException
+ * if an I/O exception has occurred.
+ */
+ int skipBytes(int n) throws IOException;
+
+ /**
+ * Skips the specified number of bytes by moving stream position.
+ *
+ * @param n
+ * the number of bytes.
+ * @return the actual skipped number of bytes.
+ * @throws IOException
+ * if an I/O exception has occurred.
+ */
+ long skipBytes(long n) throws IOException;
+
+ /**
+ * Sets the current stream position to the specified location.
+ *
+ * @param pos
+ * a file pointer position.
+ * @throws IOException
+ * if an I/O exception has occurred.
+ */
+ void seek(long pos) throws IOException;
+
+ /**
+ * Marks a position in the stream to be returned to by a subsequent call to
+ * reset.
+ */
+ void mark();
+
+ /**
+ * Returns the file pointer to its previous position.
+ *
+ * @throws IOException
+ * if an I/O exception has occurred.
+ */
+ void reset() throws IOException;
+
+ /**
+ * Flushes the initial position in this stream prior to the specified stream
+ * position.
+ *
+ * @param pos
+ * the position.
+ * @throws IOException
+ * if an I/O exception has occurred.
+ */
+ void flushBefore(long pos) throws IOException;
+
+ /**
+ * Flushes the initial position in this stream prior to the current stream
+ * position.
+ *
+ * @throws IOException
+ * if an I/O exception has occurred.
+ */
+ void flush() throws IOException;
+
+ /**
+ * Gets the flushed position.
+ *
+ * @return the flushed position.
+ */
+ long getFlushedPosition();
+
+ /**
+ * Returns true if this ImageInputStream caches data in order to allow
+ * seeking backwards.
+ *
+ * @return true, if this ImageInputStream caches data in order to allow
+ * seeking backwards, false otherwise.
+ */
+ boolean isCached();
+
+ /**
+ * Returns true if this ImageInputStream caches data in order to allow
+ * seeking backwards, and keeps it in memory.
+ *
+ * @return true, if this ImageInputStream caches data in order to allow
+ * seeking backwards, and keeps it in memory.
+ */
+ boolean isCachedMemory();
+
+ /**
+ * Returns true if this ImageInputStream caches data in order to allow
+ * seeking backwards, and keeps it in a temporary file.
+ *
+ * @return true, if this ImageInputStream caches data in order to allow
+ * seeking backwards, and keeps it in a temporary file.
+ */
+ boolean isCachedFile();
+
+ /**
+ * Closes this stream.
+ *
+ * @throws IOException
+ * if an I/O exception has occurred.
+ */
+ void close() throws IOException;
+}
diff --git a/awt/javax/imageio/stream/ImageInputStreamImpl.java b/awt/javax/imageio/stream/ImageInputStreamImpl.java
new file mode 100644
index 0000000..d79da41
--- /dev/null
+++ b/awt/javax/imageio/stream/ImageInputStreamImpl.java
@@ -0,0 +1,418 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * @author Rustem V. Rafikov
+ * @version $Revision: 1.3 $
+ */
+
+package javax.imageio.stream;
+
+import java.io.EOFException;
+import java.io.IOException;
+import java.nio.ByteOrder;
+
+/**
+ * The ImageInputStreamImpl abstract class implements the ImageInputStream
+ * interface.
+ *
+ * @since Android 1.0
+ */
+public abstract class ImageInputStreamImpl implements ImageInputStream {
+
+ /**
+ * The byte order.
+ */
+ protected ByteOrder byteOrder = ByteOrder.BIG_ENDIAN;
+
+ /**
+ * The stream position.
+ */
+ protected long streamPos = 0;
+
+ /**
+ * The flushed position.
+ */
+ protected long flushedPos = 0;
+
+ /**
+ * The bit offset.
+ */
+ protected int bitOffset = 0;
+
+ /**
+ * The closed.
+ */
+ private boolean closed = false;
+
+ /**
+ * The position stack.
+ */
+ private final PositionStack posStack = new PositionStack();
+
+ /**
+ * Instantiates a new ImageInputStreamImpl.
+ */
+ public ImageInputStreamImpl() {
+ }
+
+ /**
+ * Check if the stream is closed and if true, throws an IOException.
+ *
+ * @throws IOException
+ * if the stream is closed.
+ */
+ protected final void checkClosed() throws IOException {
+ if (closed) {
+ throw new IOException("stream is closed");
+ }
+ }
+
+ public void setByteOrder(ByteOrder byteOrder) {
+ this.byteOrder = byteOrder;
+ }
+
+ public ByteOrder getByteOrder() {
+ return byteOrder;
+ }
+
+ public abstract int read() throws IOException;
+
+ public int read(byte[] b) throws IOException {
+ return read(b, 0, b.length);
+ }
+
+ public abstract int read(byte[] b, int off, int len) throws IOException;
+
+ public void readBytes(IIOByteBuffer buf, int len) throws IOException {
+ if (buf == null) {
+ throw new NullPointerException("buffer is NULL");
+ }
+
+ byte[] b = new byte[len];
+ len = read(b, 0, b.length);
+
+ buf.setData(b);
+ buf.setOffset(0);
+ buf.setLength(len);
+ }
+
+ public boolean readBoolean() throws IOException {
+ int b = read();
+ if (b < 0) {
+ throw new EOFException("EOF reached");
+ }
+ return b != 0;
+ }
+
+ public byte readByte() throws IOException {
+ int b = read();
+ if (b < 0) {
+ throw new EOFException("EOF reached");
+ }
+ return (byte)b;
+ }
+
+ public int readUnsignedByte() throws IOException {
+ int b = read();
+ if (b < 0) {
+ throw new EOFException("EOF reached");
+ }
+ return b;
+ }
+
+ public short readShort() throws IOException {
+ int b1 = read();
+ int b2 = read();
+
+ if (b1 < 0 || b2 < 0) {
+ throw new EOFException("EOF reached");
+ }
+
+ return byteOrder == ByteOrder.BIG_ENDIAN ? (short)((b1 << 8) | (b2 & 0xff))
+ : (short)((b2 << 8) | (b1 & 0xff));
+ }
+
+ public int readUnsignedShort() throws IOException {
+ // -- TODO implement
+ throw new UnsupportedOperationException("Not implemented yet");
+ }
+
+ public char readChar() throws IOException {
+ // -- TODO implement
+ throw new UnsupportedOperationException("Not implemented yet");
+ }
+
+ public int readInt() throws IOException {
+ // -- TODO implement
+ throw new UnsupportedOperationException("Not implemented yet");
+ }
+
+ public long readUnsignedInt() throws IOException {
+ // -- TODO implement
+ throw new UnsupportedOperationException("Not implemented yet");
+ }
+
+ public long readLong() throws IOException {
+ // -- TODO implement
+ throw new UnsupportedOperationException("Not implemented yet");
+ }
+
+ public float readFloat() throws IOException {
+ // -- TODO implement
+ throw new UnsupportedOperationException("Not implemented yet");
+ }
+
+ public double readDouble() throws IOException {
+ // -- TODO implement
+ throw new UnsupportedOperationException("Not implemented yet");
+ }
+
+ public String readLine() throws IOException {
+ // -- TODO implement
+ throw new UnsupportedOperationException("Not implemented yet");
+ }
+
+ public String readUTF() throws IOException {
+ // -- TODO implement
+ throw new UnsupportedOperationException("Not implemented yet");
+ }
+
+ public void readFully(byte[] b, int off, int len) throws IOException {
+ // -- TODO implement
+ throw new UnsupportedOperationException("Not implemented yet");
+ }
+
+ public void readFully(byte[] b) throws IOException {
+ readFully(b, 0, b.length);
+ }
+
+ public void readFully(short[] s, int off, int len) throws IOException {
+ // -- TODO implement
+ throw new UnsupportedOperationException("Not implemented yet");
+ }
+
+ public void readFully(char[] c, int off, int len) throws IOException {
+ // -- TODO implement
+ throw new UnsupportedOperationException("Not implemented yet");
+ }
+
+ public void readFully(int[] i, int off, int len) throws IOException {
+ // -- TODO implement
+ throw new UnsupportedOperationException("Not implemented yet");
+ }
+
+ public void readFully(long[] l, int off, int len) throws IOException {
+ // -- TODO implement
+ throw new UnsupportedOperationException("Not implemented yet");
+ }
+
+ public void readFully(float[] f, int off, int len) throws IOException {
+ // -- TODO implement
+ throw new UnsupportedOperationException("Not implemented yet");
+ }
+
+ public void readFully(double[] d, int off, int len) throws IOException {
+ // -- TODO implement
+ throw new UnsupportedOperationException("Not implemented yet");
+ }
+
+ public long getStreamPosition() throws IOException {
+ checkClosed();
+ return streamPos;
+ }
+
+ public int getBitOffset() throws IOException {
+ checkClosed();
+ return bitOffset;
+ }
+
+ public void setBitOffset(int bitOffset) throws IOException {
+ checkClosed();
+ this.bitOffset = bitOffset;
+ }
+
+ public int readBit() throws IOException {
+ // -- TODO implement
+ throw new UnsupportedOperationException("Not implemented yet");
+ }
+
+ public long readBits(int numBits) throws IOException {
+ // -- TODO implement
+ throw new UnsupportedOperationException("Not implemented yet");
+ }
+
+ public long length() {
+ return -1L;
+ }
+
+ public int skipBytes(int n) throws IOException {
+ // -- TODO implement
+ throw new UnsupportedOperationException("Not implemented yet");
+ }
+
+ public long skipBytes(long n) throws IOException {
+ // -- TODO implement
+ throw new UnsupportedOperationException("Not implemented yet");
+ }
+
+ public void seek(long pos) throws IOException {
+ checkClosed();
+ if (pos < getFlushedPosition()) {
+ throw new IllegalArgumentException("trying to seek before flushed pos");
+ }
+ bitOffset = 0;
+ streamPos = pos;
+ }
+
+ public void mark() {
+ try {
+ posStack.push(getStreamPosition());
+ } catch (IOException e) {
+ e.printStackTrace();
+ throw new RuntimeException("Stream marking error");
+ }
+ }
+
+ public void reset() throws IOException {
+ // -- TODO bit pos
+ if (!posStack.isEmpty()) {
+ long p = posStack.pop();
+ if (p < flushedPos) {
+ throw new IOException("marked position lies in the flushed portion of the stream");
+ }
+ seek(p);
+ }
+ }
+
+ public void flushBefore(long pos) throws IOException {
+ if (pos > getStreamPosition()) {
+ throw new IndexOutOfBoundsException("Trying to flush outside of current position");
+ }
+ if (pos < flushedPos) {
+ throw new IndexOutOfBoundsException("Trying to flush within already flushed portion");
+ }
+ flushedPos = pos;
+ // -- TODO implement
+ }
+
+ public void flush() throws IOException {
+ flushBefore(getStreamPosition());
+ }
+
+ public long getFlushedPosition() {
+ return flushedPos;
+ }
+
+ public boolean isCached() {
+ return false; // def
+ }
+
+ public boolean isCachedMemory() {
+ return false; // def
+ }
+
+ public boolean isCachedFile() {
+ return false; // def
+ }
+
+ public void close() throws IOException {
+ checkClosed();
+ closed = true;
+
+ }
+
+ /**
+ * Finalizes this object.
+ *
+ * @throws Throwable
+ * if an error occurs.
+ */
+ @Override
+ protected void finalize() throws Throwable {
+ if (!closed) {
+ try {
+ close();
+ } finally {
+ super.finalize();
+ }
+ }
+ }
+
+ /**
+ * The Class PositionStack.
+ */
+ private static class PositionStack {
+
+ /**
+ * The Constant SIZE.
+ */
+ private static final int SIZE = 10;
+
+ /**
+ * The values.
+ */
+ private long[] values = new long[SIZE];
+
+ /**
+ * The pos.
+ */
+ private int pos = 0;
+
+ /**
+ * Push.
+ *
+ * @param v
+ * the v.
+ */
+ void push(long v) {
+ if (pos >= values.length) {
+ ensure(pos + 1);
+ }
+ values[pos++] = v;
+ }
+
+ /**
+ * Pop.
+ *
+ * @return the long.
+ */
+ long pop() {
+ return values[--pos];
+ }
+
+ /**
+ * Checks if is empty.
+ *
+ * @return true, if is empty.
+ */
+ boolean isEmpty() {
+ return pos == 0;
+ }
+
+ /**
+ * Ensure.
+ *
+ * @param size
+ * the size.
+ */
+ private void ensure(int size) {
+ long[] arr = new long[Math.max(2 * values.length, size)];
+ System.arraycopy(values, 0, arr, 0, values.length);
+ values = arr;
+ }
+ }
+}
diff --git a/awt/javax/imageio/stream/ImageOutputStream.java b/awt/javax/imageio/stream/ImageOutputStream.java
new file mode 100644
index 0000000..28ec932
--- /dev/null
+++ b/awt/javax/imageio/stream/ImageOutputStream.java
@@ -0,0 +1,307 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * @author Rustem V. Rafikov
+ * @version $Revision: 1.2 $
+ */
+
+package javax.imageio.stream;
+
+import java.io.DataOutput;
+import java.io.IOException;
+
+/**
+ * The ImageOutputStream represents output stream interface that is used by
+ * ImageWriters.
+ *
+ * @since Android 1.0
+ */
+public interface ImageOutputStream extends DataOutput, ImageInputStream {
+
+ /**
+ * Writes a single byte to the stream at the current position.
+ *
+ * @param b
+ * the integer value, of which the 8 lowest bits will be written.
+ * @throws IOException
+ * if an I/O exception has occurred.
+ */
+ void write(int b) throws IOException;
+
+ /**
+ * Writes the bytes array to the stream.
+ *
+ * @param b
+ * the byte array to be written.
+ * @throws IOException
+ * if an I/O exception has occurred.
+ */
+ void write(byte[] b) throws IOException;
+
+ /**
+ * Writes a number of bytes from the specified byte array beginning from the
+ * specified offset.
+ *
+ * @param b
+ * the byte array.
+ * @param off
+ * the offset.
+ * @param len
+ * the number of bytes to be written.
+ * @throws IOException
+ * if an I/O exception has occurred.
+ */
+ void write(byte[] b, int off, int len) throws IOException;
+
+ /**
+ * Writes the specified boolean value to the stream, 1 if it is true, 0 if
+ * it is false.
+ *
+ * @param b
+ * the boolean value to be written.
+ * @throws IOException
+ * if an I/O exception has occurred.
+ */
+ void writeBoolean(boolean b) throws IOException;
+
+ /**
+ * Writes the 8 lowest bits of the specified integer value to the stream.
+ *
+ * @param b
+ * the specified integer value.
+ * @throws IOException
+ * if an I/O exception has occurred.
+ */
+ void writeByte(int b) throws IOException;
+
+ /**
+ * Writes a short value to the output stream.
+ *
+ * @param v
+ * the short value to be written.
+ * @throws IOException
+ * if an I/O exception has occurred.
+ */
+ void writeShort(int v) throws IOException;
+
+ /**
+ * Writes the 16 lowest bits of the specified integer value to the stream.
+ *
+ * @param v
+ * the specified integer value.
+ * @throws IOException
+ * if an I/O exception has occurred.
+ */
+ void writeChar(int v) throws IOException;
+
+ /**
+ * Writes an integer value to the output stream.
+ *
+ * @param v
+ * the integer value to be written.
+ * @throws IOException
+ * if an I/O exception has occurred.
+ */
+ void writeInt(int v) throws IOException;
+
+ /**
+ * Write long.
+ *
+ * @param v
+ * the long value.
+ * @throws IOException
+ * if an I/O exception has occurred.
+ */
+ void writeLong(long v) throws IOException;
+
+ /**
+ * Writes a float value to the output stream.
+ *
+ * @param v
+ * the float which contains value to be written.
+ * @throws IOException
+ * if an I/O exception has occurred.
+ */
+ void writeFloat(float v) throws IOException;
+
+ /**
+ * Writes a double value to the output stream.
+ *
+ * @param v
+ * the double which contains value to be written.
+ * @throws IOException
+ * if an I/O exception has occurred.
+ */
+ void writeDouble(double v) throws IOException;
+
+ /**
+ * Writes the specified string to the stream.
+ *
+ * @param s
+ * the string to be written.
+ * @throws IOException
+ * if an I/O exception has occurred.
+ */
+ void writeBytes(String s) throws IOException;
+
+ /**
+ * Writes the specified String to the output stream.
+ *
+ * @param s
+ * the String to be written.
+ * @throws IOException
+ * if an I/O exception has occurred.
+ */
+ void writeChars(String s) throws IOException;
+
+ /**
+ * Writes 2 bytes to the output stream in the modified UTF-8 representation
+ * of every character of the specified string.
+ *
+ * @param s
+ * the specified string to be written.
+ * @throws IOException
+ * if an I/O exception has occurred.
+ */
+ void writeUTF(String s) throws IOException;
+
+ /**
+ * Flushes the initial position in this stream prior to the specified stream
+ * position.
+ *
+ * @param pos
+ * the position.
+ * @throws IOException
+ * if an I/O exception has occurred.
+ */
+ void flushBefore(long pos) throws IOException;
+
+ /**
+ * Writes a len number of short values from the specified array to the
+ * stream.
+ *
+ * @param s
+ * the shorts array to be written.
+ * @param off
+ * the offset in the char array.
+ * @param len
+ * the length of chars to be written.
+ * @throws IOException
+ * if an I/O exception has occurred.
+ */
+ void writeShorts(short[] s, int off, int len) throws IOException;
+
+ /**
+ * Writes a len number of chars to the stream.
+ *
+ * @param c
+ * the char array to be written.
+ * @param off
+ * the offset in the char array.
+ * @param len
+ * the length of chars to be written.
+ * @throws IOException
+ * if an I/O exception has occurred.
+ */
+ void writeChars(char[] c, int off, int len) throws IOException;
+
+ /**
+ * Writes a len number of integer values from the specified array to the
+ * stream.
+ *
+ * @param i
+ * the integer array to be written.
+ * @param off
+ * the offset in the char array.
+ * @param len
+ * the length of chars to be written.
+ * @throws IOException
+ * if an I/O exception has occurred.
+ */
+ void writeInts(int[] i, int off, int len) throws IOException;
+
+ /**
+ * Writes a len number of long values from the specified array to the
+ * stream.
+ *
+ * @param l
+ * the long array to be written.
+ * @param off
+ * the offset in the char array.
+ * @param len
+ * the length of chars to be written.
+ * @throws IOException
+ * if an I/O exception has occurred.
+ */
+ void writeLongs(long[] l, int off, int len) throws IOException;
+
+ /**
+ * Writes a len number of float values from the specified array to the
+ * stream.
+ *
+ * @param f
+ * the float array to be written.
+ * @param off
+ * the offset in the char array.
+ * @param len
+ * the length of chars to be written.
+ * @throws IOException
+ * if an I/O exception has occurred.
+ */
+ void writeFloats(float[] f, int off, int len) throws IOException;
+
+ /**
+ * Writes a len number of double values from the specified array to the
+ * stream.
+ *
+ * @param d
+ * the double array to be written.
+ * @param off
+ * the offset in the char array.
+ * @param len
+ * the length of chars to be written.
+ * @throws IOException
+ * if an I/O exception has occurred.
+ */
+ void writeDoubles(double[] d, int off, int len) throws IOException;
+
+ /**
+ * Writes a single bit at the current position.
+ *
+ * @param bit
+ * the integer whose least significant bit is to be written to
+ * the stream.
+ * @throws IOException
+ * if an I/O exception has occurred.
+ */
+ void writeBit(int bit) throws IOException;
+
+ /**
+ * Writes a sequence of bits beginning from the current position.
+ *
+ * @param bits
+ * the long value containing the bits to be written, starting
+ * with the bit in position numBits - 1 down to the least
+ * significant bit.
+ * @param numBits
+ * the number of significant bit, it can be between 0 and 64.
+ * @throws IOException
+ * if an I/O exception has occurred.
+ */
+ void writeBits(long bits, int numBits) throws IOException;
+
+}
diff --git a/awt/javax/imageio/stream/ImageOutputStreamImpl.java b/awt/javax/imageio/stream/ImageOutputStreamImpl.java
new file mode 100644
index 0000000..0fef78f
--- /dev/null
+++ b/awt/javax/imageio/stream/ImageOutputStreamImpl.java
@@ -0,0 +1,174 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * @author Rustem V. Rafikov
+ * @version $Revision: 1.3 $
+ */
+
+package javax.imageio.stream;
+
+import java.io.IOException;
+import java.nio.ByteOrder;
+
+/*
+ * @author Rustem V. Rafikov
+ * @version $Revision: 1.3 $
+ */
+
+/**
+ * The ImageOutputStreamImpl abstract class implements the ImageOutputStream
+ * interface.
+ *
+ * @since Android 1.0
+ */
+public abstract class ImageOutputStreamImpl extends ImageInputStreamImpl implements
+ ImageOutputStream {
+
+ /**
+ * Instantiates a new ImageOutputStreamImpl.
+ */
+ public ImageOutputStreamImpl() {
+ }
+
+ public abstract void write(int b) throws IOException;
+
+ public void write(byte[] b) throws IOException {
+ write(b, 0, b.length);
+ }
+
+ public abstract void write(byte[] b, int off, int len) throws IOException;
+
+ public void writeBoolean(boolean v) throws IOException {
+ write(v ? 1 : 0);
+ }
+
+ public void writeByte(int v) throws IOException {
+ write(v);
+ }
+
+ public void writeShort(int v) throws IOException {
+ if (byteOrder == ByteOrder.BIG_ENDIAN) {
+
+ } else {
+
+ }
+ // -- TODO implement
+ throw new UnsupportedOperationException("Not implemented yet");
+ }
+
+ public void writeChar(int v) throws IOException {
+ writeShort(v);
+ }
+
+ public void writeInt(int v) throws IOException {
+ if (byteOrder == ByteOrder.BIG_ENDIAN) {
+
+ } else {
+
+ }
+ // -- TODO implement
+ throw new UnsupportedOperationException("Not implemented yet");
+ }
+
+ public void writeLong(long v) throws IOException {
+ if (byteOrder == ByteOrder.BIG_ENDIAN) {
+
+ } else {
+
+ }
+ // -- TODO implement
+ throw new UnsupportedOperationException("Not implemented yet");
+ }
+
+ public void writeFloat(float v) throws IOException {
+ writeInt(Float.floatToIntBits(v));
+ }
+
+ public void writeDouble(double v) throws IOException {
+ writeLong(Double.doubleToLongBits(v));
+ }
+
+ public void writeBytes(String s) throws IOException {
+ write(s.getBytes());
+ }
+
+ public void writeChars(String s) throws IOException {
+ char[] chs = s.toCharArray();
+ writeChars(chs, 0, chs.length);
+ }
+
+ public void writeUTF(String s) throws IOException {
+ // -- TODO implement
+ throw new UnsupportedOperationException("Not implemented yet");
+ }
+
+ public void writeShorts(short[] s, int off, int len) throws IOException {
+ // -- TODO implement
+ throw new UnsupportedOperationException("Not implemented yet");
+ }
+
+ public void writeChars(char[] c, int off, int len) throws IOException {
+ // -- TODO implement
+ throw new UnsupportedOperationException("Not implemented yet");
+ }
+
+ public void writeInts(int[] i, int off, int len) throws IOException {
+ // -- TODO implement
+ throw new UnsupportedOperationException("Not implemented yet");
+ }
+
+ public void writeLongs(long[] l, int off, int len) throws IOException {
+ // -- TODO implement
+ throw new UnsupportedOperationException("Not implemented yet");
+ }
+
+ public void writeFloats(float[] f, int off, int len) throws IOException {
+ // -- TODO implement
+ throw new UnsupportedOperationException("Not implemented yet");
+ }
+
+ public void writeDoubles(double[] d, int off, int len) throws IOException {
+ // -- TODO implement
+ throw new UnsupportedOperationException("Not implemented yet");
+ }
+
+ public void writeBit(int bit) throws IOException {
+ // -- TODO implement
+ throw new UnsupportedOperationException("Not implemented yet");
+ }
+
+ public void writeBits(long bits, int numBits) throws IOException {
+ // -- TODO implement
+ throw new UnsupportedOperationException("Not implemented yet");
+ }
+
+ /**
+ * Flushes the bits. This method should be called in the write methods by
+ * subclasses.
+ *
+ * @throws IOException
+ * if an I/O exception has occurred.
+ */
+ protected final void flushBits() throws IOException {
+ if (bitOffset == 0) {
+ return;
+ }
+
+ // -- TODO implement
+ throw new UnsupportedOperationException("Not implemented yet");
+ }
+}
diff --git a/awt/javax/imageio/stream/MemoryCacheImageInputStream.java b/awt/javax/imageio/stream/MemoryCacheImageInputStream.java
new file mode 100644
index 0000000..d7fc791
--- /dev/null
+++ b/awt/javax/imageio/stream/MemoryCacheImageInputStream.java
@@ -0,0 +1,119 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package javax.imageio.stream;
+
+import org.apache.harmony.x.imageio.stream.RandomAccessMemoryCache;
+
+import java.io.IOException;
+import java.io.InputStream;
+
+/**
+ * The MemoryCacheImageInputStream class implements ImageInputStream using a
+ * memory buffer for caching the data.
+ *
+ * @since Android 1.0
+ */
+public class MemoryCacheImageInputStream extends ImageInputStreamImpl {
+
+ /**
+ * The is.
+ */
+ private InputStream is;
+
+ /**
+ * The ramc.
+ */
+ private RandomAccessMemoryCache ramc = new RandomAccessMemoryCache();
+
+ /**
+ * Instantiates a new MemoryCacheImageInputStream which reads from the
+ * specified InputStream.
+ *
+ * @param stream
+ * the InputStream to be read.
+ */
+ public MemoryCacheImageInputStream(InputStream stream) {
+ if (stream == null) {
+ throw new IllegalArgumentException("stream == null!");
+ }
+ is = stream;
+ }
+
+ @Override
+ public int read() throws IOException {
+ bitOffset = 0;
+
+ if (streamPos >= ramc.length()) {
+ int count = (int)(streamPos - ramc.length() + 1);
+ int bytesAppended = ramc.appendData(is, count);
+
+ if (bytesAppended < count) {
+ return -1;
+ }
+ }
+
+ int res = ramc.getData(streamPos);
+ if (res >= 0) {
+ streamPos++;
+ }
+ return res;
+ }
+
+ @Override
+ public int read(byte[] b, int off, int len) throws IOException {
+ bitOffset = 0;
+
+ if (streamPos >= ramc.length()) {
+ int count = (int)(streamPos - ramc.length() + len);
+ ramc.appendData(is, count);
+ }
+
+ int res = ramc.getData(b, off, len, streamPos);
+ if (res > 0) {
+ streamPos += res;
+ }
+ return res;
+ }
+
+ @Override
+ public boolean isCached() {
+ return true;
+ }
+
+ @Override
+ public boolean isCachedFile() {
+ return false;
+ }
+
+ @Override
+ public boolean isCachedMemory() {
+ return true;
+ }
+
+ @Override
+ public void close() throws IOException {
+ super.close();
+ ramc.close();
+ }
+
+ @Override
+ public void flushBefore(long pos) throws IOException {
+ super.flushBefore(pos);
+ ramc.freeBefore(getFlushedPosition());
+ }
+}
diff --git a/awt/javax/imageio/stream/MemoryCacheImageOutputStream.java b/awt/javax/imageio/stream/MemoryCacheImageOutputStream.java
new file mode 100644
index 0000000..1df40a3
--- /dev/null
+++ b/awt/javax/imageio/stream/MemoryCacheImageOutputStream.java
@@ -0,0 +1,135 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package javax.imageio.stream;
+
+import org.apache.harmony.x.imageio.stream.RandomAccessMemoryCache;
+
+import java.io.OutputStream;
+import java.io.IOException;
+
+/**
+ * The MemoryCacheImageOutputStream class implements ImageOutputStream using a
+ * memory buffer for caching the data.
+ *
+ * @since Android 1.0
+ */
+public class MemoryCacheImageOutputStream extends ImageOutputStreamImpl {
+
+ /**
+ * The os.
+ */
+ OutputStream os;
+
+ /**
+ * The ramc.
+ */
+ RandomAccessMemoryCache ramc = new RandomAccessMemoryCache();
+
+ /**
+ * Instantiates a new MemoryCacheImageOutputStream which writes to the
+ * specified OutputStream.
+ *
+ * @param stream
+ * the OutputStream.
+ */
+ public MemoryCacheImageOutputStream(OutputStream stream) {
+ if (stream == null) {
+ throw new IllegalArgumentException("stream == null!");
+ }
+ os = stream;
+ }
+
+ @Override
+ public void write(int b) throws IOException {
+ flushBits(); // See the flushBits method description
+
+ ramc.putData(b, streamPos);
+ streamPos++;
+ }
+
+ @Override
+ public void write(byte[] b, int off, int len) throws IOException {
+ flushBits(); // See the flushBits method description
+
+ ramc.putData(b, off, len, streamPos);
+ streamPos += len;
+ }
+
+ @Override
+ public int read() throws IOException {
+ bitOffset = 0;
+
+ int res = ramc.getData(streamPos);
+ if (res >= 0) {
+ streamPos++;
+ }
+ return res;
+ }
+
+ @Override
+ public int read(byte[] b, int off, int len) throws IOException {
+ bitOffset = 0;
+
+ int res = ramc.getData(b, off, len, streamPos);
+ if (res > 0) {
+ streamPos += res;
+ }
+ return res;
+ }
+
+ @Override
+ public long length() {
+ return ramc.length();
+ }
+
+ @Override
+ public boolean isCached() {
+ return true;
+ }
+
+ @Override
+ public boolean isCachedMemory() {
+ return true;
+ }
+
+ @Override
+ public boolean isCachedFile() {
+ return false;
+ }
+
+ @Override
+ public void close() throws IOException {
+ flushBefore(length());
+ super.close();
+ ramc.close();
+ }
+
+ @Override
+ public void flushBefore(long pos) throws IOException {
+ long flushedPosition = getFlushedPosition();
+ super.flushBefore(pos);
+
+ long newFlushedPosition = getFlushedPosition();
+ int nBytes = (int)(newFlushedPosition - flushedPosition);
+
+ ramc.getData(os, nBytes, flushedPosition);
+ ramc.freeBefore(newFlushedPosition);
+
+ os.flush();
+ }
+}
diff --git a/awt/javax/imageio/stream/package.html b/awt/javax/imageio/stream/package.html
new file mode 100644
index 0000000..6cf53c3
--- /dev/null
+++ b/awt/javax/imageio/stream/package.html
@@ -0,0 +1,8 @@
+<html>
+ <body>
+ <p>
+ This package contains classes and interfaces for handling images with low-level I/O operations.
+ </p>
+ @since Android 1.0
+ </body>
+</html>