Ticket #9094: made_fixes.patch

File made_fixes.patch, 8.8 KB (added by agent-q, 15 years ago)

MADE engine fixes

  • engines/made/pmvplayer.cpp

     
    208208
    209209        //delete _audioStream;
    210210        delete _fd;
     211        _surface->free();
    211212        delete _surface;
    212213
    213214        return !_aborted;

  • engines/made/redreader.cpp

     
    4141
    4242        byte *fileBuf = (byte *)malloc(fileEntry.origSize);
    4343
    44         LzhDecompressor lzhDec;
    45         lzhDec.decompress(fd, fileBuf, fileEntry.compSize, fileEntry.origSize);
     44        LzhDecompressor* lzhDec = new LzhDecompressor();
     45        lzhDec->decompress(fd, fileBuf, fileEntry.compSize, fileEntry.origSize);
     46        delete lzhDec;
    4647
    4748        return new Common::MemoryReadStream(fileBuf, fileEntry.origSize, true);
    4849
    4950}
    5051
    5152Common::MemoryReadStream *RedReader::loadFromRed(const char *redFilename, const char *filename) {
    52         RedReader redReader;
    53         return redReader.load(redFilename, filename);
     53        RedReader* red = new RedReader();
     54        Common::MemoryReadStream* stream = red->load(redFilename, filename);
     55        delete red;
     56        return stream;
    5457}
    5558
    5659bool RedReader::seekFile(Common::File &fd, FileEntry &fileEntry, const char *filename) {
    … …  
    8285int LzhDecompressor::decompress(Common::SeekableReadStream &source, byte *dest, uint32 sourceLen, uint32 destLen) {
    8386
    8487        int bufsize;
    85         byte buffer[DICSIZ];
     88        byte* buffer;
    8689
     90        buffer = (byte *) malloc(DICSIZ);
     91
    8792        _source = &source;
    8893        _compSize = sourceLen;
    8994
    … …  
    100105                destLen -= bufsize;
    101106        }
    102107
     108        free(buffer);
     109
    103110        return 0;
    104111}
    105112

  • engines/made/resource.cpp

     
    4545
    4646PictureResource::~PictureResource() {
    4747        if (_picture) {
     48                _picture->free();
    4849                delete _picture;
    4950                _picture = 0;
    5051        }
    … …  
    183184}
    184185
    185186AnimationResource::~AnimationResource() {
    186         for (uint i = 0; i < _frames.size(); i++)
     187        for (uint i = 0; i < _frames.size(); i++) {
     188                _frames[i]->free();
    187189                delete _frames[i];
     190        }
    188191}
    189192
    190193void AnimationResource::load(byte *source, int size) {
    … …  
    373376
    374377ResourceReader::ResourceReader() {
    375378        _isV1 = false;
     379        _cacheDataSize = 0;
    376380}
    377381
    378382ResourceReader::~ResourceReader() {
    … …  
    543547}
    544548
    545549void ResourceReader::addResourceToCache(ResourceSlot *slot, Resource *res) {
    546         if (_cacheCount >= kMaxResourceCacheCount)
     550        _cacheDataSize += slot->size;
     551
     552        if (_cacheDataSize >= kMaxResourceCacheSize) {
    547553                purgeCache();
     554        }
     555
    548556        slot->res = res;
    549557        slot->refCount = 1;
    550558        _cacheCount++;
    … …  
    562570                for (ResourceSlots::iterator slotIter = slots->begin(); slotIter != slots->end(); ++slotIter) {
    563571                        ResourceSlot *slot = &(*slotIter);
    564572                        if (slot->refCount <= 0 && slot->res) {
     573                                _cacheDataSize -= slot->size;
    565574                                delete slot->res;
    566575                                slot->res = NULL;
    567576                                slot->refCount = 0;
    568577                                _cacheCount--;
    569                         }
     578                        }                       
    570579                }
    571580        }
    572581}

  • engines/made/resource.h

     
    3737
    3838namespace Made {
    3939
    40 const int kMaxResourceCacheCount = 100;
     40/// This value specifies the size of the resource cache
     41/// which stores recently used resources.  On the DS,
     42/// 400Kb is all we can spare, while 1Mb seems like a
     43/// good value for larger systems.
     44#ifndef __DS__
     45const int kMaxResourceCacheSize = 1000 * 1024;
     46#else
     47const int kMaxResourceCacheSize = 400 * 1024;
     48#endif
    4149
     50
    4251enum ResourceType {
    4352        kResARCH = MKID_BE('ARCH'),
    4453        kResFREE = MKID_BE('FREE'),
    … …  
    6372class PictureResource : public Resource {
    6473public:
    6574        PictureResource();
    66         ~PictureResource();
     75        virtual ~PictureResource();
    6776        void load(byte *source, int size);
    6877        Graphics::Surface *getPicture() const { return _picture; }
    6978        byte *getPalette() const { return _picturePalette; }
    … …  
    8190class AnimationResource : public Resource {
    8291public:
    8392        AnimationResource();
    84         ~AnimationResource();
     93        virtual ~AnimationResource();
    8594        void load(byte *source, int size);
    8695        int getCount() const { return _frames.size(); }
    8796        Graphics::Surface *getFrame(int index) const {
    … …  
    117126class SoundResourceV1 : public SoundResource {
    118127public:
    119128        SoundResourceV1() {}
    120         ~SoundResourceV1() {}
     129        virtual ~SoundResourceV1() {}
    121130        void load(byte *source, int size);
    122131};
    123132
    124133class MenuResource : public Resource {
    125134public:
    126135        MenuResource();
    127         ~MenuResource();
     136        virtual ~MenuResource();
    128137        void load(byte *source, int size);
    129138        int getCount() const { return _strings.size(); }
    130139        const char *getString(uint index) const;
    … …  
    135144class FontResource : public Resource {
    136145public:
    137146        FontResource();
    138         ~FontResource();
     147        virtual ~FontResource();
    139148        void load(byte *source, int size);
    140149        int getHeight() const;
    141150        int getCharWidth(uint c) const;
    … …  
    150159class GenericResource : public Resource {
    151160public:
    152161        GenericResource();
    153         ~GenericResource();
     162        virtual ~GenericResource();
    154163        void load(byte *source, int size);
    155164        byte *getData() const { return _data; }
    156165        int getSize() const { return _size; }
    … …  
    200209
    201210        ResMap _resSlots;
    202211        int _cacheCount;
     212        int _cacheDataSize;
    203213
    204214        void loadIndex(ResourceSlots *slots);
    205215

  • engines/made/script.cpp

     
    3232#include "made/scriptfuncs.h"
    3333#include "made/screen.h"
    3434
     35
    3536namespace Made {
    3637
    3738/* ScriptInterpreter */
    3839
     40
    3941ScriptInterpreter::ScriptInterpreter(MadeEngine *vm) : _vm(vm) {
    4042#ifdef DUMP_SCRIPTS
    4143#define COMMAND(x, sig) { &ScriptInterpreter::x, #x, sig }
    … …  
    143145        _codeBase = _vm->_dat->getObject(_runningScriptObjectIndex)->getData();
    144146        _codeIp = _codeBase;
    145147
    146         while (!_vm->shouldQuit()) {
     148        while (true) {
    147149                byte opcode = readByte();
    148150
    149151                if (opcode >= 1 && opcode <= _commandsMax) {
    … …  
    158160                if (++opcodeSleepCounter > 500) {
    159161                        _vm->_screen->updateScreenAndWait(5);
    160162                        opcodeSleepCounter = 0;
     163                        if (_vm->shouldQuit()) {
     164                                break;
     165                        }
    161166                }
    162167
    163168        }

  • engines/made/scriptfuncs.cpp

     
    187187        if (_vm->_screen->isScreenLocked())
    188188                return 0;
    189189        if (_vm->_autoStopSound) {
    190                 _vm->_mixer->stopHandle(_audioStreamHandle);
     190                stopSound();
    191191                _vm->_autoStopSound = false;
    192192        }
    193193        _vm->_screen->clearScreen();
    … …  
    232232int16 ScriptFunctions::sfPlaySound(int16 argc, int16 *argv) {
    233233        int16 soundNum = argv[0];
    234234        _vm->_autoStopSound = false;
    235         _vm->_mixer->stopHandle(_audioStreamHandle);
     235        stopSound();
    236236        if (argc > 1) {
    237237                soundNum = argv[1];
    238238                _vm->_autoStopSound = (argv[0] == 1);
    … …  
    243243                        soundRes->getAudioStream(_vm->_soundRate, false));
    244244                _vm->_soundEnergyArray = soundRes->getSoundEnergyArray();
    245245                _vm->_soundEnergyIndex = 0;
     246                _soundStarted = true;
     247                _soundResource = soundRes;
    246248        }
    247249        return 0;
    248250}
    … …  
    563565                return 0;
    564566}
    565567
     568void ScriptFunctions::stopSound() {
     569        _vm->_mixer->stopHandle(_audioStreamHandle);
     570        if (_soundStarted) {
     571                _vm->_res->freeResource(_soundResource);
     572                _soundStarted = false;
     573        }
     574               
     575}
     576
     577
    566578int16 ScriptFunctions::sfStopSound(int16 argc, int16 *argv) {
    567         _vm->_mixer->stopHandle(_audioStreamHandle);
     579        stopSound();
    568580        _vm->_autoStopSound = false;
    569581        return 0;
    570582}
    571583
    572584int16 ScriptFunctions::sfPlayVoice(int16 argc, int16 *argv) {
    573585        int16 soundNum = argv[0];
    574         _vm->_mixer->stopHandle(_audioStreamHandle);
     586        stopSound();
    575587        if (soundNum > 0) {
     588                _soundResource = _vm->_res->getSound(soundNum);
    576589                _vm->_mixer->playInputStream(Audio::Mixer::kPlainSoundType, &_audioStreamHandle,
    577                         _vm->_res->getSound(soundNum)->getAudioStream(_vm->_soundRate, false));
     590                        _soundResource->getAudioStream(_vm->_soundRate, false));
    578591                _vm->_autoStopSound = true;
     592                _soundStarted = true;
    579593        }
    580594        return 0;
    581595}
    … …  
    863877                const char *text = menu->getString(textIndex);
    864878                if (text)
    865879                        _vm->_screen->printText(text);
     880
    866881                _vm->_res->freeResource(menu);
    867882        }
    868883        return 0;

  • engines/made/scriptfuncs.h

     
    5555        void setupExternalsTable();
    5656        const char* getFuncName(int index) { return _externalFuncNames[index]; }
    5757        int getCount() const { return _externalFuncs.size(); }
     58        void stopSound();
     59
    5860protected:
    5961        MadeEngine *_vm;
    6062        Audio::SoundHandle _audioStreamHandle;
    6163        Audio::SoundHandle _voiceStreamHandle;
     64        SoundResource* _soundResource;
     65        bool _soundStarted;
    6266
    6367        Common::Array<const ExternalFunc*> _externalFuncs;
    6468        Common::Array<const char *> _externalFuncNames;