Ticket #1981: smush-file-cache.diff

File smush-file-cache.diff, 7.0 KB (added by eriktorbjorn, 17 years ago)

Patch against a June 22 CVS snapshot

  • scumm/smush/chunk.cpp

    diff -ur --exclude=CVS ScummVM/scumm/smush/chunk.cpp ScummVM+hack/scumm/smush/chunk.cpp
    old new  
    2121
    2222#include "stdafx.h"
    2323#include "scumm/smush/chunk.h"
     24#include "scumm/smush/smush_player.h"
    2425#include "scumm/scumm.h"
    2526
    2627#include "common/file.h"
     
    8586        return true;
    8687}
    8788
    88 FileChunk::FileChunk(const Common::String &name, int offset)
    89         : _name(name) {
    90         if (!g_scumm->openFile(_data, name.c_str()))
     89FileChunk::FileChunk(SmushPlayer *player, const Common::String &name, int offset)
     90        : _player(player), _name(name) {
     91        _data = _player->openFile(name.c_str());
     92        if (!_data)
    9193                error("FileChunk: Unable to open file %s", name.c_str());
    9294
    93         _data.seek(offset);
    94         _type = _data.readUint32BE();
    95         _size = _data.readUint32BE();
    96         _offset = _data.pos();
     95        _data->seek(offset);
     96        _type = _data->readUint32BE();
     97        _size = _data->readUint32BE();
     98        _offset = _data->pos();
    9799        _curPos = 0;
    98100}
    99101
     
    101103}
    102104
    103105Chunk *FileChunk::subBlock() {
    104         FileChunk *ptr = new FileChunk(_name, _offset + _curPos);
    105         _data.seek(_offset + _curPos + sizeof(Chunk::type) + sizeof(uint32));
     106        FileChunk *ptr = new FileChunk(_player, _name, _offset + _curPos);
     107        _data->seek(_offset + _curPos + sizeof(Chunk::type) + sizeof(uint32));
    106108        seek(sizeof(Chunk::type) + sizeof(uint32) + ptr->getSize());
    107109        return ptr;
    108110}
     
    111113        if (size <= 0 || (_curPos + size) > _size)
    112114                error("invalid buffer read request");
    113115
    114 //      _data.seek(_offset + _curPos);
    115         _data.read(buffer, size);
     116//      _data->seek(_offset + _curPos);
     117        _data->read(buffer, size);
    116118        _curPos += size;
    117119        return true;
    118120}
     
    122124}
    123125
    124126byte FileChunk::getByte() {
    125 //      _data.seek(_offset + _curPos);
     127//      _data->seek(_offset + _curPos);
    126128        _curPos++;
    127129
    128130        if (_curPos > _size)
    129131                error("invalid byte read request");
    130132
    131         return _data.readByte();
     133        return _data->readByte();
    132134}
    133135
    134136int16 FileChunk::getShort() {
     
    136138}
    137139
    138140uint16 FileChunk::getWord() {
    139 //      _data.seek(_offset + _curPos);
     141//      _data->seek(_offset + _curPos);
    140142        _curPos += 2;
    141143
    142144        if (_curPos > _size)
    143145                error("invalid word read request");
    144146
    145         return _data.readUint16LE();
     147        return _data->readUint16LE();
    146148}
    147149
    148150uint32 FileChunk::getDword() {
    149 //      _data.seek(_offset + _curPos);
     151//      _data->seek(_offset + _curPos);
    150152        _curPos += 4;
    151153
    152154        if (_curPos > _size)
    153155                error("invalid dword read request");
    154156
    155         return _data.readUint32LE();
     157        return _data->readUint32LE();
    156158}
    157159
    158160MemoryChunk::MemoryChunk(byte *data) {
  • scumm/smush/chunk.h

    diff -ur --exclude=CVS ScummVM/scumm/smush/chunk.h ScummVM+hack/scumm/smush/chunk.h
    old new  
    2929namespace Scumm {
    3030
    3131class ScummFile;
     32class SmushPlayer;
    3233
    3334class Chunk {
    3435public:
     
    6970
    7071class FileChunk : public BaseChunk {
    7172private:
     73        SmushPlayer *_player;
    7274        Common::String _name;
    73         ScummFile _data;
     75        ScummFile *_data;
    7476        uint32 _offset;
    7577
    7678public:
    77         FileChunk(const Common::String &name, int offset = 0);
     79        FileChunk(SmushPlayer *player, const Common::String &name, int offset = 0);
    7880        virtual ~FileChunk();
    7981        Chunk *subBlock();
    8082        bool read(void *buffer, uint32 size);
  • scumm/smush/smush_player.cpp

    diff -ur --exclude=CVS ScummVM/scumm/smush/smush_player.cpp ScummVM+hack/scumm/smush/smush_player.cpp
    old new  
    174174        }
    175175};
    176176
    177 static StringResource *getStrings(ScummEngine *vm, const char *file, bool is_encoded) {
    178         debugC(DEBUG_SMUSH, "trying to read text ressources from %s", file);
    179         ScummFile theFile;
     177static StringResource *getStrings(SmushPlayer *player, const char *file, bool is_encoded) {
     178        debugC(DEBUG_SMUSH, "trying to read text resources from %s", file);
     179        ScummFile *theFile;
    180180
    181         vm->openFile(theFile, file);
    182         if (!theFile.isOpen()) {
     181        theFile = player->openFile(file);
     182        if (!theFile) {
    183183                return 0;
    184184        }
    185         int32 length = theFile.size();
     185        int32 length = theFile->size();
    186186        char *filebuffer = new char [length + 1];
    187187        assert(filebuffer);
    188         theFile.read(filebuffer, length);
     188        theFile->read(filebuffer, length);
    189189        filebuffer[length] = 0;
    190190
    191191        if (is_encoded) {
     
    197197
    198198                if (type != TYPE_ETRS) {
    199199                        delete [] filebuffer;
    200                         return getStrings(vm, file, false);
     200                        return getStrings(player, file, false);
    201201                }
    202202
    203203                char *old = filebuffer;
     
    265265        release();
    266266}
    267267
     268ScummFile *SmushPlayer::openFile(const char *filename) {
     269        for (FileList::iterator f = _fileList.begin(); f != _fileList.end(); f++) {
     270                if (scumm_stricmp(filename, f->name()) == 0) {
     271                        return f;
     272                }
     273        }
     274
     275        ScummFile *file = new ScummFile;
     276
     277        if (!_vm->openFile(*file, filename)) {
     278                delete file;
     279                return NULL;
     280        }
     281
     282        _fileList.push_back(*file);
     283        return file;
     284}
     285
    268286void SmushPlayer::init() {
    269287        _frame = 0;
    270288        _alreadyInit = false;
     
    340358        // some explanation.
    341359        _vm->virtscr[0].pitch = _origPitch;
    342360        _vm->gdi._numStrips = _origNumStrips;
    343        
     361
     362        for (FileList::iterator f = _fileList.begin(); f != _fileList.end(); f++) {
     363                f->close();
     364        }
     365
     366        _fileList.clear();
    344367       
    345368        _initDone = false;
    346369}
     
    661684        char fname[260];
    662685        memcpy(fname, file, i - file);
    663686        strcpy(fname + (i - file), ".trs");
    664         if ((_strings = getStrings(_vm, fname, false)) != 0) {
     687        if ((_strings = getStrings(this, fname, false)) != 0) {
    665688                return true;
    666689        }
    667690
    668         if ((_strings = getStrings(_vm, "digtxt.trs", true)) != 0) {
     691        if ((_strings = getStrings(this, "digtxt.trs", true)) != 0) {
    669692                return true;
    670693        }
    671694        return false;
     
    9861009        int i;
    9871010        char file_font[11];
    9881011
    989         _base = new FileChunk(file);
     1012        _base = new FileChunk(this, file);
    9901013        sub = _base->subBlock();
    9911014        checkBlock(*sub, TYPE_AHDR);
    9921015        handleAnimHeader(*sub);
     
    11621185                        delete _base;
    11631186                }
    11641187
    1165                 _base = new FileChunk(file);
     1188                _base = new FileChunk(this, file);
    11661189                if (pos) {
    11671190                        assert(pos != 8);
    11681191                        // In this case we need to get palette and number of frames
     
    12261249void SmushPlayer::play(const char *filename, int32 offset, int32 startFrame) {
    12271250
    12281251        // Verify the specified file exists
    1229         ScummFile f;
    1230         _vm->openFile(f, filename);
    1231         if (!f.isOpen()) {
     1252        if (!openFile(filename)) {
    12321253                warning("SmushPlayer::play() File not found %s", filename);
    12331254                return;
    12341255        }
    1235         f.close();
    12361256
    12371257        tryCmpFile(filename);
    12381258
  • scumm/smush/smush_player.h

    diff -ur --exclude=CVS ScummVM/scumm/smush/smush_player.h ScummVM+hack/scumm/smush/smush_player.h
    old new  
    3838class SmushPlayer {
    3939        friend class Insane;
    4040private:
     41        typedef Common::Array<ScummFile> FileList;
     42        FileList _fileList;
    4143        ScummEngine_v6 *_vm;
    4244        int _version;
    4345        int32 _nbframes;
     
    9496
    9597        void play(const char *filename, int32 offset = 0, int32 startFrame = 0);
    9698        void warpMouse(int x, int y, int buttons);
     99        ScummFile *openFile(const char *filename);
    97100
    98101protected:
    99102        SmushFont *_sf[5];