Home | History | Annotate | Download | only in util
      1 /*
      2  * Copyright (C) 2014 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 package com.android.tv.settings.util;
     18 
     19 import java.io.FilterInputStream;
     20 import java.io.IOException;
     21 import java.io.InputStream;
     22 import java.util.ArrayList;
     23 import java.util.List;
     24 
     25 /**
     26  * A replacement of BufferedInputStream (no multiple thread): <p>
     27  * - use list of byte array (chunks) instead of keep growing a single byte array (more efficent)
     28  *   <br>
     29  * - support overriding the markLimit passed in mark() call (The value that BitmapFactory
     30  *   uses 1024 is too small for detecting bitmap bounds and reset()) <br>
     31  */
     32 public class CachedInputStream extends FilterInputStream {
     33 
     34     private static final int CHUNK_SIZE = ByteArrayPool.CHUNK16K;
     35 
     36     private ArrayList<byte[]> mBufs = new ArrayList<byte[]>();
     37     private int mPos = 0;  // current read position inside the chunk buffers
     38     private int mCount = 0; // total validate bytes in chunk buffers
     39     private int mMarkPos = -1; // marked read position in chunk buffers
     40     private int mOverrideMarkLimit; // to override readlimit of mark() call
     41     private int mMarkLimit; // effective marklimit
     42     private byte[] tmp = new byte[1]; // tmp buffer used in read()
     43 
     44     public CachedInputStream(InputStream in) {
     45         super(in);
     46     }
     47 
     48     @Override
     49     public boolean markSupported() {
     50         return true;
     51     }
     52 
     53     /**
     54      * set the value that will override small readlimit passed in mark() call.
     55      */
     56     public void setOverrideMarkLimit(int overrideMarkLimit) {
     57         mOverrideMarkLimit = overrideMarkLimit;
     58     }
     59 
     60     public int getOverrideMarkLimit() {
     61         return mOverrideMarkLimit;
     62     }
     63 
     64     @Override
     65     public void mark(int readlimit) {
     66         readlimit = readlimit < mOverrideMarkLimit ? mOverrideMarkLimit : readlimit;
     67         if (mMarkPos >= 0) {
     68             // for replacing existing mark(), discard anything before mPos
     69             // and move mMarkPos to mPos
     70             int chunks = mPos / CHUNK_SIZE;
     71             if (chunks > 0) {
     72                 // trim the header buffers
     73                 int removedBytes = chunks * CHUNK_SIZE;
     74                 List<byte[]> subList = mBufs.subList(0, chunks);
     75                 releaseChunks(subList);
     76                 subList.clear();
     77                 mPos = mPos - removedBytes;
     78                 mCount = mCount - removedBytes;
     79             }
     80         }
     81         mMarkPos = mPos;
     82         mMarkLimit = readlimit;
     83     }
     84 
     85     @Override
     86     public void reset() throws IOException {
     87         if (mMarkPos < 0) {
     88             throw new IOException("mark has been invalidated");
     89         }
     90         mPos = mMarkPos;
     91     }
     92 
     93     @Override
     94     public int read() throws IOException {
     95         // TODO, not efficient, but the function is not called by BitmapFactory
     96         int r = read(tmp, 0, 1);
     97         if (r <= 0) {
     98             return -1;
     99         }
    100         return tmp[0] & 0xFF;
    101     }
    102 
    103     @Override
    104     public void close() throws IOException {
    105         if (in!=null) {
    106             in.close();
    107             in = null;
    108         }
    109         releaseChunks(mBufs);
    110     }
    111 
    112     private static void releaseChunks(List<byte[]> bufs) {
    113         ByteArrayPool.get16KBPool().releaseChunks(bufs);
    114     }
    115 
    116     private byte[] allocateChunk() {
    117         return ByteArrayPool.get16KBPool().allocateChunk();
    118     }
    119 
    120     private boolean invalidate() {
    121         if (mCount - mMarkPos > mMarkLimit) {
    122             mMarkPos = -1;
    123             mCount = 0;
    124             mPos = 0;
    125             releaseChunks(mBufs);
    126             mBufs.clear();
    127             return true;
    128         }
    129         return false;
    130     }
    131 
    132     @Override
    133     public int read(byte[] buffer, int offset, int count) throws IOException {
    134         if (in == null) {
    135             throw streamClosed();
    136         }
    137         if (mMarkPos == -1) {
    138             int reads = in.read(buffer, offset, count);
    139             return reads;
    140         }
    141         if (count == 0) {
    142             return 0;
    143         }
    144         int copied = copyMarkedBuffer(buffer, offset, count);
    145         count -= copied;
    146         offset += copied;
    147         int totalReads = copied;
    148         while (count > 0) {
    149             if (mPos == mBufs.size() * CHUNK_SIZE) {
    150                 mBufs.add(allocateChunk());
    151             }
    152             int currentBuf = mPos / CHUNK_SIZE;
    153             int indexInBuf = mPos - currentBuf * CHUNK_SIZE;
    154             byte[] buf = mBufs.get(currentBuf);
    155             int end = (currentBuf + 1) * CHUNK_SIZE;
    156             int leftInBuffer = end - mPos;
    157             int toRead = count > leftInBuffer ? leftInBuffer : count;
    158             int reads = in.read(buf, indexInBuf, toRead);
    159             if (reads > 0) {
    160                 System.arraycopy(buf, indexInBuf, buffer, offset, reads);
    161                 mPos += reads;
    162                 mCount += reads;
    163                 totalReads += reads;
    164                 offset += reads;
    165                 count -= reads;
    166                 if (invalidate()) {
    167                     reads = in.read(buffer, offset, count);
    168                     if (reads >0 ) {
    169                         totalReads += reads;
    170                     }
    171                     break;
    172                 }
    173             } else {
    174                 break;
    175             }
    176         }
    177         if (totalReads == 0) {
    178             return -1;
    179         }
    180         return totalReads;
    181     }
    182 
    183     private int copyMarkedBuffer(byte[] buffer, int offset, int read) {
    184         int totalRead = 0;
    185         while (read > 0 && mPos < mCount) {
    186             int currentBuf = mPos / CHUNK_SIZE;
    187             int indexInBuf = mPos - currentBuf * CHUNK_SIZE;
    188             byte[] buf = mBufs.get(currentBuf);
    189             int end = (currentBuf + 1) * CHUNK_SIZE;
    190             if (end > mCount) {
    191                 end = mCount;
    192             }
    193             int leftInBuffer = end - mPos;
    194             int toRead = read > leftInBuffer ? leftInBuffer : read;
    195             System.arraycopy(buf, indexInBuf, buffer, offset, toRead);
    196             offset += toRead;
    197             read -= toRead;
    198             totalRead += toRead;
    199             mPos += toRead;
    200         }
    201         return totalRead;
    202     }
    203 
    204     @Override
    205     public int available() throws IOException {
    206         if (in == null) {
    207             throw streamClosed();
    208         }
    209         return mCount - mPos + in.available();
    210     }
    211 
    212     @Override
    213     public long skip(long byteCount) throws IOException {
    214         if (in == null) {
    215             throw streamClosed();
    216         }
    217         if (mMarkPos <0) {
    218             return in.skip(byteCount);
    219         }
    220         long totalSkip = 0;
    221         totalSkip = mCount - mPos;
    222         if (totalSkip > byteCount) {
    223             totalSkip = byteCount;
    224         }
    225         mPos += totalSkip;
    226         byteCount -= totalSkip;
    227         while (byteCount > 0) {
    228             if (mPos == mBufs.size() * CHUNK_SIZE) {
    229                 mBufs.add(allocateChunk());
    230             }
    231             int currentBuf = mPos / CHUNK_SIZE;
    232             int indexInBuf = mPos - currentBuf * CHUNK_SIZE;
    233             byte[] buf = mBufs.get(currentBuf);
    234             int end = (currentBuf + 1) * CHUNK_SIZE;
    235             int leftInBuffer = end - mPos;
    236             int toRead = (int) (byteCount > leftInBuffer ? leftInBuffer : byteCount);
    237             int reads = in.read(buf, indexInBuf, toRead);
    238             if (reads > 0) {
    239                 mPos += reads;
    240                 mCount += reads;
    241                 byteCount -= reads;
    242                 totalSkip += reads;
    243                 if (invalidate()) {
    244                     if (byteCount > 0) {
    245                         totalSkip += in.skip(byteCount);
    246                     }
    247                     break;
    248                 }
    249             } else {
    250                 break;
    251             }
    252         }
    253         return totalSkip;
    254     }
    255 
    256     private static IOException streamClosed() {
    257         return new IOException("stream closed");
    258     }
    259 
    260 }
    261