advancedDetector.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 ENGINES_ADVANCED_DETECTOR_H
#define ENGINES_ADVANCED_DETECTOR_H
 
#include "engines/metaengine.h"
#include "engines/engine.h"
 
#include "common/hash-str.h"
 
#include "common/gui_options.h" // Keep it here, so detection tables can refer to them
 
namespace Common {
class Error;
class FSList;
}
/* Some helpers functions to avoid code duplication */
namespace ADDynamicDescription {
 
static inline uint32 strSizeBuffer(const char * const &field) {
    return field ? (uint32)strlen(field) + 1 : 0;
}
static inline void *strToBuffer(void *buffer, const char *&field) {
    if (field) {
        int len = (int)strlen(field) + 1;
        memcpy((char *)buffer, field, len);
        field = (const char *)buffer;
        buffer = (char *)buffer + len;
    }
    return buffer;
}
 
static inline uint32 alignSizeBuffer() {
    // We consider alignments up to pointer size
    return sizeof(void *) - 1;
}
static inline void *alignToBuffer(void *buffer) {
    // Round up
    uintptr tmp = (uintptr)buffer + sizeof(void *) - 1;
    return (void *)(tmp & -(int)sizeof(void *));
}
 
} // End of namespace ADDynamicDescription
 
struct ADGameFileDescription {
    const char *fileName; 
    uint16 fileType;      
    const char *md5;      
    uint32 fileSize;      
 
    uint32 sizeBuffer() const {
        uint32 ret = 0;
        ret += ADDynamicDescription::strSizeBuffer(fileName);
        ret += ADDynamicDescription::strSizeBuffer(md5);
        return ret;
    }
 
    void *toBuffer(void *buffer) {
        buffer = ADDynamicDescription::strToBuffer(buffer, fileName);
        buffer = ADDynamicDescription::strToBuffer(buffer, md5);
        return buffer;
    }
};
 
#define AD_NO_SIZE ((uint32)-1)
 
#define AD_LISTEND {NULL, 0, NULL, 0}
 
#define AD_ENTRY1(f, x) {{ f, 0, x, AD_NO_SIZE}, AD_LISTEND}
 
#define AD_ENTRY1s(f, x, s) {{ f, 0, x, s}, AD_LISTEND}
 
#define AD_ENTRY2s(f1, x1, s1, f2, x2, s2) {{f1, 0, x1, s1}, {f2, 0, x2, s2}, AD_LISTEND}
 
#define AD_ENTRY3s(f1, x1, s1, f2, x2, s2, f3, x3, s3) {{f1, 0, x1, s1}, {f2, 0, x2, s2}, {f3, 0, x3, s3}, AD_LISTEND}
#define AD_ENTRY4s(f1, x1, s1, f2, x2, s2, f3, x3, s3, f4, x4, s4) {{f1, 0, x1, s1}, {f2, 0, x2, s2}, {f3, 0, x3, s3}, {f4, 0, x4, s4}, AD_LISTEND}
#define AD_ENTRY5s(f1, x1, s1, f2, x2, s2, f3, x3, s3, f4, x4, s4, f5, x5, s5) {{f1, 0, x1, s1}, {f2, 0, x2, s2}, {f3, 0, x3, s3}, {f4, 0, x4, s4}, {f5, 0, x5, s5}, AD_LISTEND}
#define AD_ENTRY6s(f1, x1, s1, f2, x2, s2, f3, x3, s3, f4, x4, s4, f5, x5, s5, f6, x6, s6) {{f1, 0, x1, s1}, {f2, 0, x2, s2}, {f3, 0, x3, s3}, {f4, 0, x4, s4}, {f5, 0, x5, s5}, {f6, 0, x6, s6}, AD_LISTEND}
 
enum ADGameFlags : uint {
    ADGF_NO_FLAGS        =  0u,        
    ADGF_ADDON           = (1u << 15), 
    ADGF_TAILMD5         = (1u << 16), 
    ADGF_AUTOGENTARGET   = (1u << 17), 
    ADGF_UNSTABLE        = (1u << 18), 
    ADGF_TESTING         = (1u << 19), 
    ADGF_PIRATED         = (1u << 20), 
    ADGF_UNSUPPORTED     = (1u << 21), 
    ADGF_WARNING         = (1u << 22), 
    ADGF_ADDENGLISH      = (1u << 23), 
    ADGF_MACRESFORK      = (1u << 24), 
    ADGF_USEEXTRAASTITLE = (1u << 25), 
    ADGF_DROPLANGUAGE    = (1u << 26), 
    ADGF_DROPPLATFORM    = (1u << 27), 
    ADGF_CD              = (1u << 28), 
    ADGF_DVD             = (1u << 29), 
    ADGF_DEMO            = (1u << 30), 
    ADGF_REMASTERED      = (1u << 31)  
};
 
