res_man.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.
 *
 * Additional copyright for this file:
 * Copyright (C) 1999-2000 Revolution Software Ltd.
 * This code is based on source code created by Revolution Software,
 * used with permission.
 *
 * 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 ICB_RES_MAN_H
#define ICB_RES_MAN_H

#include "engines/icb/p4.h"
#include "engines/icb/common/px_array.h"
#include "engines/icb/common/px_string.h"
#include "engines/icb/common/px_common.h"
#include "engines/icb/common/px_clu_api.h"

namespace Common {
class Mutex;
}

namespace ICB {

// Horrible forward declaration, this really should be a macro, but that makes
// debugging a real bitch
// The actual body is contained in res_man_psx.h & res_man_pc.h
// as the PC & PSX have different ways of determining if the files are identical
// i.e. PC uses strcmp, PSX uses compare the hash values
inline int32 SameUrl(const char *urla, const uint32 urla_hash, const uint32 clustera_hash, const char *urlb, const uint32 urlb_hash, const uint32 clusterb_hash);

} // End of namespace ICB (To avoid nesting during includes)

#include "engines/icb/res_man_pc.h"

namespace ICB {

// Generic stuff

extern uint32 MAX_MEM_BLOCKS;

#define MEM_null 0
#define MEM_free 1
#define MEM_in_use 2

#define RM_LOADNOW 0   // load file right now
#define RM_ASYNCLOAD 1 // async load file

#define MAKE_TOTAL_HASH(c, f) (2 * c + f)

typedef struct {
    uint32 url_hash;     // hash value of the url name
    uint32 cluster_hash; // hash value of the cluster the url beint32s to
    uint8 *ad;
    uint32 size;
    uint32 protect;
    uint32 total_hash; // 2*cluster_hash+url_hash;
    int16 parent; // who is before us
    int16 child; // who is after us
    uint16 age;
    uint8 state;
    uint8 pad1;
} mem;

// MUST BE PADDED TO 8 BYTES!!!!
typedef struct {
    uint32 total_hash;
    int32 search;
} mem_offset;

// Put the res_man params in a structure to prevent passing lots of the same arguments
// from function to function
typedef struct RMParams {
    uint32 url_hash;
    const char *cluster;
    uint32 cluster_hash;
    uint32 mode;
    int32 len;
    int32 seekpos;
    int32 zipped;
    int32 search;
    int32 compressed; // No zero if the resource is compressed
    Common::SeekableReadStream *_stream;
    uint8 not_ready_yet; // are not ready yet
} RMParams;

class res_man {
    uint32 total_pool; // fixed initial memory pool
    uint32 total_free_memory;
    uint8 *memory_base;
    uint32 total_blocks; // total memory blocks in use - 1 more than number_files_open as we have the end free block to be eaten into
    uint32 number_files_open;
    uint32 max_mem_blocks;

    mem *mem_list; // mem_list[MAX_MEM_BLOCKS];

    mem_offset *mem_offset_list;
    int32 num_mem_offsets;

    uint16 current_time_frame; // inc's each time Res_open is called and is given to resource as its age cannot be allowed to start at 0!

public:
    int32 amount_of_defrags;

    res_man();
    res_man(uint32 memory_tot);
    res_man(uint8 *base, uint32 size);
    void Construct(uint8 *base, uint32 size, mem *memList, mem_offset *memOffsets, uint32 nMemBlocks);
    ~res_man();

    void AddMemOffset(uint32 total_hash, int32 search); // adds to mem list, clearing out if nesesary
    inline int32 FindMemSearch(uint32 total_hash);      // returns a search file for given total_hash, generates and adds if not in
    inline int32 FindMemOffset(uint32 total_hash);      // returns index into offsets table

public:
    void Reset(); // trash all resources

    // So that other parts of the game can use this memory
    inline uint8 *Get_memory_base();
    inline uint32 Get_memory_size();

    void Set_auto_timeframe_advance();
    void Set_to_no_defrag();

    int16 find_oldest_file();
    void Garbage_removal();

    // load whole cluster (if size is specified then load that amount of data, otherwise just load
    // the cluster header first...
    void Res_open_cluster(const char *cluster_url, uint32 &cluster_hash, int32 size = -1);

    void Res_open_mini_cluster(const char *cluster_url, uint32 &cluster_hash, const char *fake_cluster_url, uint32 &fake_cluster_hash);

    // If hash or cluster_hash == NULL_HASH then the hash of url/cluster_url
    // is computed and stored in hash/cluster_hash
    uint8 *Res_open(const char *url, uint32 &url_hash, const char *cluster_url, uint32 &cluster_hash,
                    int32 compressed = 0, // non zero if the resource is compressed
                    int32 *ret_len = NULL);
    // new function to just allocate some memory for use
    // by code which wants temporary memory but not files
    // e.g. stream player, image decompressor
    uint8 *Res_alloc(uint32 url_hash, const char *cluster, uint32 cluster_hash, uint32 length);
    // If hash or cluster_hash == NULL_HASH then the hash of url/cluster_url
    void Res_purge(const char *url, uint32 url_hash, const char *cluster, uint32 cluster_hash, uint32 fatal = 1);
    void Res_purge_all();
    uint32 Fetch_size(const char *url, uint32 url_hash, const char *cluster_url, uint32 cluster_hash);

