1 /*
   2  * Copyright (c) 2000, 2003, 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 javax.imageio.stream;
  27 
  28 import java.util.ArrayList;
  29 import java.io.InputStream;
  30 import java.io.OutputStream;
  31 import java.io.IOException;
  32 
  33 /**
  34  * Package-visible class consolidating common code for
  35  * <code>MemoryCacheImageInputStream</code> and
  36  * <code>MemoryCacheImageOutputStream</code>.
  37  * This class keeps an <code>ArrayList</code> of 8K blocks,
  38  * loaded sequentially.  Blocks may only be disposed of
  39  * from the index 0 forward.  As blocks are freed, the
  40  * corresponding entries in the array list are set to
  41  * <code>null</code>, but no compacting is performed.
  42  * This allows the index for each block to never change,
  43  * and the length of the cache is always the same as the
  44  * total amount of data ever cached.  Cached data is
  45  * therefore always contiguous from the point of last
  46  * disposal to the current length.
  47  *
  48  * <p> The total number of blocks resident in the cache must not
  49  * exceed <code>Integer.MAX_VALUE</code>.  In practice, the limit of
  50  * available memory will be exceeded long before this becomes an
  51  * issue, since a full cache would contain 8192*2^31 = 16 terabytes of
  52  * data.
  53  *
  54  * A <code>MemoryCache</code> may be reused after a call
  55  * to <code>reset()</code>.
  56  */
  57 class MemoryCache {
  58 
  59     private static final int BUFFER_LENGTH = 8192;
  60 
  61     private ArrayList<byte[]> cache = new ArrayList<>();
  62 
  63     private long cacheStart = 0L;
  64 
  65     /**
  66      * The largest position ever written to the cache.
  67      */
  68     private long length = 0L;
  69 
  70     private byte[] getCacheBlock(long blockNum) throws IOException {
  71         long blockOffset = blockNum - cacheStart;
  72         if (blockOffset > Integer.MAX_VALUE) {
  73             // This can only happen when the cache hits 16 terabytes of
  74             // contiguous data...
  75             throw new IOException("Cache addressing limit exceeded!");
  76         }
  77         return cache.get((int)blockOffset);
  78     }
  79 
  80     /**
  81      * Ensures that at least <code>pos</code> bytes are cached,
  82      * or the end of the source is reached.  The return value
  83      * is equal to the smaller of <code>pos</code> and the
  84      * length of the source.


  85      */
  86     public long loadFromStream(InputStream stream, long pos)
  87         throws IOException {
  88         // We've already got enough data cached
  89         if (pos < length) {
  90             return pos;
  91         }
  92 
  93         int offset = (int)(length % BUFFER_LENGTH);
  94         byte [] buf = null;
  95 
  96         long len = pos - length;
  97         if (offset != 0) {
  98             buf = getCacheBlock(length/BUFFER_LENGTH);
  99         }
 100 
 101         while (len > 0) {
 102             if (buf == null) {
 103                 try {
 104                     buf = new byte[BUFFER_LENGTH];
 105                 } catch (OutOfMemoryError e) {
 106                     throw new IOException("No memory left for cache!");
 107                 }
 108                 offset = 0;
 109             }
 110 
 111             int left = BUFFER_LENGTH - offset;
 112             int nbytes = (int)Math.min(len, (long)left);
 113             nbytes = stream.read(buf, offset, nbytes);
 114             if (nbytes == -1) {
 115                 return length; // EOF
 116             }
 117 
 118             if (offset == 0) {
 119                 cache.add(buf);
 120             }
 121 
 122             len -= nbytes;
 123             length += nbytes;
 124             offset += nbytes;
 125 
 126             if (offset >= BUFFER_LENGTH) {
 127                 // we've filled the current buffer, so a new one will be
 128                 // allocated next time around (and offset will be reset to 0)
 129                 buf = null;
 130             }
 131         }
 132 
 133         return pos;
 134     }
 135 
 136     /**
 137      * Writes out a portion of the cache to an <code>OutputStream</code>.
 138      * This method preserves no state about the output stream, and does
 139      * not dispose of any blocks containing bytes written.  To dispose
 140      * blocks, use {@link #disposeBefore <code>disposeBefore()</code>}.
 141      *
 142      * @exception IndexOutOfBoundsException if any portion of
 143      * the requested data is not in the cache (including if <code>pos</code>
 144      * is in a block already disposed), or if either <code>pos</code> or
 145      * <code>len</code> is < 0.


 146      */
 147     public void writeToStream(OutputStream stream, long pos, long len)
 148         throws IOException {
 149         if (pos + len > length) {
 150             throw new IndexOutOfBoundsException("Argument out of cache");
 151         }
 152         if ((pos < 0) || (len < 0)) {
 153             throw new IndexOutOfBoundsException("Negative pos or len");
 154         }
 155         if (len == 0) {
 156             return;
 157         }
 158 
 159         long bufIndex = pos/BUFFER_LENGTH;
 160         if (bufIndex < cacheStart) {
 161             throw new IndexOutOfBoundsException("pos already disposed");
 162         }
 163         int offset = (int)(pos % BUFFER_LENGTH);
 164 
 165         byte[] buf = getCacheBlock(bufIndex++);
 166         while (len > 0) {
 167             if (buf == null) {
 168                 buf = getCacheBlock(bufIndex++);
 169                 offset = 0;
 170             }
 171             int nbytes = (int)Math.min(len, (long)(BUFFER_LENGTH - offset));
 172             stream.write(buf, offset, nbytes);
 173             buf = null;
 174             len -= nbytes;
 175         }
 176     }
 177 
 178     /**
 179      * Ensure that there is space to write a byte at the given position.


 180      */
 181     private void pad(long pos) throws IOException {
 182         long currIndex = cacheStart + cache.size() - 1;
 183         long lastIndex = pos/BUFFER_LENGTH;
 184         long numNewBuffers = lastIndex - currIndex;
 185         for (long i = 0; i < numNewBuffers; i++) {
 186             try {
 187                 cache.add(new byte[BUFFER_LENGTH]);
 188             } catch (OutOfMemoryError e) {
 189                 throw new IOException("No memory left for cache!");
 190             }
 191         }
 192     }
 193 
 194     /**
 195      * Overwrites and/or appends the cache from a byte array.
 196      * The length of the cache will be extended as needed to hold
 197      * the incoming data.
 198      *
 199      * @param b an array of bytes containing data to be written.
 200      * @param off the starting offset withing the data array.
 201      * @param len the number of bytes to be written.
 202      * @param pos the cache position at which to begin writing.
 203      *
 204      * @exception NullPointerException if <code>b</code> is <code>null</code>.
 205      * @exception IndexOutOfBoundsException if <code>off</code>,
 206      * <code>len</code>, or <code>pos</code> are negative,
 207      * or if <code>off+len > b.length</code>.

 208      */
 209     public void write(byte[] b, int off, int len, long pos)
 210         throws IOException {
 211         if (b == null) {
 212             throw new NullPointerException("b == null!");
 213         }
 214         // Fix 4430357 - if off + len < 0, overflow occurred
 215         if ((off < 0) || (len < 0) || (pos < 0) ||
 216             (off + len > b.length) || (off + len < 0)) {
 217             throw new IndexOutOfBoundsException();
 218         }
 219 
 220         // Ensure there is space for the incoming data
 221         long lastPos = pos + len - 1;
 222         if (lastPos >= length) {
 223             pad(lastPos);
 224             length = lastPos + 1;
 225         }
 226 
 227         // Copy the data into the cache, block by block
 228         int offset = (int)(pos % BUFFER_LENGTH);
 229         while (len > 0) {
 230             byte[] buf = getCacheBlock(pos/BUFFER_LENGTH);
 231             int nbytes = Math.min(len, BUFFER_LENGTH - offset);
 232             System.arraycopy(b, off, buf, offset, nbytes);
 233 
 234             pos += nbytes;
 235             off += nbytes;
 236             len -= nbytes;
 237             offset = 0; // Always after the first time
 238         }
 239     }
 240 
 241     /**
 242      * Overwrites or appends a single byte to the cache.
 243      * The length of the cache will be extended as needed to hold
 244      * the incoming data.
 245      *
 246      * @param b an <code>int</code> whose 8 least significant bits
 247      * will be written.
 248      * @param pos the cache position at which to begin writing.
 249      *
 250      * @exception IndexOutOfBoundsException if <code>pos</code> is negative.

 251      */
 252     public void write(int b, long pos) throws IOException {
 253         if (pos < 0) {
 254             throw new ArrayIndexOutOfBoundsException("pos < 0");
 255         }
 256 
 257         // Ensure there is space for the incoming data
 258         if (pos >= length) {
 259             pad(pos);
 260             length = pos + 1;
 261         }
 262 
 263         // Insert the data.
 264         byte[] buf = getCacheBlock(pos/BUFFER_LENGTH);
 265         int offset = (int)(pos % BUFFER_LENGTH);
 266         buf[offset] = (byte)b;
 267     }
 268 
 269     /**
 270      * Returns the total length of data that has been cached,
 271      * regardless of whether any early blocks have been disposed.
 272      * This value will only ever increase.
 273      */
 274     public long getLength() {
 275         return length;
 276     }
 277 
 278     /**
 279      * Returns the single byte at the given position, as an
 280      * <code>int</code>.  Returns -1 if this position has
 281      * not been cached or has been disposed.



 282      */
 283     public int read(long pos) throws IOException {
 284         if (pos >= length) {
 285             return -1;
 286         }
 287 
 288         byte[] buf = getCacheBlock(pos/BUFFER_LENGTH);
 289         if (buf == null) {
 290             return -1;
 291         }
 292 
 293         return buf[(int)(pos % BUFFER_LENGTH)] & 0xff;
 294     }
 295 
 296     /**
 297      * Copy <code>len</code> bytes from the cache, starting
 298      * at cache position <code>pos</code>, into the array
 299      * <code>b</code> at offset <code>off</code>.
 300      *
 301      * @exception NullPointerException if b is <code>null</code>
 302      * @exception IndexOutOfBoundsException if <code>off</code>,
 303      * <code>len</code> or <code>pos</code> are negative or if
 304      * <code>off + len > b.length</code> or if any portion of the
 305      * requested data is not in the cache (including if
 306      * <code>pos</code> is in a block that has already been disposed).


 307      */
 308     public void read(byte[] b, int off, int len, long pos)
 309         throws IOException {
 310         if (b == null) {
 311             throw new NullPointerException("b == null!");
 312         }
 313         // Fix 4430357 - if off + len < 0, overflow occurred
 314         if ((off < 0) || (len < 0) || (pos < 0) ||
 315             (off + len > b.length) || (off + len < 0)) {
 316             throw new IndexOutOfBoundsException();
 317         }
 318         if (pos + len > length) {
 319             throw new IndexOutOfBoundsException();
 320         }
 321 
 322         long index = pos/BUFFER_LENGTH;
 323         int offset = (int)pos % BUFFER_LENGTH;
 324         while (len > 0) {
 325             int nbytes = Math.min(len, BUFFER_LENGTH - offset);
 326             byte[] buf = getCacheBlock(index++);
 327             System.arraycopy(buf, offset, b, off, nbytes);
 328 
 329             len -= nbytes;
 330             off += nbytes;
 331             offset = 0; // Always after the first time
 332         }
 333     }
 334 
 335     /**
 336      * Free the blocks up to the position <code>pos</code>.
 337      * The byte at <code>pos</code> remains available.
 338      *
 339      * @exception IndexOutOfBoundsException if <code>pos</code>
 340      * is in a block that has already been disposed.
 341      */
 342     public void disposeBefore(long pos) {
 343         long index = pos/BUFFER_LENGTH;
 344         if (index < cacheStart) {
 345             throw new IndexOutOfBoundsException("pos already disposed");
 346         }
 347         long numBlocks = Math.min(index - cacheStart, cache.size());
 348         for (long i = 0; i < numBlocks; i++) {
 349             cache.remove(0);
 350         }
 351         this.cacheStart = index;
 352     }
 353 
 354     /**
 355      * Erase the entire cache contents and reset the length to 0.
 356      * The cache object may subsequently be reused as though it had just
 357      * been allocated.
 358      */
 359     public void reset() {
 360         cache.clear();
 361         cacheStart = 0;
 362         length = 0L;
 363     }
 364  }
--- EOF ---