struct ADGameDescription {
    const char *gameId;
 
    const char *extra;
 
    ADGameFileDescription filesDescriptions[14];
 
    Common::Language language;
 
    Common::Platform platform;
 
    uint32 flags;
 
    const char *guiOptions;
 
    uint32 sizeBuffer() const {
        uint32 ret = 0;
        ret += ADDynamicDescription::strSizeBuffer(gameId);
        ret += ADDynamicDescription::strSizeBuffer(extra);
        for(int i = 0; i < ARRAYSIZE(filesDescriptions); i++) {
            ret += filesDescriptions[i].sizeBuffer();
        }
        ret += ADDynamicDescription::strSizeBuffer(guiOptions);
        return ret;
    }
 
    void *toBuffer(void *buffer) {
        buffer = ADDynamicDescription::strToBuffer(buffer, gameId);
        buffer = ADDynamicDescription::strToBuffer(buffer, extra);
        for(int i = 0; i < ARRAYSIZE(filesDescriptions); i++) {
            buffer = filesDescriptions[i].toBuffer(buffer);
        }
        buffer = ADDynamicDescription::strToBuffer(buffer, guiOptions);
        return buffer;
    }
};
 
#define AD_GAME_DESCRIPTION_HELPERS(field) \
    uint32 sizeBuffer() const { \
        return field.sizeBuffer(); \
    } \
    void *toBuffer(void *buffer) { \
        return field.toBuffer(buffer); \
    }
 
template<class T>
class ADDynamicGameDescription : public T {
public:
    ADDynamicGameDescription(const T *other) : _buffer(nullptr) {
        // First copy all fields
        memcpy(static_cast<T*>(this), other, sizeof(T));
 
        // Then calculate the size of the dynamic buffer
        // we will need to store evrything pointed at by
        // the structures
        uint32 sz = other->sizeBuffer();
        _buffer = new byte[sz];
 
        // Finally copy every pointer in the buffer
        // and make the structure point into it
        void *end = this->toBuffer(_buffer);
        assert(end <= _buffer + sz);
        (void)end;
    }
 
    ~ADDynamicGameDescription() {
        delete[] _buffer;
    }
 
private:
    byte *_buffer;
};
 
struct ADDetectedGameExtraInfo {
    Common::String gameName;            
    Common::String targetID;            
};
 
struct ADDetectedGame {
    bool hasUnknownFiles;           
    FilePropertiesMap matchedFiles; 
    const ADGameDescription *desc;  
    ADDetectedGame() : desc(nullptr), hasUnknownFiles(false) {}
    explicit ADDetectedGame(const ADGameDescription *d) : desc(d), hasUnknownFiles(false) {}
};
 
typedef Common::Array<ADDetectedGame> ADDetectedGames;
 
#define AD_TABLE_END_MARKER \
    { NULL, NULL, { { NULL, 0, NULL, 0 } }, Common::UNK_LANG, Common::kPlatformUnknown, ADGF_NO_FLAGS, GUIO0() }
 
struct ADFileBasedFallback {
    const ADGameDescription *desc;
 
    const char *filenames[10];
};
 
 
enum ADFlags {
    kADFlagUseExtraAsHint = (1 << 0),
 
     kADFlagMatchFullPaths = (1 << 1),
 
     kADFlagPreferFallbackDetection = (1 << 2),
 
    kADFlagCanPlayUnknownVariants = (1 << 3),
 
    kADFlagCanTranscodeTraditionalChineseToSimplified = (1 << 4),
};
 
 
struct ADExtraGuiOptionsMap {
    const char *guioFlag;  
    ExtraGuiOption option; 
};
 
#define AD_EXTRA_GUI_OPTIONS_TERMINATOR { 0, { 0, 0, 0, 0, 0, 0 } }
 
