Deprecate for BufferedImageInputStream, now using buffered streams directly in all readers.

2026-04-25 00:00:03 -04:00 · 2021-01-11 22:07:31 +01:00
parent 8a1a90dafd
commit ebaa69713f
18 changed files with 944 additions and 105 deletions
@@ -0,0 +1,252 @@
+/*
+ * Copyright (c) 2021, Harald Kuhr
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * * Redistributions of source code must retain the above copyright notice, this
+ *   list of conditions and the following disclaimer.
+ *
+ * * Redistributions in binary form must reproduce the above copyright notice,
+ *   this list of conditions and the following disclaimer in the documentation
+ *   and/or other materials provided with the distribution.
+ *
+ * * Neither the name of the copyright holder nor the names of its
+ *   contributors may be used to endorse or promote products derived from
+ *   this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package com.twelvemonkeys.imageio.stream;
+
+import javax.imageio.stream.ImageInputStreamImpl;
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.RandomAccessFile;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+
+import static com.twelvemonkeys.lang.Validate.notNull;
+import static java.lang.Math.max;
+
+/**
+ * A buffered replacement for {@link javax.imageio.stream.FileImageInputStream}
+ * that provides greatly improved performance for shorter reads, like single
+ * byte or bit reads.
+ * As with {@code javax.imageio.stream.FileImageInputStream}, either
+ * {@link File} or {@link RandomAccessFile} can be used as input.
+ *
+ * @see javax.imageio.stream.FileImageInputStream
+ */
+// TODO: Create a memory-mapped version?
+//  Or not... From java.nio.channels.FileChannel.map:
+//      For most operating systems, mapping a file into memory is more
+//      expensive than reading or writing a few tens of kilobytes of data via
+//      the usual {@link #read read} and {@link #write write} methods.  From the
+//      standpoint of performance it is generally only worth mapping relatively
+//      large files into memory.
+public final class BufferedFileImageInputStream extends ImageInputStreamImpl {
+    static final int DEFAULT_BUFFER_SIZE = 8192;
+
+    private byte[] buffer = new byte[DEFAULT_BUFFER_SIZE];
+    private int bufferPos;
+    private int bufferLimit;
+
+    private final ByteBuffer integralCache = ByteBuffer.allocate(8);
+    private final byte[] integralCacheArray = integralCache.array();
+
+    private RandomAccessFile raf;
+
+    /**
+     * Constructs a <code>BufferedFileImageInputStream</code> that will read from a given <code>File</code>.
+     *
+     * @param file a <code>File</code> to read from.
+     * @throws IllegalArgumentException if <code>file</code> is <code>null</code>.
+     * @throws FileNotFoundException    if <code>file</code> is a directory or cannot be opened for reading
+     *                                  for any reason.
+     * @throws IOException              if an I/O error occurs.
+     */
+    public BufferedFileImageInputStream(final File file) throws IOException {
+        this(new RandomAccessFile(notNull(file, "file"), "r"));
+    }
+
+    /**
+     * Constructs a <code>BufferedFileImageInputStream</code> that will read from a given <code>RandomAccessFile</code>.
+     *
+     * @param raf a <code>RandomAccessFile</code> to read from.
+     * @throws IllegalArgumentException if <code>raf</code> is <code>null</code>.
+     */
+    public BufferedFileImageInputStream(final RandomAccessFile raf) {
+        this.raf = notNull(raf, "raf");
+    }
+
+    @SuppressWarnings("BooleanMethodIsAlwaysInverted")
+    private boolean fillBuffer() throws IOException {
+        bufferPos = 0;
+        int length = raf.read(buffer, 0, buffer.length);
+        bufferLimit = max(length, 0);
+
+        return bufferLimit > 0;
+    }
+
+    private boolean bufferEmpty() {
+        return bufferPos >= bufferLimit;
+    }
+
+    @Override
+    public void setByteOrder(ByteOrder byteOrder) {
+        super.setByteOrder(byteOrder);
+        integralCache.order(byteOrder);
+    }
+
+    @Override
+    public int read() throws IOException {
+        checkClosed();
+
+        if (bufferEmpty() && !fillBuffer()) {
+            return -1;
+        }
+
+        bitOffset = 0;
+        streamPos++;
+
+        return buffer[bufferPos++] & 0xff;
+    }
+
+    @Override
+    public int read(final byte[] pBuffer, final int pOffset, final int pLength) throws IOException {
+        checkClosed();
+        bitOffset = 0;
+
+        if (bufferEmpty()) {
+            // Bypass buffer if buffer is empty for reads longer than buffer
+            if (pLength >= buffer.length) {
+                return readDirect(pBuffer, pOffset, pLength);
+            }
+            else if (!fillBuffer()) {
+                return -1;
+            }
+        }
+
+        return readBuffered(pBuffer, pOffset, pLength);
+    }
+
+    private int readDirect(final byte[] pBuffer, final int pOffset, final int pLength) throws IOException {
+        // Invalidate the buffer, as its contents is no longer in sync with the stream's position.
+        bufferLimit = 0;
+        int read = raf.read(pBuffer, pOffset, pLength);
+
+        if (read > 0) {
+            streamPos += read;
+        }
+
+        return read;
+    }
+
+    private int readBuffered(final byte[] pBuffer, final int pOffset, final int pLength) {
+        // Read as much as possible from buffer
+        int length = Math.min(bufferLimit - bufferPos, pLength);
+
+        if (length > 0) {
+            System.arraycopy(buffer, bufferPos, pBuffer, pOffset, length);
+            bufferPos += length;
+            streamPos += length;
+        }
+
+        return length;
+    }
+
+    public long length() {
+        // WTF?! This method is allowed to throw IOException in the interface...
+        try {
+            checkClosed();
+            return raf.length();
+        }
+        catch (IOException ignore) {
+        }
+
+        return -1;
+    }
+
+    public void close() throws IOException {
+        super.close();
+
+        raf.close();
+
+        raf = null;
+        buffer = null;
+    }
+
+    // Need to override the readShort(), readInt() and readLong() methods,
+    // because the implementations in ImageInputStreamImpl expects the
+    // read(byte[], int, int) to always read the expected number of bytes,
+    // causing uninitialized values, alignment issues and EOFExceptions at
+    // random places...
+    // Notes:
+    // * readUnsignedXx() is covered by their signed counterparts
+    // * readChar() is covered by readShort()
+    // * readFloat() and readDouble() is covered by readInt() and readLong()
+    //   respectively.
+    // * readLong() may be covered by two readInt()s, we'll override to be safe
+
+    @Override
+    public short readShort() throws IOException {
+        readFully(integralCacheArray, 0, 2);
+
+        return integralCache.getShort(0);
+    }
+
+    @Override
+    public int readInt() throws IOException {
+        readFully(integralCacheArray, 0, 4);
+
+        return integralCache.getInt(0);
+    }
+
+    @Override
+    public long readLong() throws IOException {
+        readFully(integralCacheArray, 0, 8);
+
+        return integralCache.getLong(0);
+    }
+
+    @Override
+    public void seek(long position) throws IOException {
+        checkClosed();
+
+        if (position < flushedPos) {
+            throw new IndexOutOfBoundsException("position < flushedPos!");
+        }
+
+        bitOffset = 0;
+
+        if (streamPos == position) {
+            return;
+        }
+
+        // Optimized to not invalidate buffer if new position is within current buffer
+        long newBufferPos = bufferPos + position - streamPos;
+        if (newBufferPos >= 0 && newBufferPos <= bufferLimit) {
+            bufferPos = (int) newBufferPos;
+        }
+        else {
+            // Will invalidate buffer
+            bufferLimit = 0;
+            raf.seek(position);
+        }
+
+        streamPos = position;
+    }
+}
@@ -0,0 +1,97 @@
+/*
+ * Copyright (c) 2021, Harald Kuhr
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * * Redistributions of source code must retain the above copyright notice, this
+ *   list of conditions and the following disclaimer.
+ *
+ * * Redistributions in binary form must reproduce the above copyright notice,
+ *   this list of conditions and the following disclaimer in the documentation
+ *   and/or other materials provided with the distribution.
+ *
+ * * Neither the name of the copyright holder nor the names of its
+ *   contributors may be used to endorse or promote products derived from
+ *   this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package com.twelvemonkeys.imageio.stream;
+
+import com.twelvemonkeys.imageio.spi.ProviderInfo;
+
+import javax.imageio.spi.ImageInputStreamSpi;
+import javax.imageio.spi.ServiceRegistry;
+import javax.imageio.stream.ImageInputStream;
+import java.io.File;
+import java.io.IOException;
+import java.util.Iterator;
+import java.util.Locale;
+
+/**
+ * BufferedFileImageInputStreamSpi
+ * Experimental
+ *
+ * @author <a href="mailto:harald.kuhr@gmail.com">Harald Kuhr</a>
+ * @author last modified by $Author: haraldk$
+ * @version $Id: BufferedFileImageInputStreamSpi.java,v 1.0 May 15, 2008 2:14:59 PM haraldk Exp$
+ */
+public class BufferedFileImageInputStreamSpi extends ImageInputStreamSpi {
+    public BufferedFileImageInputStreamSpi() {
+        this(new StreamProviderInfo());
+    }
+
+    private BufferedFileImageInputStreamSpi(ProviderInfo providerInfo) {
+        super(providerInfo.getVendorName(), providerInfo.getVersion(), File.class);
+    }
+
+    @Override
+    public void onRegistration(final ServiceRegistry registry, final Class<?> category) {
+        Iterator<ImageInputStreamSpi> providers = registry.getServiceProviders(ImageInputStreamSpi.class, new FileInputFilter(), true);
+
+        while (providers.hasNext()) {
+            ImageInputStreamSpi provider = providers.next();
+            if (provider != this) {
+                registry.setOrdering(ImageInputStreamSpi.class, this, provider);
+            }
+        }
+    }
+
+    public ImageInputStream createInputStreamInstance(final Object input, final boolean pUseCache, final File pCacheDir) throws IOException {
+        if (input instanceof File) {
+            File file = (File) input;
+            return new BufferedFileImageInputStream(file);
+        }
+        else {
+            throw new IllegalArgumentException("Expected input of type URL: " + input);
+        }
+    }
+
+    @Override
+    public boolean canUseCacheFile() {
+        return false;
+    }
+
+    public String getDescription(final Locale pLocale) {
+        return "Service provider that instantiates an ImageInputStream from a File";
+    }
+
+    private static class FileInputFilter implements ServiceRegistry.Filter {
+        @Override
+        public boolean filter(final Object provider) {
+            return ((ImageInputStreamSpi) provider).getInputClass() == File.class;
+        }
+    }
+}
@@ -43,15 +43,18 @@ import static com.twelvemonkeys.lang.Validate.notNull;
 * A buffered {@code ImageInputStream}.
 * Experimental - seems to be effective for {@link javax.imageio.stream.FileImageInputStream}
 * and {@link javax.imageio.stream.FileCacheImageInputStream} when doing a lot of single-byte reads
