resource.h

/* ScummVM - Graphic Adventure Engine
 *
 * ScummVM is the legal property of its developers, whose names
 * are too numerous to list here. Please refer to the COPYRIGHT
 * file distributed with this source distribution.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */
 
#ifndef SCUMM_RESOURCE_H
#define SCUMM_RESOURCE_H
 
#include "common/array.h"
#include "scumm/scumm.h"    // for ResType
 
namespace Scumm {
 
// Extra space allocated for every resource. Originaly a safety area to make
// "precaching" of bytes in the gdi drawer easier. Now also taken into
// consideration when doing bounds checking in o5_stringOps().
#define SAFETY_AREA 2
 
enum {
    OF_OWNER_MASK = 0x0F,
    OF_STATE_MASK = 0xF0,
 
    OF_STATE_SHL = 4
};
 
class ResourceIterator {
    uint32 _size;
    uint32 _pos;
    const byte *_ptr;
    bool _smallHeader;
public:
    ResourceIterator(const byte *searchin, bool smallHeader);
    const byte *findNext(uint32 tag);
};
 
enum : uint {
    RES_INVALID_OFFSET = 0xFFFFFFFF
};
 
class ScummEngine;
 
enum ResTypeMode {
    kDynamicResTypeMode = 0,    
    kStaticResTypeMode = 1,     
    kSoundResTypeMode = 2       
};
 
class ResourceManager {
    //friend class ScummDebugger;
    //friend class ScummEngine;
protected:
    ScummEngine *_vm;
    Common::Mutex *_mutex;
 
public:
    class Resource {
    public:
        byte *_address;
 
        uint32 _size;
 
    protected:
        byte _flags;
 
        byte _status;
 
    public:
        byte _roomno;
 
        uint32 _roomoffs;
 
    public:
        Resource();
        ~Resource();
 
        void nuke();
 
        inline void setResourceCounter(byte counter);
        inline byte getResourceCounter() const;
 
        void lock();
        void unlock();
        bool isLocked() const;
 
        // HE specific
        void setModified();
        bool isModified() const;
        void setOffHeap();
        void setOnHeap();
        bool isOffHeap() const;
    };
 
    class ResTypeData : public Common::Array<Resource> {
    friend class ResourceManager;
    public:
        ResTypeMode _mode;
 
        uint32 _tag;
 
    public:
        ResTypeData();
        ~ResTypeData();
    };
    ResTypeData _types[rtLast + 1];
 
protected:
    uint32 _allocatedSize;
    uint32 _maxHeapThreshold, _minHeapThreshold;
    byte _expireCounter;
 
public:
    ResourceManager(ScummEngine *vm);
    ~ResourceManager();
 
    void setHeapThreshold(int min, int max);
    uint32 getHeapSize() { return _allocatedSize; }
 
    void allocResTypeData(ResType type, uint32 tag, int num, ResTypeMode mode);
    void freeResources();
 
    byte *createResource(ResType type, ResId idx, uint32 size);
    void nukeResource(ResType type, ResId idx);
 
//  inline Resource &getRes(ResType type, ResId idx) { return _types[type][idx]; }
//  inline const Resource &getRes(ResType type, ResId idx) const { return _types[type][idx]; }
 
    bool isResourceLoaded(ResType type, ResId idx) const;
 
    void lock(ResType type, ResId idx);
    void unlock(ResType type, ResId idx);
    bool isLocked(ResType type, ResId idx) const;
 
    // HE Specific
    void setModified(ResType type, ResId idx);
    bool isModified(ResType type, ResId idx) const;
    void setOffHeap(ResType type, ResId idx);
    bool isOffHeap(ResType type, ResId idx) const;
    void setOnHeap(ResType type, ResId idx);
 
    void increaseExpireCounter();
 
    void setResourceCounter(ResType type, ResId idx, byte counter);
 
    void increaseResourceCounters();
 
    void resourceStats();
 
//protected:
    bool validateResource(const char *str, ResType type, ResId idx) const;
protected:
    void expireResources(uint32 size);
};
 
} // End of namespace Scumm
 
#endif