300 lines
9.4 KiB
C
300 lines
9.4 KiB
C
/*****************************************
|
|
*
|
|
* GOB File System
|
|
*
|
|
* Here's what Merriam-Webster says about "gob": --Chuck
|
|
* Entry: gob
|
|
* Function: noun
|
|
* Etymology: Middle English gobbe, from Middle French gobe large piece of food,
|
|
* back-formation from gobet
|
|
* Date: 14th century
|
|
* 1 : LUMP
|
|
* 2 : a large amount -- usually used in plural <gobs of money>
|
|
*
|
|
* Purpose: Provide fast, efficient disk access on a variety of platforms.
|
|
*
|
|
* Implementation:
|
|
* The GOB system maintains two files -- GOB and GFC. The GOB file is actually
|
|
* an archive of many files split into variable size, compressed blocks. The GFC,
|
|
* GOB File Control, contains 3 tables -- a block table, basic file table, and
|
|
* extended file table. The block table is analogous to a DOS FAT. The basic
|
|
* file table contains a minimal set of file information to handle basic reading
|
|
* tasks. The extended file table is optionally loaded and contains additional
|
|
* file information. File names are case insensitive.
|
|
*
|
|
* Files can be read in a normal manner. Open, read, seek and close
|
|
* operations are all provided. Files can only be written in a single
|
|
* contiguous chunk of blocks at the end of an archive. Reads are processed
|
|
* through a configurable number of read ahead buffers to in an effort to
|
|
* minimize both reads and seeks. Other operations including delete, verify,
|
|
* access, and get size are also supported on files inside an archive.
|
|
*
|
|
* The system supports read profiling. By supplying a file read callback
|
|
* function, the library will output the block number of each read. This can
|
|
* be used rearrange block in the archive to minimize seek times. The
|
|
* GOBRearrange sorts files in an archive.
|
|
*
|
|
* Supports block based caching. Primarily aimed at caching files off a DVD/CD
|
|
* to a faster hard disk.
|
|
*
|
|
* Future Work:
|
|
*
|
|
* Dependencies: vvInt, snprintf, zlib
|
|
* Owner: Chris McEvoy
|
|
* History:
|
|
* 09/23/2001 Original version
|
|
* 10/28/2002 Merged into vvtech
|
|
*
|
|
* Copyright (C) 2002, Vicarious Visions, Inc. All Rights Reserved.
|
|
*
|
|
* UNPUBLISHED -- Rights reserved under the copyright laws of the
|
|
* United States. Use of a copyright notice is precautionary only and
|
|
* does not imply publication or disclosure.
|
|
*
|
|
* THIS DOCUMENTATION CONTAINS CONFIDENTIAL AND PROPRIETARY INFORMATION
|
|
* OF VICARIOUS VISIONS, INC. ANY DUPLICATION, MODIFICATION,
|
|
* DISTRIBUTION, OR DISCLOSURE IS STRICTLY PROHIBITED WITHOUT THE PRIOR
|
|
* EXPRESS WRITTEN PERMISSION OF VICARIOUS VISIONS, INC.
|
|
*
|
|
*****************************************/
|
|
|
|
/*
|
|
This is an unofficial branch of GOB, for Jedi Academy
|
|
Maintainer: Brian Osman
|
|
*/
|
|
|
|
#ifndef GOBLIB_H__
|
|
#define GOBLIB_H__
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
#define GOB_MAGIC_IDENTIFIER 0x8008
|
|
#define GOB_MAX_FILE_NAME_LEN 96
|
|
#define GOB_MAX_OPEN_FILES 16
|
|
#define GOB_MAX_CODECS 2
|
|
#define GOB_INFINITE_RATIO 1000
|
|
#define GOB_READ_RETRYS 3
|
|
|
|
#define GOB_MAX_FILES (16*1024)
|
|
#define GOB_MAX_BLOCKS 32767
|
|
|
|
#define GOB_BLOCK_SIZE (64*1024)
|
|
#define GOB_BLOCK_ALIGNMENT 2048
|
|
#define GOB_MEM_ALIGNMENT 64
|
|
#define GOB_COMPRESS_OVERHEAD 1024
|
|
|
|
#define GOB_INVALID_SIZE 0xFFFFFFFF
|
|
#define GOB_INVALID_BLOCK 0xFFFFFFFF
|
|
|
|
#define GOB_TRUE 1
|
|
#define GOB_FALSE 0
|
|
|
|
#define GOBERR_OK 0
|
|
#define GOBERR_NOT_INIT 1
|
|
#define GOBERR_FILE_NOT_FOUND 2
|
|
#define GOBERR_FILE_READ 3
|
|
#define GOBERR_FILE_WRITE 4
|
|
#define GOBERR_NO_MEMORY 5
|
|
#define GOBERR_ALREADY_INIT 6
|
|
#define GOBERR_ALREADY_OPEN 7
|
|
#define GOBERR_INVALID_ACCESS 8
|
|
#define GOBERR_NOT_GOB_FILE 9
|
|
#define GOBERR_NOT_OPEN 10
|
|
#define GOBERR_CANNOT_CREATE 11
|
|
#define GOBERR_TOO_MANY_OPEN 12
|
|
#define GOBERR_INVALID_SEEK 13
|
|
#define GOBERR_TOO_MANY_FILES 14
|
|
#define GOBERR_FILE_RENAME 15
|
|
#define GOBERR_PROFILE_OFF 16
|
|
#define GOBERR_PROFILE_ON 17
|
|
#define GOBERR_NO_EXTENDED 18
|
|
#define GOBERR_DUP_HASH 19
|
|
#define GOBERR_TOO_MANY_BLOCKS 20
|
|
#define GOBERR_COMPRESS_FAIL 21
|
|
#define GOBERR_NO_SUITABLE_CODEC 22
|
|
|
|
#define GOBACCESS_READ 0
|
|
#define GOBACCESS_WRITE 1
|
|
#define GOBACCESS_RW 2
|
|
|
|
#define GOBSEEK_START 0
|
|
#define GOBSEEK_CURRENT 1
|
|
#define GOBSEEK_END 2
|
|
|
|
#define GOB_CODEC_MASK(n) ((GOBUInt32)(1u<<(n)))
|
|
#define GOB_CODEC_MASK_ANY ((GOBUInt32)(-1))
|
|
|
|
#define GOBMARKER_STARTBLOCK ('L' | 'B' << 8 | 'T' << 16 | 'S' << 24)
|
|
#define GOBMARKER_ENDBLOCK ('L' | 'B' << 8 | 'N' << 16 | 'E' << 24)
|
|
|
|
typedef int int32;
|
|
typedef unsigned int uint32;
|
|
//#define bool int
|
|
//#define false 0
|
|
//#define true 1
|
|
typedef unsigned long ulong;
|
|
typedef unsigned char byte;
|
|
|
|
typedef int32 GOBInt32;
|
|
typedef uint32 GOBUInt32;
|
|
typedef char GOBChar;
|
|
typedef bool GOBBool;
|
|
typedef int32 GOBError;
|
|
typedef int32 GOBSeekType;
|
|
typedef int32 GOBHandle;
|
|
typedef int32 GOBAccessType;
|
|
typedef void* GOBFSHandle;
|
|
typedef void GOBVoid;
|
|
|
|
typedef GOBFSHandle (*GOBFileSysOpenFunc)(GOBChar*, GOBAccessType);
|
|
typedef GOBBool (*GOBFileSysCloseFunc)(GOBFSHandle*);
|
|
typedef GOBInt32 (*GOBFileSysReadFunc)(GOBFSHandle, GOBVoid*, GOBInt32);
|
|
typedef GOBInt32 (*GOBFileSysWriteFunc)(GOBFSHandle, GOBVoid*, GOBInt32);
|
|
typedef GOBInt32 (*GOBFileSysSeekFunc)(GOBFSHandle, GOBInt32, GOBSeekType);
|
|
typedef GOBInt32 (*GOBFileSysRenameFunc)(GOBChar*, GOBChar*);
|
|
|
|
typedef GOBVoid* (*GOBMemAllocFunc)(GOBUInt32);
|
|
typedef GOBVoid (*GOBMemFreeFunc)(GOBVoid*);
|
|
|
|
typedef GOBInt32 (*GOBCompressFunc)(GOBVoid*, GOBUInt32, GOBVoid*, GOBUInt32*);
|
|
typedef GOBInt32 (*GOBDecompressFunc)(GOBVoid*, GOBUInt32, GOBVoid*, GOBUInt32*);
|
|
|
|
typedef GOBBool (*GOBCacheFileOpenFunc)(GOBUInt32);
|
|
typedef GOBBool (*GOBCacheFileCloseFunc)(GOBVoid);
|
|
typedef GOBInt32 (*GOBCacheFileReadFunc)(GOBVoid*, GOBInt32);
|
|
typedef GOBInt32 (*GOBCacheFileWriteFunc)(GOBVoid*, GOBInt32);
|
|
typedef GOBInt32 (*GOBCacheFileSeekFunc)(GOBInt32);
|
|
|
|
struct GOBBlockTableEntry
|
|
{
|
|
GOBUInt32 size; // compressed size
|
|
GOBUInt32 offset;
|
|
GOBUInt32 next;
|
|
};
|
|
|
|
struct GOBFileTableBasicEntry
|
|
{
|
|
GOBUInt32 hash;
|
|
GOBUInt32 size; // decompressed size
|
|
GOBUInt32 block;
|
|
};
|
|
|
|
struct GOBFileTableExtEntry
|
|
{
|
|
GOBChar name[GOB_MAX_FILE_NAME_LEN];
|
|
GOBUInt32 crc;
|
|
GOBUInt32 time;
|
|
};
|
|
|
|
struct GOBMemoryFuncSet
|
|
{
|
|
GOBMemAllocFunc alloc;
|
|
GOBMemFreeFunc free;
|
|
};
|
|
|
|
struct GOBSingleCodecDesc
|
|
{
|
|
GOBChar tag;
|
|
GOBInt32 max_ratio;
|
|
GOBCompressFunc compress;
|
|
GOBDecompressFunc decompress;
|
|
};
|
|
|
|
struct GOBCodecFuncSet
|
|
{
|
|
GOBInt32 codecs;
|
|
struct GOBSingleCodecDesc codec[GOB_MAX_CODECS];
|
|
};
|
|
|
|
struct GOBFileSysFuncSet
|
|
{
|
|
GOBFileSysOpenFunc open;
|
|
GOBFileSysCloseFunc close;
|
|
GOBFileSysReadFunc read;
|
|
GOBFileSysWriteFunc write;
|
|
GOBFileSysSeekFunc seek;
|
|
};
|
|
|
|
struct GOBCacheFileFuncSet
|
|
{
|
|
GOBCacheFileOpenFunc open;
|
|
GOBCacheFileCloseFunc close;
|
|
GOBCacheFileReadFunc read;
|
|
GOBCacheFileWriteFunc write;
|
|
GOBCacheFileSeekFunc seek;
|
|
};
|
|
|
|
struct GOBReadStats
|
|
{
|
|
GOBUInt32 bufferUsed;
|
|
GOBUInt32 bytesRead;
|
|
GOBUInt32 cacheBytesRead;
|
|
GOBUInt32 cacheBytesWrite;
|
|
GOBUInt32 totalSeeks;
|
|
GOBUInt32 farSeeks;
|
|
GOBUInt32 filesOpened;
|
|
};
|
|
|
|
extern GOBError GOBInit(struct GOBMemoryFuncSet* mem,
|
|
struct GOBFileSysFuncSet* file,
|
|
struct GOBCodecFuncSet* codec,
|
|
struct GOBCacheFileFuncSet* cache);
|
|
extern GOBError GOBShutdown(GOBVoid);
|
|
|
|
extern GOBError GOBArchiveCreate(const GOBChar* file);
|
|
extern GOBError GOBArchiveOpen(const GOBChar* file, GOBAccessType atype,
|
|
GOBBool extended, GOBBool safe);
|
|
extern GOBError GOBArchiveClose(GOBVoid);
|
|
extern GOBError GOBArchiveCheckMarkers(GOBVoid);
|
|
|
|
extern GOBError GOBOpen(GOBChar* file, GOBHandle* handle);
|
|
extern GOBError GOBOpenCode(GOBInt32 code, GOBHandle* handle);
|
|
extern GOBError GOBClose(GOBHandle handle);
|
|
|
|
extern GOBUInt32 GOBRead(GOBVoid* buffer, GOBUInt32 size, GOBHandle handle);
|
|
extern GOBError GOBSeek(GOBHandle handle, GOBUInt32 offset, GOBSeekType type, GOBUInt32* pos);
|
|
|
|
extern GOBError GOBWrite(GOBVoid* buffer, GOBUInt32 size, GOBUInt32 mtime, const GOBChar* file, GOBUInt32 codec_mask);
|
|
extern GOBError GOBDelete(const GOBChar* file);
|
|
|
|
extern GOBError GOBRearrange(const GOBChar* file, const GOBUInt32* xlat, GOBFileSysRenameFunc _rename);
|
|
|
|
extern GOBError GOBVerify(const GOBChar* file, GOBBool* status);
|
|
|
|
extern GOBError GOBGetSize(const GOBChar* file, GOBUInt32* decomp, GOBUInt32* comp, GOBUInt32* slack);
|
|
extern GOBError GOBGetTime(const GOBChar* file, GOBUInt32* time);
|
|
extern GOBError GOBGetCRC(const GOBChar* file, GOBUInt32* crc);
|
|
|
|
extern GOBError GOBAccess(const GOBChar* file, GOBBool* status);
|
|
extern GOBInt32 GOBGetFileCode(const GOBChar* file);
|
|
|
|
extern GOBError GOBGetFileTables(struct GOBFileTableBasicEntry** basic, struct GOBFileTableExtEntry** ext);
|
|
extern GOBError GOBGetBlockTable(struct GOBBlockTableEntry** table, GOBUInt32* num);
|
|
extern GOBUInt32 GOBGetSlack(GOBUInt32 x);
|
|
|
|
extern GOBError GOBSetCacheSize(GOBUInt32 num);
|
|
extern GOBError GOBSetReadBufferSize(GOBUInt32 size);
|
|
|
|
extern struct GOBReadStats GOBGetReadStats(GOBVoid);
|
|
|
|
|
|
typedef GOBVoid (*GOBProfileReadFunc)(GOBUInt32);
|
|
struct GOBProfileFuncSet
|
|
{
|
|
GOBProfileReadFunc read;
|
|
};
|
|
extern GOBVoid GOBSetProfileFuncs(struct GOBProfileFuncSet* fset);
|
|
|
|
extern GOBError GOBStartProfile(GOBVoid);
|
|
extern GOBError GOBStopProfile(GOBVoid);
|
|
|
|
|
|
#ifdef __cplusplus
|
|
} /* extern "C" */
|
|
#endif
|
|
|
|
|
|
#endif /* GOBLIB_H__ */
|