class AdvancedMetaEngineDetectionBase : public MetaEngineDetection {
protected:
    const byte *_gameDescriptors;
 
    const uint _descItemSize;
 
    const PlainGameDescriptor *_gameIds;
 
    uint _md5Bytes;
 
    uint32 _flags;
 
    Common::String _guiOptions;
 
    uint32 _maxScanDepth;
 
    const char * const *_directoryGlobs;
 
    int _maxAutogenLength;
 
     int _fullPathGlobsDepth;
 
    AdvancedMetaEngineDetectionBase(const void *descs, uint descItemSize, const PlainGameDescriptor *gameIds);
 
public:
    PlainGameList getSupportedGames() const override;
 
    PlainGameDescriptor findGame(const char *gameId) const override;
 
    Common::Error identifyGame(DetectedGame &game, const void **descriptor) override;
 
    DetectedGames detectGames(const Common::FSList &fslist, uint32 skipADFlags, bool skipIncomplete) override;
 
    uint getMD5Bytes() const override final { return _md5Bytes; }
 
    int getGameVariantCount() const override final {
        uint count = 0;
        for (const byte *descPtr = _gameDescriptors; ((const ADGameDescription *)descPtr)->gameId != nullptr; descPtr += _descItemSize)
            ++count;
        return count;
    }
 
    void dumpDetectionEntries() const override;
 
    static Common::String sanitizeName(const char *name, int maxLen);
 
protected:
    typedef Common::HashMap<Common::Path, Common::FSNode, Common::Path::IgnoreCase_Hash, Common::Path::IgnoreCase_EqualTo> FileMap;
 
    virtual ADDetectedGame fallbackDetect(const FileMap &allFiles, const Common::FSList &fslist, ADDetectedGameExtraInfo **extra = nullptr) const {
        return ADDetectedGame();
    }
 
private:
    void preprocessDescriptions();
    static Common::StringArray getPathsFromEntry(const ADGameDescription *g);
    bool isEntryGrayListed(const ADGameDescription *g) const;
    void detectClashes() const;
 
private:
    Common::HashMap<Common::String, bool, Common::IgnoreCase_Hash, Common::IgnoreCase_EqualTo> _grayListMap;
    Common::HashMap<Common::String, bool, Common::IgnoreCase_Hash, Common::IgnoreCase_EqualTo> _globsMap;
    bool _hashMapsInited;
 
protected:
    virtual ADDetectedGames detectGame(const Common::FSNode &parent, const FileMap &allFiles, Common::Language language, Common::Platform platform, const Common::String &extra, uint32 skipADFlags = 0, bool skipIncomplete = false);
 
    ADDetectedGame detectGameFilebased(const FileMap &allFiles, const ADFileBasedFallback *fileBasedFallback) const;
 
    void composeFileHashMap(FileMap &allFiles, const Common::FSList &fslist, int depth, const Common::Path &parentName = Common::Path()) const;
 
    bool getFileProperties(const FileMap &allFiles, MD5Properties md5prop, const Common::Path &fname, FileProperties &fileProps) const;
 
    virtual DetectedGame toDetectedGame(const ADDetectedGame &adGame, ADDetectedGameExtraInfo *extraInfo = nullptr) const;
 
    bool cleanupPirated(ADDetectedGames &matched) const;
 
    friend class FileMapArchive;
};
 
template<class Descriptor>
class AdvancedMetaEngineDetection : public AdvancedMetaEngineDetectionBase {
protected:
    AdvancedMetaEngineDetection(const Descriptor *descs, const PlainGameDescriptor *gameIds) : AdvancedMetaEngineDetectionBase(descs, sizeof(Descriptor), gameIds) {}
 
    Common::Error identifyGame(DetectedGame &game, const void **descriptor) override {
        assert(descriptor);
        Common::Error err = AdvancedMetaEngineDetectionBase::identifyGame(game, descriptor);
        if (err.getCode() != Common::kNoError) {
            return err;
        }
        if (*descriptor) {
            *descriptor = new ADDynamicGameDescription<Descriptor>(static_cast<const Descriptor *>(*descriptor));
        }
        return err;
    }
};
 
class AdvancedMetaEngineBase : public MetaEngine {
public:
    Common::Error createInstance(OSystem *syst, Engine **engine, const DetectedGame &gameDescriptor, const void *metaEngineDescriptor) override;
 
