root/system/file.h

/*  file.h  : KANON の圧瞮ファむル・PDT ファむル画像ファむルの展開の
 *            ためのクラス
 *     class FileSearcher : ファむルの管理を行う
 *     class ARCINFO : 曞庫ファむルの䞭の぀のファむルを扱うクラス
 *     class PDTCONV : PDT ファむルの展開を行う。
 */

/*
 *
 *  Copyright (C) 2000-   Kazunori Ueno(JAGARL) <jagarl@creator.club.ne.jp>
 *
 *  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 2 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, write to the Free Software Foundation, Inc.,
 *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 *
*/

#ifndef __KANON_FILE_H__
#define __KANON_FILE_H__

#ifndef DIR_SPLIT
#define DIR_SPLIT '/'   /* UNIX */
#endif

// read 'KANON' compressed file

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>

#ifdef HAVE_CONFIG_H
#  include "config.h"
#endif

#if defined(__sparc) || defined(sparc)
#  if !defined(WORDS_BIGENDIAN)
#    define WORDS_BIGENDIAN 1
#  endif
#endif

#define INT_SIZE 4

static int read_little_endian_int(const char* buf) {
        const unsigned char *p = (const unsigned char *) buf;
        return (p[3] << 24) | (p[2] << 16) | (p[1] << 8) | p[0];
}

static int read_little_endian_short(const char* buf) {
        const unsigned char *p = (const unsigned char *) buf;
        return (p[1] << 8) | p[0];
}

static int write_little_endian_int(char* buf, int number) {
        int c = read_little_endian_int(buf);
        unsigned char *p = (unsigned char *) buf;
        unsigned int unum = (unsigned int) number;
        p[0] = unum & 255;
        unum >>= 8;
        p[1] = unum & 255;
        unum >>= 8;
        p[2] = unum & 255;
        unum >>= 8;
        p[3] = unum & 255;
        return c;
}

static int write_little_endian_short(char* buf, int number) {
        int c = read_little_endian_short(buf);
        unsigned char *p = (unsigned char *) buf;
        unsigned int unum = (unsigned int) number;
        p[0] = unum & 255;
        unum >>= 8;
        p[1] = unum & 255;
        return c;
}


/*********************************************
**  FileSearcher:
**      曞庫ファむルディレクトリを含め、
**      党ファむルの管理を行う。
**
**      最初に、蚭定ファむルからファむルの皮類ごずに
**      実際に入っおいるディレクトリ、曞庫を蚭定する
**
**      以降はFind() メ゜ッドで実際のファむルの内容を埗る
**
*/

/* ARCFILE ず DIRFILE ã¯ãƒ•ã‚¡ã‚€ãƒ«çš®é¡žã”ãšã®æƒ…å ± */
class ARCFILE;
class DIRFILE;
class SCN2kFILE;
/* ARCINFO はファむルを読み蟌むために必芁 */
class ARCINFO;
class ARCFILE_ATOM;

class KeyHolder {
        public:
                static KeyHolder* GetInstance(void);
                static void Quit(void);

                void SetKey(char[16]);
                void SetKey2(char[33]);
                void GuessKey(char*);

        private:
                KeyHolder(){}
                ~KeyHolder(){}

        public:
                const char* GetKey(void);

        private:
                char key[16];
                static KeyHolder* _singleton;
};

class FileSearcher {
        public:
#define TYPEMAX 14
                enum FILETYPE {
                        /* 䞀応、0 - 15 たで reserved */
                        ALL = 1, /* dat/ 以䞋のファむル(デフォルトの怜玢先) */
                        ROOT= 2, /* ゲヌムのむンストヌルディレクトリ */
                        PDT = 3, /* default: PDT/ */
                        SCN = 4, /* default: DAT/SEEN.TXT */
                        ANM = 5, /* default: DAT/ALLANM.ANL */
                        ARD = 6, /* default: DAT/ALLARD.ARD */
                        CUR = 7, /* default: DAT/ALLCUR.CUR */
                        MID = 8, /* default: ALL */
                        WAV = 9, /* default: ALL */
                        KOE = 10, /* default: KOE/ */
                        BGM = 11, /* default: BGM */
                        MOV = 12, /* default : MOV */
                        GAN = 13  /* default : MOV */
                };
                enum ARCTYPE {ATYPE_DIR, ATYPE_ARC, ATYPE_SCN2k};

