From e2970992fd5ce9e6df3ba8700c6593ae67fed0bf Mon Sep 17 00:00:00 2001 From: janwas Date: Wed, 18 Aug 2004 02:11:50 +0000 Subject: [PATCH] fix FileIO type; also new transfer mode for uncompressed files that allows using the file cache (HACK!) This was SVN commit r1016. --- source/lib/res/zip.cpp | 74 +++++++++++++++++++++++++++++++++++------- source/lib/res/zip.h | 8 +++-- 2 files changed, 69 insertions(+), 13 deletions(-) diff --git a/source/lib/res/zip.cpp b/source/lib/res/zip.cpp index 4399f16040..f603acc67f 100755 --- a/source/lib/res/zip.cpp +++ b/source/lib/res/zip.cpp @@ -719,7 +719,7 @@ int inf_set_dest(uintptr_t ctx, void* out, size_t out_size) // unzip into output buffer. returns bytes written // (may be 0, if not enough data is passed in), or < 0 on error. -ssize_t inf_inflate(uintptr_t ctx, void* in, size_t in_size) +ssize_t inf_inflate(uintptr_t ctx, bool compressed, void* in, size_t in_size) { #ifdef NO_ZLIB return -1; @@ -732,7 +732,21 @@ ssize_t inf_inflate(uintptr_t ctx, void* in, size_t in_size) stream->avail_in = (uInt)in_size; stream->next_in = (Byte*)in; - int err = inflate(stream, Z_SYNC_FLUSH); + + int err = 0; + + if(compressed) + err = inflate(stream, Z_SYNC_FLUSH); + else + { + memcpy(stream->next_out, stream->next_in, stream->avail_in); + stream->avail_out -= stream->avail_in; + stream->avail_in = 0; + stream->next_in += stream->avail_in; + stream->next_out += stream->avail_in; + stream->total_in += stream->avail_in; + stream->total_out += stream->avail_in; + } // check+return how much actual data was read // @@ -922,7 +936,7 @@ int zip_open(const Handle ha, const char* fn, ZFile* zf) zf->csize = loc.csize; zf->ha = ha; - zf->inf_ctx = inf_init_ctx(); + zf->inf_ctx = inf_init_ctx(); } invalid_zf: @@ -952,6 +966,7 @@ int zip_close(ZFile* zf) struct IOCBParams { uintptr_t inf_ctx; + bool compressed; FileIOCB user_cb; uintptr_t user_ctx; @@ -962,7 +977,7 @@ static ssize_t io_cb(uintptr_t ctx, void* buf, size_t size) { IOCBParams* p = (IOCBParams*)ctx; - ssize_t ret = inf_inflate(p->inf_ctx, buf, size); + ssize_t ret = inf_inflate(p->inf_ctx, p->compressed, buf, size); if(p->user_cb) return p->user_cb(p->user_ctx, buf, size); @@ -970,6 +985,7 @@ static ssize_t io_cb(uintptr_t ctx, void* buf, size_t size) return ret; } +#include "timer.h" // note: we go to a bit of trouble to make sure the buffer we allocated // (if p == 0) is freed when the read fails. @@ -977,6 +993,8 @@ ssize_t zip_read(ZFile* zf, off_t raw_ofs, size_t size, void** p, FileIOCB cb, u { CHECK_ZFILE(zf); + const bool compressed = zfile_compressed(zf); + ssize_t err = -1; ssize_t raw_bytes_read; @@ -988,8 +1006,8 @@ ssize_t zip_read(ZFile* zf, off_t raw_ofs, size_t size, void** p, FileIOCB cb, u // not compressed - just pass it on to file_io // (avoid the Zip inflate start/finish stuff below) - if(!zfile_compressed(zf)) - return file_io(&za->f, ofs, size, p); +// if(!compressed) +// return file_io(&za->f, ofs, size, p); // no need to set last_raw_ofs - only checked if compressed. // compressed @@ -1035,12 +1053,38 @@ fail: return err; } - const IOCBParams params = { zf->inf_ctx, cb, ctx }; +/* +static bool once = false; +if(!once) +{ + +once=true; +uintptr_t xctx = inf_init_ctx(); +size_t xsize = za->f.size; +void* xbuf=mem_alloc(xsize, 65536); +inf_set_dest(xctx, xbuf, xsize); +const IOCBParams xparams = { xctx, false, 0, 0 }; +double t1 = get_time(); +file_io(&za->f,0, xsize, 0, io_cb, (uintptr_t)&xparams); +double t2 = get_time(); +debug_out("\n\ntime to load whole archive %f\nthroughput %f MB/s\n", t2-t1, xsize / (t2-t1) / 1e6); +mem_free(xbuf); +} +*/ + + const IOCBParams params = { zf->inf_ctx, compressed, cb, ctx }; // read blocks from the archive's file starting at ofs and pass them to // inf_inflate, until all compressed data has been read, or it indicates // the desired output amount has been reached. - const size_t raw_size = zf->csize; + size_t raw_size = zf->csize; + +// we set csize to 0 to indicate the file isn't compressed. +// see zfile_compressed implementation. +if(!compressed) +raw_size = zf->ucsize; + + raw_bytes_read = file_io(&za->f, ofs, raw_size, (void**)0, io_cb, (uintptr_t)¶ms); zf->last_raw_ofs = raw_ofs + (off_t)raw_bytes_read; @@ -1064,7 +1108,7 @@ fail: // rationale for not supporting aio for compressed files: // would complicate things considerably (could no longer just -// return the file I/O handle, since we have to decompress in wait_io), +// return the file I/O context, since we have to decompress in wait_io), // yet it isn't really useful - aio is used to stream music, // which is already compressed. @@ -1085,16 +1129,24 @@ int zip_start_io(ZFile* const zf, off_t ofs, size_t size, void* buf, FileIO* io) } +// indicates if the IO referenced by has completed. +// return value: 0 if pending, 1 if complete, < 0 on error. +inline int zip_io_complete(FileIO io) +{ + return file_io_complete(io); +} + + // wait until the transfer completes, and return its buffer. // output parameters are zeroed on error. -inline int zip_wait_io(FileIO* io, void*& p, size_t& size) +inline int zip_wait_io(FileIO io, void*& p, size_t& size) { return file_wait_io(io, p, size); } // finished with transfer - free its buffer (returned by vfs_wait_io) -inline int zip_discard_io(FileIO* io) +inline int zip_discard_io(FileIO io) { return file_discard_io(io); } diff --git a/source/lib/res/zip.h b/source/lib/res/zip.h index ecc6aeae1a..90ef3c9e72 100755 --- a/source/lib/res/zip.h +++ b/source/lib/res/zip.h @@ -108,12 +108,16 @@ extern int zip_unmap(ZFile* zf); // with zip_wait_io; when no longer needed, free via zip_discard_io. extern int zip_start_io(ZFile* const zf, off_t ofs, size_t size, void* buf, FileIO* io); +// indicates if the IO referenced by has completed. +// return value: 0 if pending, 1 if complete, < 0 on error. +extern int zip_io_complete(FileIO io); + // wait until the transfer completes, and return its buffer. // output parameters are zeroed on error. -extern int zip_wait_io(FileIO* io, void*& p, size_t& size); +extern int zip_wait_io(FileIO io, void*& p, size_t& size); // finished with transfer - free its buffer (returned by vfs_wait_io) -extern int zip_discard_io(FileIO* io); +extern int zip_discard_io(FileIO io); //