    void Advance_time_stamp();
    uint32 Check_file_size(const char *url, uint32 url_hash, const char *cluster_url, uint32 cluster_hash);
    bool8 Test_file(const char *url);
    bool8 Test_file(const char *url, uint32 url_hash, const char *cluster_url, uint32 cluster_hash);

    uint32 Fetch_files_open();
    uint32 Fetch_total_pool_size();
    uint32 Fetch_free_memory();
    uint32 Fetch_mem_used();
    mem *Fetch_mem_list();
    uint32 Fetch_max_mem_blocks();

    uint32 Fetch_old_memory(int32 number_of_cycles);

    // For testing purposes wanted to call Defrag from console
    // so made it public function
    void Defrag();

    // To aid debugging messages
    inline void Id(int32 newId);
    inline int32 Id();

private:
    inline void MakeHash(const char *s, uint32 &h);
    inline int32 CheckHash(const char *s, const uint32 h, uint32 &h2);

    const char *OpenFile(int32 &cluster_search, RMParams *params);

    // the old linear ones
    int16 OldFindFile(uint32 url_hash, uint32 cluster_hash, uint32 total_hash);

    // new binary ones
    int16 FindFile(uint32 url_hash, uint32 cluster_hash, uint32 total_hash);

    int16 FindFile(RMParams *params);
    void FindFileCluster(int32 &url_search, int32 &cluster_search, RMParams *params);

    HEADER_NORMAL *GetFileHeader(int32 &cluster_search, RMParams *params);

    inline int32 SameFile(mem *current_mem_block, const char *url, const uint32 url_hash, const uint32 cluster_hash);

    void ReadFile(const char *new_url, RMParams *params);
    uint32 FindMemBlock(uint32 adj_len, RMParams *params);
    uint8 *AllocMemory(uint32 &memory_tot);

    void Initialise(uint32 memory_tot);

    uint8 *Internal_open(RMParams *params, int32 *ret_len = NULL);

    uint8 *LoadFile(int32 &cluster_search, RMParams *params);

    int16 Find_space(uint32 len);
    uint16 Fetch_spawn(uint16 parent);

    bool8 auto_time_advance; // if true then time stamp is automatically imcremented as a file is opened
    bool8 no_defrag; // this manager is a static one so resources cannot be purged, shuffled or aged out
    uint8 id; // used for debugging messages to say which res_man you are

    uint8 padding1;
};

// binary search the mem_offset table return -1 if not found
inline int32 res_man::FindMemOffset(uint32 hash) {
    int32 top, bottom;
    int32 i;
    uint32 current;

    if (!num_mem_offsets)
        return -1;

    top = num_mem_offsets - 1;
    i = top >> 1;
    bottom = 0;

    for (;;) {
        current = mem_offset_list[i].total_hash;
        if (hash == current)
            return i;
        else if (top == bottom)
            return -1;
        else if (hash > current) {
            bottom = i + 1;
            i = (top + bottom) >> 1;
        } else {
            top = i;
            i = (top + bottom) >> 1;
        }
    }
}

inline int32 res_man::FindMemSearch(uint32 total_hash) { // returns a search file for given total_hash, generates and adds if not in
    int32 i = FindMemOffset(total_hash);
    if (i == -1)
        return -1;
    else
        return mem_offset_list[i].search;
}

inline uint8 *res_man::Get_memory_base() {
    return memory_base;
}

inline uint32 res_man::Get_memory_size() {
    return total_pool;
}

inline void res_man::Set_auto_timeframe_advance() {
    auto_time_advance = TRUE8; // timeframe will be advanced with each res-open
}

inline void res_man::Set_to_no_defrag() {
    no_defrag = TRUE8; // stop ageing out, etc
}

inline uint32 res_man::Fetch_total_pool_size() {
    return (total_pool);
}

inline uint32 res_man::Fetch_free_memory() {
    return (total_free_memory);
}

inline uint32 res_man::Fetch_files_open() {
    return (number_files_open);
}

inline mem *res_man::Fetch_mem_list() { return mem_list; }

inline uint32 res_man::Fetch_max_mem_blocks() { return max_mem_blocks; }

inline uint32 res_man::Fetch_mem_used() {
    return (total_pool - total_free_memory);
}

inline int32 res_man::SameFile(mem *current_mem_block, const char *url, const uint32 url_hash, const uint32 cluster_hash) {
    return SameUrl(url, url_hash, cluster_hash, NULL, current_mem_block->url_hash, current_mem_block->cluster_hash);
}

inline void res_man::MakeHash(const char *s, uint32 &h) {
    // if hash value is not set then make it
    if (h == NULL_HASH)
        h = EngineHashString(s);
}

inline int32 res_man::CheckHash(const char *s, const uint32 h, uint32 &h2) {
    if (!s)
        return 1;
    h2 = EngineHashString(s);
    if (h2 != h)
        return 0;
    return 1;
}

// To aid debugging messages
inline void res_man::Id(int32 newId) { id = (uint8)newId; }

inline int32 res_man::Id() { return (int32)id; }

extern uint32 memory_available; // set by memory_stats

void Memory_stats();
void Print_console_clusters();

} // End of namespace ICB

#endif // #ifndef RES_MAN_H