        public:
                static FileSearcher* GetInstance(void);
                static void Quit(void);

                /* 初めにゲヌムのデヌタがあるディレクトリを蚭定する必芁がある */
                int InitRoot(char* root);
                /* ãƒ•ã‚¡ã‚€ãƒ«ã®åž‹ã”ãšã®æƒ…å ±ã‚’ã‚»ãƒƒãƒˆã™ã‚‹ */
                void SetFileInformation(FILETYPE type, ARCTYPE is_arc,
                        char* filename);
                /* 耇数のファむルを䞀぀の型に関連づける */
                void AppendFileInformation(FILETYPE type, ARCTYPE is_arc,
                        char* filename);
                ARCFILE* MakeARCFILE(ARCTYPE tp, const char* filename);
                /* fname で指定された名前のファむルを怜玢 */
                class ARCINFO* Find(FILETYPE type, const char* fname, const char* ext=0);
                /* ある皮類のファむルをすべおリストアップ
                ** 末尟は NULL pointer
                */
                char** ListAll(FILETYPE type);

        private:
                FileSearcher(void);
                ~FileSearcher();

        private:
                /* InitRoot() の時点で初期化される倉数 */
                DIRFILE* root_dir;
                DIRFILE* dat_dir;
                ARCFILE* searcher[TYPEMAX];
                /* ファむルの存圚䜍眮の information */
                ARCTYPE is_archived[TYPEMAX];
                const char* filenames[TYPEMAX];
                /* デフォルトの information */
                static ARCTYPE default_is_archived[TYPEMAX];
                static const char* default_dirnames[TYPEMAX];
                static FileSearcher *_singleton;
};

class ARCINFO {
        protected:
                /* ãƒ•ã‚¡ã‚€ãƒ«ãã®ã‚‚ã®ã®æƒ…å ± */
                ARCFILE_ATOM& info;
                char* arcfile;
                /* mmap ã—ãŠã„ã‚‹å Žåˆã€ãã®æƒ…å ± */
                bool use_mmap;
                char* mmapped_memory;
                int fd;
                /* ファむル内容の入っおいるバッファ */
                const char* data;

        protected:
                ARCINFO(const char* arcfile, ARCFILE_ATOM& from); // only from ARCFILE
                friend class ARCFILE;
                friend class DIRFILE;

                virtual bool ExecExtract(void);
        public:
                /* dest は256byte 皋床の䜙裕があるこず */
                static void Extract(char*& dest, char*& src, char* destend, char* srcend);
                static void Extract2k(char*& dest, char*& src, char* destend, char* srcend);
                virtual ~ARCINFO();
                /* 必芁なら Read 前に呌ぶこずで凊理を分割できる */
                int Size(void) const;
                char* CopyRead(void); /* Read() しお内容のコピヌを返す */
                const char* Read(void);
                /* ファむルが regular file ã®å Žåˆã€ãƒ•ã‚¡ã‚€ãƒ«åã‚’åž°ã™ */
                /* そうでないなら 0 を垰す */
                const char* Path(void) const;
                FILE* OpenFile(int* length=0) const; /* 互換性のためraw file ã®å Žåˆã€ãƒ•ã‚¡ã‚€ãƒ«ã‚’é–‹ã */
};

class GRPCONV {
        public:
                int width;
                int height;
                bool is_mask;

                const char* filename;
                const char* data;
                int datalen;

                int Width(void) { return width;}
                int Height(void) { return height;}
                bool IsMask(void) { return is_mask;}

                GRPCONV(void);
                virtual ~GRPCONV();
                void Init(const char* fname, const char* data, int dlen, int width, int height, bool is_mask);

                virtual bool Read(char* image) = 0;
                static GRPCONV* AssignConverter(const char* inbuf, int inlen, const char* fname);
                static GRPCONV* AssignConverter(ARCINFO* info) {
                        const char* dat = info->Read();
                        if (dat == 0) return 0;
                        return AssignConverter(dat, info->Size(), info->Path()); //FIXME: Is it really okay?
                }
                void CopyRGBA(char* image, const char* from);
                void CopyRGB(char* image, const char* from);
                void CopyRGBA_rev(char* image, const char* from);
                void CopyRGB_rev(char* image, const char* from);
};

#endif // !defined(__KANON_FILE_H__)