- * (or short byte-array reads) on OS X at least.
+ * (or short byte-array reads).
 * Code that uses the {@code readFully} methods are not affected by the issue.
+ * <p/>
+ * NOTE: Invoking {@code close()} will  <em>NOT</em> close the wrapped stream.
 *
 * @author <a href="mailto:harald.kuhr@gmail.com">Harald Kuhr</a>
 * @author last modified by $Author: haraldk$
 * @version $Id: BufferedFileImageInputStream.java,v 1.0 May 15, 2008 4:36:49 PM haraldk Exp$
+ *
+ * @deprecated Use {@link BufferedFileImageInputStream} instead.
 */
-// TODO: Create a provider for this (wrapping the FileIIS and FileCacheIIS classes), and disable the Sun built-in spis?
-// TODO: Test on other platforms, might be just an OS X issue
+@Deprecated
 public final class BufferedImageInputStream extends ImageInputStreamImpl implements ImageInputStream {
    static final int DEFAULT_BUFFER_SIZE = 8192;

@@ -0,0 +1,97 @@
+/*
+ * Copyright (c) 2021, Harald Kuhr
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * * Redistributions of source code must retain the above copyright notice, this
+ *   list of conditions and the following disclaimer.
+ *
+ * * Redistributions in binary form must reproduce the above copyright notice,
+ *   this list of conditions and the following disclaimer in the documentation
+ *   and/or other materials provided with the distribution.
+ *
+ * * Neither the name of the copyright holder nor the names of its
+ *   contributors may be used to endorse or promote products derived from
+ *   this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package com.twelvemonkeys.imageio.stream;
+
+import com.twelvemonkeys.imageio.spi.ProviderInfo;
+
+import javax.imageio.spi.ImageInputStreamSpi;
+import javax.imageio.spi.ServiceRegistry;
+import javax.imageio.stream.ImageInputStream;
+import java.io.File;
+import java.io.RandomAccessFile;
+import java.util.Iterator;
+import java.util.Locale;
+
+/**
+ * BufferedRAFImageInputStreamSpi
+ * Experimental
+ *
+ * @author <a href="mailto:harald.kuhr@gmail.com">Harald Kuhr</a>
+ * @author last modified by $Author: haraldk$
+ * @version $Id: BufferedRAFImageInputStreamSpi.java,v 1.0 May 15, 2008 2:14:59 PM haraldk Exp$
+ */
+public class BufferedRAFImageInputStreamSpi extends ImageInputStreamSpi {
+    public BufferedRAFImageInputStreamSpi() {
+        this(new StreamProviderInfo());
+    }
+
+    private BufferedRAFImageInputStreamSpi(ProviderInfo providerInfo) {
+        super(providerInfo.getVendorName(), providerInfo.getVersion(), RandomAccessFile.class);
+    }
+
+    @Override
+    public void onRegistration(final ServiceRegistry registry, final Class<?> category) {
+        Iterator<ImageInputStreamSpi> providers = registry.getServiceProviders(ImageInputStreamSpi.class, new RAFInputFilter(), true);
+
+        while (providers.hasNext()) {
+            ImageInputStreamSpi provider = providers.next();
+            if (provider != this) {
+                registry.setOrdering(ImageInputStreamSpi.class, this, provider);
+            }
+        }
+    }
+
+    public ImageInputStream createInputStreamInstance(final Object input, final boolean pUseCache, final File pCacheDir) {
+        if (input instanceof RandomAccessFile) {
+            RandomAccessFile file = (RandomAccessFile) input;
+            return new BufferedFileImageInputStream(file);
+        }
+        else {
+            throw new IllegalArgumentException("Expected input of type URL: " + input);
+        }
+    }
+
+    @Override
+    public boolean canUseCacheFile() {
+        return false;
+    }
+
+    public String getDescription(final Locale pLocale) {
+        return "Service provider that instantiates an ImageInputStream from a RandomAccessFile";
+    }
+
+    private static class RAFInputFilter implements ServiceRegistry.Filter {
+        @Override
+        public boolean filter(final Object provider) {
+            return ((ImageInputStreamSpi) provider).getInputClass() == RandomAccessFile.class;
+        }
+    }
+}
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2008, Harald Kuhr
+ * Copyright (c) 2021, Harald Kuhr
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
@@ -34,7 +34,6 @@ import com.twelvemonkeys.imageio.spi.ProviderInfo;

 import javax.imageio.spi.ImageInputStreamSpi;
 import javax.imageio.stream.FileCacheImageInputStream;
-import javax.imageio.stream.FileImageInputStream;
 import javax.imageio.stream.ImageInputStream;
 import javax.imageio.stream.MemoryCacheImageInputStream;
 import java.io.File;
@@ -72,7 +71,7 @@ public class URLImageInputStreamSpi extends ImageInputStreamSpi {
            // Special case for file protocol, a lot faster than FileCacheImageInputStream
            if ("file".equals(url.getProtocol())) {
                try {
-                    return new BufferedImageInputStream(new FileImageInputStream(new File(url.toURI())));
+                    return new BufferedFileImageInputStream(new File(url.toURI()));
                }
                catch (URISyntaxException ignore) {
                    // This should never happen, but if it does, we'll fall back to using the stream  
@@ -81,29 +80,29 @@ public class URLImageInputStreamSpi extends ImageInputStreamSpi {
            }

            // Otherwise revert to cached
-            final InputStream stream = url.openStream();
+            final InputStream urlStream = url.openStream();
            if (pUseCache) {
-                return new BufferedImageInputStream(new FileCacheImageInputStream(stream, pCacheDir) {
+                return new FileCacheImageInputStream(urlStream, pCacheDir) {
                    @Override
                    public void close() throws IOException {
                        try {
                            super.close();
                        }
                        finally {
-                            stream.close(); // NOTE: If this line throws IOE, it will shadow the original..
+                            urlStream.close(); // NOTE: If this line throws IOE, it will shadow the original..
                        }
                    }
-                });
+                };
            }
            else {
-                return new MemoryCacheImageInputStream(stream) {
+                return new MemoryCacheImageInputStream(urlStream) {
                    @Override
                    public void close() throws IOException {
                        try {
                            super.close();
                        }
                        finally {
-                            stream.close(); // NOTE: If this line throws IOE, it will shadow the original..
+                            urlStream.close(); // NOTE: If this line throws IOE, it will shadow the original..
                        }
                    }
                };
@@ -0,0 +1,2 @@
+com.twelvemonkeys.imageio.stream.BufferedFileImageInputStreamSpi
+com.twelvemonkeys.imageio.stream.BufferedRAFImageInputStreamSpi