vpdf/poppler/poppler/CachedFile.cc

   1 //========================================================================
   2 //
   3 // CachedFile.cc
   4 //
   5 // This file is licensed under the GPLv2 or later
   6 //
   7 // Copyright 2009 Stefan Thomas <thomas@eload24.com>
   8 // Copyright 2010, 2011 Hib Eris <hib@hiberis.nl>
   9 // Copyright 2010 Albert Astals Cid <aacid@kde.org>
  10 //
  11 //========================================================================
  12
  13 #include <config.h>
  14 #include "CachedFile.h"
  15
  16 //------------------------------------------------------------------------
  17 // CachedFile
  18 //------------------------------------------------------------------------
  19
  20 CachedFile::CachedFile(CachedFileLoader *cachedFileLoaderA, GooString *uriA)
  21 {
  22   uri = uriA;
  23   loader = cachedFileLoaderA;
  24
  25   streamPos = 0;
  26   chunks = new std::vector<Chunk>();
  27   length = 0;
  28
  29   length = loader->init(uri, this);
  30   refCnt = 1;
  31
  32   if (length != ((size_t) -1)) {
  33     chunks->resize(length/CachedFileChunkSize + 1);
  34   }
  35   else {
  36     error(-1, "Failed to initialize file cache for '%s'.", uri->getCString());
  37     chunks->resize(0);
  38   }
  39 }
  40
  41 CachedFile::~CachedFile()
  42 {
  43   delete uri;
  44   delete loader;
  45   delete chunks;
  46 }
  47
  48 void CachedFile::incRefCnt() {
  49   refCnt++;
  50 }
  51
  52 void CachedFile::decRefCnt() {
  53   if (--refCnt == 0)
  54     delete this;
  55 }
  56
  57 long int CachedFile::tell() {
  58   return streamPos;
  59 }
  60
  61 int CachedFile::seek(long int offset, int origin)
  62 {
  63   if (origin == SEEK_SET) {
  64     streamPos = offset;
  65   } else if (origin == SEEK_CUR) {
  66     streamPos += offset;
  67   } else {
  68     streamPos = length + offset;
  69   }
  70
  71   if (streamPos > length) {
  72     streamPos = 0;
  73     return 1;
  74   }
  75
  76   return 0;
  77 }
  78
  79 int CachedFile::cache(const std::vector<ByteRange> &origRanges)
  80 {
  81   std::vector<int> loadChunks;
  82   int numChunks = length/CachedFileChunkSize + 1;
  83   std::vector<bool> chunkNeeded(numChunks);
  84   int startChunk, endChunk;
  85   std::vector<ByteRange> chunk_ranges, all;
  86   ByteRange range;
  87   const std::vector<ByteRange> *ranges = &origRanges;
  88
  89   if (ranges->empty()) {
  90     range.offset = 0;
  91     range.length = length;
  92     all.push_back(range);
  93     ranges = &all;
  94   }
  95
  96   for (int i = 0; i < numChunks; ++i)
  97     chunkNeeded[i] = false;
  98   for (size_t i = 0; i < ranges->size(); i++) {
  99
 100     if ((*ranges)[i].length == 0) continue;
 101     if ((*ranges)[i].offset >= length) continue;
 102
 103     size_t start = (*ranges)[i].offset;
 104     size_t end = start + (*ranges)[i].length - 1;
 105     if (end >= length) end = length - 1;
 106
 107     startChunk = start / CachedFileChunkSize;
 108     endChunk = end / CachedFileChunkSize;
 109     for (int chunk = startChunk; chunk <= endChunk; chunk++) {
 110       if ((*chunks)[chunk].state == chunkStateNew) {
 111            chunkNeeded[chunk] = true;
 112       }
 113     }
 114   }
 115
 116   int chunk = 0;
 117   while (chunk < numChunks) {
 118     while (!chunkNeeded[chunk] && (++chunk != numChunks)) ;
 119     if (chunk == numChunks) break;
 120     startChunk = chunk;
 121     loadChunks.push_back(chunk);
 122
 123     while ((++chunk != numChunks) && chunkNeeded[chunk]) {
 124       loadChunks.push_back(chunk);
 125     }
 126     endChunk = chunk - 1;
 127
 128     range.offset = startChunk * CachedFileChunkSize;
 129     range.length = (endChunk - startChunk + 1) * CachedFileChunkSize;
 130
 131     chunk_ranges.push_back(range);
 132   }
 133
 134   if (chunk_ranges.size() > 0) {
 135     CachedFileWriter writer =
 136         CachedFileWriter(this, &loadChunks);
 137     return loader->load(chunk_ranges, &writer);
 138   }
 139
 140   return 0;
 141 }
 142
 143 size_t CachedFile::read(void *ptr, size_t unitsize, size_t count)
 144 {
 145   size_t bytes = unitsize*count;
 146   if (length < (streamPos + bytes)) {
 147     bytes = length - streamPos;
 148   }
 149
 150   if (bytes == 0) return 0;
 151
 152   // Load data
 153   if (cache(streamPos, bytes) != 0) return 0;
 154
 155   // Copy data to buffer
 156   size_t toCopy = bytes;
 157   while (toCopy) {
 158     int chunk = streamPos / CachedFileChunkSize;
 159     int offset = streamPos % CachedFileChunkSize;
 160     size_t len = CachedFileChunkSize-offset;
 161
 162     if (len > toCopy)
 163       len = toCopy;
 164
 165     memcpy(ptr, (*chunks)[chunk].data + offset, len);
 166     streamPos += len;
 167     toCopy -= len;
 168     ptr = (char*)ptr + len;
 169   }
 170
 171   return bytes;
 172 }
 173
 174 int CachedFile::cache(size_t offset, size_t length)
 175 {
 176   std::vector<ByteRange> r;
 177   ByteRange range;
 178   range.offset = offset;
 179   range.length = length;
 180   r.push_back(range);
 181   return cache(r);
 182 }
 183
 184 //------------------------------------------------------------------------
 185 // CachedFileWriter
 186 //------------------------------------------------------------------------
 187
 188 CachedFileWriter::CachedFileWriter(CachedFile *cachedFileA, std::vector<int> *chunksA)
 189 {
 190    cachedFile = cachedFileA;
 191    chunks = chunksA;
 192
 193    if (chunks) {
 194      offset = 0;
 195      it = (*chunks).begin();
 196    }
 197 }
 198
 199 CachedFileWriter::~CachedFileWriter()
 200 {
 201 }
 202
 203 size_t CachedFileWriter::write(const char *ptr, size_t size)
 204 {
 205   const char *cp = ptr;
 206   size_t len = size;
 207   size_t nfree, ncopy;
 208   size_t written = 0;
 209   size_t chunk;
 210
 211   if (!len) return 0;
 212
 213   while (len) {
 214     if (chunks) {
 215       if (offset == CachedFileChunkSize) {
 216          it++;
 217          if (it == (*chunks).end()) return written;
 218          offset = 0;
 219       }
 220       chunk = *it;
 221     } else {
 222       offset = cachedFile->length % CachedFileChunkSize;
 223       chunk = cachedFile->length / CachedFileChunkSize;
 224     }
 225
 226     if (chunk >= cachedFile->chunks->size()) {
 227        cachedFile->chunks->resize(chunk + 1);
 228     }
 229
 230     nfree = CachedFileChunkSize - offset;
 231     ncopy = (len >= nfree) ? nfree : len;
 232     memcpy(&((*cachedFile->chunks)[chunk].data[offset]), cp, ncopy);
 233     len -= ncopy;
 234     cp += ncopy;
 235     offset += ncopy;
 236     written += ncopy;
 237
 238     if (!chunks) {
 239       cachedFile->length += ncopy;
 240     }
 241
 242     if (offset == CachedFileChunkSize) {
 243        (*cachedFile->chunks)[chunk].state = CachedFile::chunkStateLoaded;
 244     }
 245   }
 246
 247   if ((chunk == (cachedFile->length / CachedFileChunkSize)) &&
 248       (offset == (cachedFile->length % CachedFileChunkSize))) {
 249      (*cachedFile->chunks)[chunk].state = CachedFile::chunkStateLoaded;
 250   }
 251
 252   return written;
 253 }
 254
 255 //------------------------------------------------------------------------
 256