    virtual Common::Error createInstance(OSystem *syst, Engine **engine, const void *desc) const = 0;
 
    const char *getName() const override = 0;
 
    Common::String getGameId(const char *target) const;
 
public:
    typedef Common::HashMap<Common::Path, Common::FSNode, Common::Path::IgnoreCase_Hash, Common::Path::IgnoreCase_EqualTo> FileMap;
 
    virtual ADDetectedGame fallbackDetectExtern(uint md5Bytes, const FileMap &allFiles, const Common::FSList &fslist, ADDetectedGameExtraInfo **extra = nullptr) const {
        return ADDetectedGame();
    }
 
    bool getFilePropertiesExtern(uint md5Bytes, const FileMap &allFiles, MD5Properties md5prop, const Common::Path &fname, FileProperties &fileProps) const;
 
protected:
    const ExtraGuiOptions getExtraGuiOptions(const Common::String &target) const override final;
 
    virtual const ADExtraGuiOptionsMap *getAdvancedExtraGuiOptions() const { return nullptr; }
 
    bool checkExtendedSaves(MetaEngineFeature f) const;
 
private:
    void initSubSystems(const ADGameDescription *gameDesc) const;
};
 
template<class Descriptor>
class AdvancedMetaEngine : public AdvancedMetaEngineBase {
protected:
    virtual Common::Error createInstance(OSystem *syst, Engine **engine, const Descriptor *desc) const = 0;
    Common::Error createInstance(OSystem *syst, Engine **engine, const void *desc) const override final {
        return createInstance(syst, engine, static_cast<const Descriptor *>(desc));
    }
 
    void deleteInstance(Engine *engine, const DetectedGame &gameDescriptor, const void *meDescriptor) override {
        delete engine;
        delete static_cast<ADDynamicGameDescription<Descriptor> *>(
                                const_cast<void *>(meDescriptor));
    }
 
private:
    // Silence overloaded-virtual warning from clang
    using AdvancedMetaEngineBase::createInstance;
};
 
class AdvancedDetectorCacheManager : public Common::Singleton<AdvancedDetectorCacheManager> {
public:
    void setMD5(const Common::String &fname, const Common::String &md5) {
        md5HashMap.setVal(fname, md5);
    }
 
    const Common::String &getMD5(const Common::String &fname) const {
        return md5HashMap.getVal(fname);
    }
 
    void setSize(const Common::String &fname, int64 size) {
        sizeHashMap.setVal(fname, size);
    }
 
    int64 getSize(const Common::String &fname) const {
        return sizeHashMap.getVal(fname);
    }
 
    bool containsMD5(const Common::String &fname) const {
        return (md5HashMap.contains(fname) && sizeHashMap.contains(fname));
    }
 
    void addArchive(const Common::FSNode &node, Common::Archive *archivePtr) {
        if (!archivePtr)
            return;
 
        Common::Path filename = node.getPath();
 
        if (archiveHashMap.contains(filename)) {
            delete archiveHashMap[filename];
        }
 
        archiveHashMap.setVal(filename, archivePtr);
    }
 
    Common::Archive *getArchive(const Common::FSNode &node) const {
        return archiveHashMap.getValOrDefault(node.getPath(), nullptr);
    }
 
    AdvancedDetectorCacheManager() {
        clear();
    }
 
    void clearArchives() {
        for (auto &entry : archiveHashMap) {
            delete entry._value;
        }
        archiveHashMap.clear(true);
    }
 
    void clear() {
        md5HashMap.clear(true);
        sizeHashMap.clear(true);
        clearArchives();
    }
 
private:
    friend class Common::Singleton<AdvancedDetectorCacheManager>;
 
    typedef Common::HashMap<Common::String, Common::String, Common::IgnoreCase_Hash, Common::IgnoreCase_EqualTo> FileHashMap;
    typedef Common::HashMap<Common::String, int64, Common::IgnoreCase_Hash, Common::IgnoreCase_EqualTo> SizeHashMap;
    typedef Common::HashMap<Common::Path, Common::Archive *, Common::Path::IgnoreCase_Hash, Common::Path::IgnoreCase_EqualTo> ArchiveHashMap;
    FileHashMap md5HashMap;
    SizeHashMap sizeHashMap;
    ArchiveHashMap archiveHashMap;
};
 
#define ADCacheMan AdvancedDetectorCacheManager::instance()
#endif