From 170916201c2dd8b75dccefb9a39c6fee572a4ec9 Mon Sep 17 00:00:00 2001 From: Max Horn Date: Fri, 27 Feb 2009 02:23:00 +0000 Subject: SCI: Moved almost all files from include/ to other dirs; only include/engine.h remains svn-id: r38920 --- engines/sci/scicore/resource.h | 423 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 423 insertions(+) create mode 100644 engines/sci/scicore/resource.h (limited to 'engines/sci/scicore/resource.h') diff --git a/engines/sci/scicore/resource.h b/engines/sci/scicore/resource.h new file mode 100644 index 0000000000..2b6c4b0474 --- /dev/null +++ b/engines/sci/scicore/resource.h @@ -0,0 +1,423 @@ +/* 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 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. + * + * $URL$ + * $Id$ + * + */ + +#ifndef SCI_SCICORE_RESOURCE_H +#define SCI_SCICORE_RESOURCE_H + +#include "common/str.h" + +namespace Common { + class ReadStream; +} + +namespace Sci { + +/** The maximum allowed size for a compressed or decompressed resource */ +#define SCI_MAX_RESOURCE_SIZE 0x0400000 + +/*** RESOURCE STATUS TYPES ***/ +#define SCI_STATUS_NOMALLOC 0 +#define SCI_STATUS_ALLOCATED 1 +#define SCI_STATUS_ENQUEUED 2 /* In the LRU queue */ +#define SCI_STATUS_LOCKED 3 /* Allocated and in use */ + +#define SCI_RES_FILE_NR_PATCH -1 /* Resource was read from a patch file rather than from a resource */ + + +/*** INITIALIZATION RESULT TYPES ***/ +#define SCI_ERROR_IO_ERROR 1 +#define SCI_ERROR_EMPTY_OBJECT 2 +#define SCI_ERROR_INVALID_RESMAP_ENTRY 3 +/* Invalid resource.map entry */ +#define SCI_ERROR_RESMAP_NOT_FOUND 4 +#define SCI_ERROR_NO_RESOURCE_FILES_FOUND 5 +/* No resource at all was found */ +#define SCI_ERROR_UNKNOWN_COMPRESSION 6 +#define SCI_ERROR_DECOMPRESSION_OVERFLOW 7 +/* decompression failed: Buffer overflow (wrong SCI version?) */ +#define SCI_ERROR_DECOMPRESSION_INSANE 8 +/* sanity checks failed during decompression */ +#define SCI_ERROR_RESOURCE_TOO_BIG 9 +/* Resource size exceeds SCI_MAX_RESOURCE_SIZE */ +#define SCI_ERROR_UNSUPPORTED_VERSION 10 +#define SCI_ERROR_INVALID_SCRIPT_VERSION 11 + +#define SCI_ERROR_CRITICAL SCI_ERROR_NO_RESOURCE_FILES_FOUND +/* the first critical error number */ + +/*** SCI VERSION NUMBERS ***/ +#define SCI_VERSION_AUTODETECT 0 +#define SCI_VERSION_0 1 +#define SCI_VERSION_01 2 +#define SCI_VERSION_01_VGA 3 +#define SCI_VERSION_01_VGA_ODD 4 +#define SCI_VERSION_1_EARLY 5 +#define SCI_VERSION_1_LATE 6 +#define SCI_VERSION_1_1 7 +#define SCI_VERSION_32 8 +#define SCI_VERSION_LAST SCI_VERSION_1_LATE /* The last supported SCI version */ + +#define SCI_VERSION_1 SCI_VERSION_1_EARLY + +enum ResourceType { + RESSOURCE_TYPE_DIRECTORY = 0, + RESSOURCE_TYPE_VOLUME = 2, + RESSOURCE_TYPE_EXTERNAL_MAP = 3, + RESSOURCE_TYPE_INTERNAL_MAP = 4, + RESSOURCE_TYPE_MASK = 127 +}; + +#define RESSOURCE_ADDRESSING_BASIC 0 +#define RESSOURCE_ADDRESSING_EXTENDED 128 +#define RESSOURCE_ADDRESSING_MASK 128 + +extern const char* sci_error_types[]; +extern const char* sci_version_types[]; +extern const char* sci_resource_types[]; +extern const char* sci_resource_type_suffixes[]; /* Suffixes for SCI1 patch files */ +extern const int sci_max_resource_nr[]; /* Highest possible resource numbers */ + + +enum ResourceTypes { + sci_view = 0, sci_pic, sci_script, sci_text, + sci_sound, sci_memory, sci_vocab, sci_font, + sci_cursor, sci_patch, sci_bitmap, sci_palette, + sci_cdaudio, sci_audio, sci_sync, sci_message, + sci_map, sci_heap, sci_invalid_resource +}; + +#define sci0_last_resource sci_patch +#define sci1_last_resource sci_heap +/* Used for autodetection */ + + +struct resource_index_struct { + unsigned short resource_id; + unsigned int resource_location; +}; /* resource type as stored in the resource.map file */ + +typedef struct resource_index_struct resource_index_t; + +struct ResourceSource { + ResourceType source_type; + bool scanned; + Common::String location_name; // FIXME: Replace by FSNode ? + Common::String location_dir_name; // FIXME: Get rid of this again, only a temporary HACK! + int volume_number; + ResourceSource *associated_map; + ResourceSource *next; +}; + +struct resource_altsource_t { + ResourceSource *source; + unsigned int file_offset; + resource_altsource_t *next; +}; + + +/** Struct for storing resources in memory */ +struct resource_t { + unsigned char *data; + + unsigned short number; + unsigned short type; + uint16 id; /* contains number and type */ + + unsigned int size; + + unsigned int file_offset; /* Offset in file */ + ResourceSource *source; + + unsigned char status; + unsigned short lockers; /* Number of places where this resource was locked */ + + resource_t *next; /* Position marker for the LRU queue */ + resource_t *prev; + + resource_altsource_t *alt_sources; /* SLL of alternative resource data sources */ +}; + + +struct ResourceManager { + int _maxMemory; /* Config option: Maximum total byte number allocated */ + int sci_version; /* SCI resource version to use */ + + int _resourcesNr; + ResourceSource *_sources; + resource_t *_resources; + + int memory_locked; /* Amount of resource bytes in locked memory */ + int memory_lru; /* Amount of resource bytes under LRU control */ + + resource_t *lru_first, *lru_last; /* Pointers to the first and last LRU queue entries */ + /* LRU queue: lru_first points to the most recent entry */ + +public: + /** + * Creates a new FreeSCI resource manager. + * @param version The SCI version to look for; use SCI_VERSION_AUTODETECT + * in the default case. + * @param maxMemory Maximum number of bytes to allow allocated for resources + * + * @note maxMemory will not be interpreted as a hard limit, only as a restriction + * for resources which are not explicitly locked. However, a warning will be + * issued whenever this limit is exceeded. + */ + ResourceManager(int version, int maxMemory); + ~ResourceManager(); +}; + +/**** FUNCTION DECLARATIONS ****/ + +/**--- New Resource manager ---**/ + +ResourceSource *scir_add_patch_dir(ResourceManager *mgr, const char *path); +/* Add a path to the resource manager's list of sources. +** Parameters: (ResourceManager *) mgr: The resource manager to look up in +** (const char *) path: The path to add +** Returns: A pointer to the added source structure, or NULL if an error occurred. +*/ + +ResourceSource *scir_get_volume(ResourceManager *mgr, ResourceSource *map, int volume_nr); + +ResourceSource *scir_add_volume(ResourceManager *mgr, ResourceSource *map, const char *filename, + int number, int extended_addressing); +/* Add a volume to the resource manager's list of sources. +** Parameters: (ResourceManager *) mgr: The resource manager to look up in +** (ResourceSource *) map: The map associated with this volume +** (char *) filename: The name of the volume to add +** (int) extended_addressing: 1 if this volume uses extended addressing, +** 0 otherwise. +** Returns: A pointer to the added source structure, or NULL if an error occurred. +*/ + +ResourceSource *scir_add_external_map(ResourceManager *mgr, const char *file_name); +/* Add an external (i.e. separate file) map resource to the resource manager's list of sources. +** Parameters: (ResourceManager *) mgr: The resource manager to look up in +** (const char *) file_name: The name of the volume to add +** Returns: A pointer to the added source structure, or NULL if an error occurred. +*/ + +int scir_scan_new_sources(ResourceManager *mgr, int *detected_version); +/* Scans newly registered resource sources for resources, earliest addition first. +** Parameters: (ResourceManager *) mgr: The resource manager to look up in +** (int *) detected_version: Pointer to the detected version number, +** used during startup. May be NULL. +** Returns: One of SCI_ERROR_*. +*/ + +resource_t *scir_find_resource(ResourceManager *mgr, int type, int number, int lock); +/* Looks up a resource's data +** Parameters: (ResourceManager *) mgr: The resource manager to look up in +** (int) type: The resource type to look for +** (int) number: The resource number to search +** (int) lock: non-zero iff the resource should be locked +** Returns : (resource_t *): The resource, or NULL if it doesn't exist +** Locked resources are guaranteed not to have their contents freed until +** they are unlocked explicitly (by scir_unlock_resource). +*/ + +void scir_unlock_resource(ResourceManager *mgr, resource_t *res, int restype, int resnum); +/* Unlocks a previously locked resource +** Parameters: (ResourceManager *) mgr: The manager the resource should be freed from +** (resource_t *) res: The resource to free +** (int) type: Type of the resource to check (for error checking) +** (int) number: Number of the resource to check (ditto) +** Returns : (void) +*/ + +resource_t *scir_test_resource(ResourceManager *mgr, int type, int number); +/* Tests whether a resource exists +** Parameters: (ResourceManager *) mgr: The resource manager to search in +** (int) type: Type of the resource to check +** (int) number: Number of the resource to check +** Returns : (resource_t *) non-NULL if the resource exists, NULL otherwise +** This function may often be much faster than finding the resource +** and should be preferred for simple tests. +** The resource object returned is, indeed, the resource in question, but +** it should be used with care, as it may be unallocated. +** Use scir_find_resource() if you want to use the data contained in the resource. +*/ + +/**--- Resource map decoding functions ---*/ + +int sci0_read_resource_map(ResourceManager *mgr, ResourceSource *map, resource_t **resources, int *resource_nr_p, int *sci_version); +/* Reads the SCI0 resource.map file from a local directory +** Parameters: (char *) path: (unused) +** (resource_t **) resources: Pointer to a pointer +** that will be set to the +** location of the resources +** (in one large chunk) +** (int *) resource_nr_p: Pointer to an int the number of resources +** read is stored in +** (int) sci_version: SCI resource version +** Returns : (int) 0 on success, an SCI_ERROR_* code otherwise +*/ + +int sci1_read_resource_map(ResourceManager *mgr, ResourceSource *map, ResourceSource *vol, + resource_t **resource_p, int *resource_nr_p, int *sci_version); +/* Reads the SCI1 resource.map file from a local directory +** Parameters: (char *) path: (unused) +** (resource_t **) resources: Pointer to a pointer +** that will be set to the +** location of the resources +** (in one large chunk) +** (int *) resource_nr_p: Pointer to an int the number of resources +** read is stored in +** (int) sci_version: SCI resource version +** Returns : (int) 0 on success, an SCI_ERROR_* code otherwise +*/ + +/**--- Patch management functions ---*/ + +void sci0_sprintf_patch_file_name(char *string, resource_t *res); +/* Prints the name of a matching patch to a string buffer +** Parameters: (char *) string: The buffer to print to +** (resource_t *) res: Resource containing the number and type of the +** resource whose name is to be print +** Returns : (void) +*/ + +void sci1_sprintf_patch_file_name(char *string, resource_t *res); +/* Prints the name of a matching patch to a string buffer +** Parameters: (char *) string: The buffer to print to +** (resource_t *) res: Resource containing the number and type of the +** resource whose name is to be print +** Returns : (void) +*/ + +int sci0_read_resource_patches(ResourceSource *source, resource_t **resources, int *resource_nr_p); +/* Reads SCI0 patch files from a local directory +** Parameters: (char *) path: (unused) +** (resource_t **) resources: Pointer to a pointer +** that will be set to the +** location of the resources +** (in one large chunk) +** (int *) resource_nr_p: Pointer to an int the number of resources +** read is stored in +** Returns : (int) 0 on success, an SCI_ERROR_* code otherwise +*/ + +int sci1_read_resource_patches(ResourceSource *source, resource_t **resources, int *resource_nr_p); +/* Reads SCI1 patch files from a local directory +** Parameters: (char *) path: (unused) +** (resource_t **) resources: Pointer to a pointer +** that will be set to the +** location of the resources +** (in one large chunk) +** (int *) resource_nr_p: Pointer to an int the number of resources +** read is stored in +** Returns : (int) 0 on success, an SCI_ERROR_* code otherwise +*/ + + +/**--- Decompression functions ---**/ + + +int decompress0(resource_t *result, Common::ReadStream &stream, int sci_version); +/* Decrypts resource data and stores the result for SCI0-style compression. +** Parameters : result: The resource_t the decompressed data is stored in. +** stream: Stream of the resource file +** sci_version : Actual SCI resource version +** Returns : (int) 0 on success, one of SCI_ERROR_* if a problem was +** encountered. +*/ + +int decompress01(resource_t *result, Common::ReadStream &stream, int sci_version); +/* Decrypts resource data and stores the result for SCI01-style compression. +** Parameters : result: The resource_t the decompressed data is stored in. +** stream: Stream of the resource file +** sci_version : Actual SCI resource version +** Returns : (int) 0 on success, one of SCI_ERROR_* if a problem was +** encountered. +*/ + +int decompress1(resource_t *result, Common::ReadStream &stream, int sci_version); +/* Decrypts resource data and stores the result for SCI1.1-style compression. +** Parameters : result: The resource_t the decompressed data is stored in. +** sci_version : Actual SCI resource version +** stream: Stream of the resource file +** Returns : (int) 0 on success, one of SCI_ERROR_* if a problem was +** encountered. +*/ + + +int decompress11(resource_t *result, Common::ReadStream &stream, int sci_version); +/* Decrypts resource data and stores the result for SCI1.1-style compression. +** Parameters : result: The resource_t the decompressed data is stored in. +** sci_version : Actual SCI resource version +** stream: Stream of the resource file +** Returns : (int) 0 on success, one of SCI_ERROR_* if a problem was +** encountered. +*/ + + +int decrypt2(uint8* dest, uint8* src, int length, int complength); +/* Huffman token decryptor - defined in decompress0.c and used in decompress01.c +*/ + +int decrypt4(uint8* dest, uint8* src, int length, int complength); +/* DCL inflate- implemented in decompress1.c +*/ + +byte *view_reorder(byte *inbuffer, int dsize); +/* SCI1 style view compression */ + +byte *pic_reorder(byte *inbuffer, int dsize); +/* SCI1 style pic compression */ + +/*--- Internal helper functions ---*/ + +void _scir_free_resources(resource_t *resources, int _resourcesNr); +/* Frees a block of resources and associated data +** Parameters: (resource_t *) resources: The resources to free +** (int) _resourcesNr: Number of resources in the block +** Returns : (void) +*/ + +resource_t *_scir_find_resource_unsorted(resource_t *res, int res_nr, int type, int number); +/* Finds a resource matching type.number in an unsorted resource_t block +** To be used during initial resource loading, when the resource list +** may not have been sorted yet. +** Parameters: (resource_t *) res: Pointer to the block to search in +** (int) res_nr: Number of resource_t structs allocated and defined +** in the block pointed to by res +** (int) type: Type of the resource to look for +** (int) number: Number of the resource to look for +** Returns : (resource_t) The matching resource entry, or NULL if not found +*/ + +void _scir_add_altsource(resource_t *res, ResourceSource *source, unsigned int file_offset); +/* Adds an alternative source to a resource +** Parameters: (resource_t *) res: The resource to add to +** (ResourceSource *) source: The source of the resource +** (unsigned int) file_offset: Offset in the file the resource +** is stored at +** Returns : (void) +*/ + +} // End of namespace Sci + +#endif // SCI_SCICORE_RESOURCE_H -- cgit v1.2.3