Mercurial > hg > dmlib
annotate dmres.c @ 730:3d813c81f33c
More work on resources API.
| author | Matti Hamalainen <ccr@tnsp.org> |
|---|---|
| date | Sun, 21 Apr 2013 19:29:00 +0300 |
| parents | 867fc7f205a8 |
| children | 0e164aaa7409 |
| rev | line source |
|---|---|
| 0 | 1 /* |
| 2 * dmlib | |
| 3 * -- Resource management | |
| 4 * Programmed and designed by Matti 'ccr' Hamalainen | |
|
721
bb14d7907eb2
Rename many pack & resource handling functions.
Matti Hamalainen <ccr@tnsp.org>
parents:
630
diff
changeset
|
5 * (C) Copyright 2003-2013 Tecnic Software productions (TNSP) |
| 0 | 6 */ |
| 7 #include "dmres.h" | |
| 8 #include <time.h> | |
| 9 | |
|
719
eb4bd1f7b679
Sanitize some more includes.
Matti Hamalainen <ccr@tnsp.org>
parents:
630
diff
changeset
|
10 #ifdef DM_USE_PACKFS |
|
eb4bd1f7b679
Sanitize some more includes.
Matti Hamalainen <ccr@tnsp.org>
parents:
630
diff
changeset
|
11 #include <zlib.h> |
|
eb4bd1f7b679
Sanitize some more includes.
Matti Hamalainen <ccr@tnsp.org>
parents:
630
diff
changeset
|
12 #endif |
|
eb4bd1f7b679
Sanitize some more includes.
Matti Hamalainen <ccr@tnsp.org>
parents:
630
diff
changeset
|
13 |
|
625
e8fc083b7499
More work on resource management.
Matti Hamalainen <ccr@tnsp.org>
parents:
613
diff
changeset
|
14 #ifdef DM_USE_STDIO |
| 630 | 15 #include <sys/types.h> |
| 16 #include <sys/stat.h> | |
| 17 #include <unistd.h> | |
| 18 #include <dirent.h> | |
|
625
e8fc083b7499
More work on resource management.
Matti Hamalainen <ccr@tnsp.org>
parents:
613
diff
changeset
|
19 #endif |
|
e8fc083b7499
More work on resource management.
Matti Hamalainen <ccr@tnsp.org>
parents:
613
diff
changeset
|
20 |
| 0 | 21 |
|
721
bb14d7907eb2
Rename many pack & resource handling functions.
Matti Hamalainen <ccr@tnsp.org>
parents:
630
diff
changeset
|
22 DMResource *dmResourceNew(DMResourceLib *lib, const char *filename, const size_t size) |
| 0 | 23 { |
|
27
21c14afbf63d
Modularize the resource system a bit.
Matti Hamalainen <ccr@tnsp.org>
parents:
26
diff
changeset
|
24 DMResource *node = dmMalloc0(sizeof(DMResource)); |
|
21c14afbf63d
Modularize the resource system a bit.
Matti Hamalainen <ccr@tnsp.org>
parents:
26
diff
changeset
|
25 if (node == NULL) |
| 0 | 26 return NULL; |
| 27 | |
|
359
59045853853d
Make resource management re-entrant.
Matti Hamalainen <ccr@tnsp.org>
parents:
237
diff
changeset
|
28 node->lib = lib; |
|
27
21c14afbf63d
Modularize the resource system a bit.
Matti Hamalainen <ccr@tnsp.org>
parents:
26
diff
changeset
|
29 node->filename = dm_strdup(filename); |
|
721
bb14d7907eb2
Rename many pack & resource handling functions.
Matti Hamalainen <ccr@tnsp.org>
parents:
630
diff
changeset
|
30 node->rawSize = size; |
| 0 | 31 |
|
27
21c14afbf63d
Modularize the resource system a bit.
Matti Hamalainen <ccr@tnsp.org>
parents:
26
diff
changeset
|
32 return node; |
|
21c14afbf63d
Modularize the resource system a bit.
Matti Hamalainen <ccr@tnsp.org>
parents:
26
diff
changeset
|
33 } |
|
21c14afbf63d
Modularize the resource system a bit.
Matti Hamalainen <ccr@tnsp.org>
parents:
26
diff
changeset
|
34 |
|
21c14afbf63d
Modularize the resource system a bit.
Matti Hamalainen <ccr@tnsp.org>
parents:
26
diff
changeset
|
35 |
|
721
bb14d7907eb2
Rename many pack & resource handling functions.
Matti Hamalainen <ccr@tnsp.org>
parents:
630
diff
changeset
|
36 void dmResourceFreeResData(DMResource *node) |
|
27
21c14afbf63d
Modularize the resource system a bit.
Matti Hamalainen <ccr@tnsp.org>
parents:
26
diff
changeset
|
37 { |
|
721
bb14d7907eb2
Rename many pack & resource handling functions.
Matti Hamalainen <ccr@tnsp.org>
parents:
630
diff
changeset
|
38 if (node->resData != NULL && |
|
27
21c14afbf63d
Modularize the resource system a bit.
Matti Hamalainen <ccr@tnsp.org>
parents:
26
diff
changeset
|
39 node->rops != NULL && |
|
21c14afbf63d
Modularize the resource system a bit.
Matti Hamalainen <ccr@tnsp.org>
parents:
26
diff
changeset
|
40 node->rops->free != NULL) |
|
21c14afbf63d
Modularize the resource system a bit.
Matti Hamalainen <ccr@tnsp.org>
parents:
26
diff
changeset
|
41 { |
|
21c14afbf63d
Modularize the resource system a bit.
Matti Hamalainen <ccr@tnsp.org>
parents:
26
diff
changeset
|
42 node->rops->free(node); |
|
21c14afbf63d
Modularize the resource system a bit.
Matti Hamalainen <ccr@tnsp.org>
parents:
26
diff
changeset
|
43 } |
|
21c14afbf63d
Modularize the resource system a bit.
Matti Hamalainen <ccr@tnsp.org>
parents:
26
diff
changeset
|
44 |
|
721
bb14d7907eb2
Rename many pack & resource handling functions.
Matti Hamalainen <ccr@tnsp.org>
parents:
630
diff
changeset
|
45 node->resData = NULL; |
|
728
867fc7f205a8
More work on resource handling cleanup.
Matti Hamalainen <ccr@tnsp.org>
parents:
727
diff
changeset
|
46 node->flags &= ~DMF_LOADED_RES; |
| 0 | 47 } |
| 48 | |
| 49 | |
|
721
bb14d7907eb2
Rename many pack & resource handling functions.
Matti Hamalainen <ccr@tnsp.org>
parents:
630
diff
changeset
|
50 void dmResourceFreeRawData(DMResource *node) |
|
27
21c14afbf63d
Modularize the resource system a bit.
Matti Hamalainen <ccr@tnsp.org>
parents:
26
diff
changeset
|
51 { |
|
721
bb14d7907eb2
Rename many pack & resource handling functions.
Matti Hamalainen <ccr@tnsp.org>
parents:
630
diff
changeset
|
52 dmFree(node->rawData); |
|
bb14d7907eb2
Rename many pack & resource handling functions.
Matti Hamalainen <ccr@tnsp.org>
parents:
630
diff
changeset
|
53 node->rawData = NULL; |
|
728
867fc7f205a8
More work on resource handling cleanup.
Matti Hamalainen <ccr@tnsp.org>
parents:
727
diff
changeset
|
54 node->flags &= ~DMF_LOADED_RAW; |
|
27
21c14afbf63d
Modularize the resource system a bit.
Matti Hamalainen <ccr@tnsp.org>
parents:
26
diff
changeset
|
55 } |
|
21c14afbf63d
Modularize the resource system a bit.
Matti Hamalainen <ccr@tnsp.org>
parents:
26
diff
changeset
|
56 |
|
21c14afbf63d
Modularize the resource system a bit.
Matti Hamalainen <ccr@tnsp.org>
parents:
26
diff
changeset
|
57 |
|
721
bb14d7907eb2
Rename many pack & resource handling functions.
Matti Hamalainen <ccr@tnsp.org>
parents:
630
diff
changeset
|
58 void dmResourceFree(DMResource *node) |
|
27
21c14afbf63d
Modularize the resource system a bit.
Matti Hamalainen <ccr@tnsp.org>
parents:
26
diff
changeset
|
59 { |
|
21c14afbf63d
Modularize the resource system a bit.
Matti Hamalainen <ccr@tnsp.org>
parents:
26
diff
changeset
|
60 if (node != NULL) |
| 0 | 61 { |
|
721
bb14d7907eb2
Rename many pack & resource handling functions.
Matti Hamalainen <ccr@tnsp.org>
parents:
630
diff
changeset
|
62 dmResourceFreeResData(node); |
|
bb14d7907eb2
Rename many pack & resource handling functions.
Matti Hamalainen <ccr@tnsp.org>
parents:
630
diff
changeset
|
63 dmResourceFreeRawData(node); |
|
27
21c14afbf63d
Modularize the resource system a bit.
Matti Hamalainen <ccr@tnsp.org>
parents:
26
diff
changeset
|
64 dmFree(node->filename); |
|
21c14afbf63d
Modularize the resource system a bit.
Matti Hamalainen <ccr@tnsp.org>
parents:
26
diff
changeset
|
65 dmFree(node); |
| 0 | 66 } |
| 67 } | |
| 68 | |
| 69 | |
|
721
bb14d7907eb2
Rename many pack & resource handling functions.
Matti Hamalainen <ccr@tnsp.org>
parents:
630
diff
changeset
|
70 void dmResourceInsert(DMResourceLib *lib, DMResource * node) |
| 0 | 71 { |
|
625
e8fc083b7499
More work on resource management.
Matti Hamalainen <ccr@tnsp.org>
parents:
613
diff
changeset
|
72 if (lib == NULL || node == NULL) |
|
359
59045853853d
Make resource management re-entrant.
Matti Hamalainen <ccr@tnsp.org>
parents:
237
diff
changeset
|
73 return; |
|
59045853853d
Make resource management re-entrant.
Matti Hamalainen <ccr@tnsp.org>
parents:
237
diff
changeset
|
74 |
|
59045853853d
Make resource management re-entrant.
Matti Hamalainen <ccr@tnsp.org>
parents:
237
diff
changeset
|
75 node->lib = lib; |
|
59045853853d
Make resource management re-entrant.
Matti Hamalainen <ccr@tnsp.org>
parents:
237
diff
changeset
|
76 |
|
59045853853d
Make resource management re-entrant.
Matti Hamalainen <ccr@tnsp.org>
parents:
237
diff
changeset
|
77 if (lib->resources != NULL) |
| 0 | 78 { |
|
359
59045853853d
Make resource management re-entrant.
Matti Hamalainen <ccr@tnsp.org>
parents:
237
diff
changeset
|
79 node->prev = lib->resources->prev; |
|
59045853853d
Make resource management re-entrant.
Matti Hamalainen <ccr@tnsp.org>
parents:
237
diff
changeset
|
80 lib->resources->prev->next = node; |
|
59045853853d
Make resource management re-entrant.
Matti Hamalainen <ccr@tnsp.org>
parents:
237
diff
changeset
|
81 lib->resources->prev = node; |
| 0 | 82 } |
| 83 else | |
| 84 { | |
|
359
59045853853d
Make resource management re-entrant.
Matti Hamalainen <ccr@tnsp.org>
parents:
237
diff
changeset
|
85 lib->resources = node->prev = node; |
| 0 | 86 } |
| 87 | |
| 88 node->next = NULL; | |
| 89 } | |
| 90 | |
| 91 | |
|
721
bb14d7907eb2
Rename many pack & resource handling functions.
Matti Hamalainen <ccr@tnsp.org>
parents:
630
diff
changeset
|
92 void dmResourceDelete(DMResourceLib *lib, DMResource * node) |
| 0 | 93 { |
|
359
59045853853d
Make resource management re-entrant.
Matti Hamalainen <ccr@tnsp.org>
parents:
237
diff
changeset
|
94 if (lib == NULL) |
|
59045853853d
Make resource management re-entrant.
Matti Hamalainen <ccr@tnsp.org>
parents:
237
diff
changeset
|
95 return; |
|
59045853853d
Make resource management re-entrant.
Matti Hamalainen <ccr@tnsp.org>
parents:
237
diff
changeset
|
96 |
| 0 | 97 if (node->prev) |
| 98 node->prev->next = node->next; | |
| 99 | |
| 100 if (node->next) | |
| 101 node->next->prev = node->prev; | |
| 102 else | |
|
359
59045853853d
Make resource management re-entrant.
Matti Hamalainen <ccr@tnsp.org>
parents:
237
diff
changeset
|
103 lib->resources->prev = node->prev; |
| 0 | 104 |
| 105 node->prev = node->next = NULL; | |
| 106 } | |
| 107 | |
| 108 | |
|
721
bb14d7907eb2
Rename many pack & resource handling functions.
Matti Hamalainen <ccr@tnsp.org>
parents:
630
diff
changeset
|
109 DMResource * dmResourceFind(DMResourceLib *lib, const char *filename) |
| 0 | 110 { |
| 111 DMResource *node, *found = NULL; | |
| 112 | |
|
359
59045853853d
Make resource management re-entrant.
Matti Hamalainen <ccr@tnsp.org>
parents:
237
diff
changeset
|
113 if (lib == NULL) |
|
59045853853d
Make resource management re-entrant.
Matti Hamalainen <ccr@tnsp.org>
parents:
237
diff
changeset
|
114 return NULL; |
| 0 | 115 |
|
359
59045853853d
Make resource management re-entrant.
Matti Hamalainen <ccr@tnsp.org>
parents:
237
diff
changeset
|
116 dmMutexLock(lib->mutex); |
|
59045853853d
Make resource management re-entrant.
Matti Hamalainen <ccr@tnsp.org>
parents:
237
diff
changeset
|
117 |
|
59045853853d
Make resource management re-entrant.
Matti Hamalainen <ccr@tnsp.org>
parents:
237
diff
changeset
|
118 for (node = lib->resources; node != NULL; node = node->next) |
| 0 | 119 { |
| 120 if (strcmp(node->filename, filename) == 0) | |
| 121 { | |
| 122 found = node; | |
| 123 break; | |
| 124 } | |
| 125 } | |
| 126 | |
|
359
59045853853d
Make resource management re-entrant.
Matti Hamalainen <ccr@tnsp.org>
parents:
237
diff
changeset
|
127 dmMutexUnlock(lib->mutex); |
| 0 | 128 |
| 129 return found; | |
| 130 } | |
| 131 | |
| 132 | |
|
124
d5cfd29c87c4
Rename some conditional compilation directives.
Matti Hamalainen <ccr@tnsp.org>
parents:
114
diff
changeset
|
133 #ifdef DM_USE_STDIO |
| 0 | 134 /* Basic stdio file routines |
| 135 */ | |
| 136 static int dm_stdio_fopen(DMResource *handle) | |
| 137 { | |
| 138 char *rfilename = dm_strdup_printf("%s%s", DMRES_DATA_PATH, handle->filename); | |
| 139 if (rfilename == NULL) | |
| 140 return DMERR_MALLOC; | |
| 141 | |
| 142 handle->fh = fopen(rfilename, "rb"); | |
| 143 dmFree(rfilename); | |
| 144 | |
| 145 handle->error = dmGetErrno(); | |
| 146 return (handle->fh != NULL) ? DMERR_OK : DMERR_FOPEN; | |
| 147 } | |
| 148 | |
| 149 | |
| 150 static void dm_stdio_fclose(DMResource * f) | |
| 151 { | |
| 152 if (f->fh != NULL) | |
| 153 { | |
| 154 fclose(f->fh); | |
| 155 f->fh = NULL; | |
| 156 } | |
| 157 } | |
| 158 | |
| 159 | |
| 160 static int dm_stdio_ferror(DMResource * f) | |
| 161 { | |
| 162 return f->error; | |
| 163 } | |
| 164 | |
| 165 | |
| 166 static int dm_stdio_fseek(DMResource *f, const off_t pos, const int whence) | |
| 167 { | |
| 168 int ret = fseek(f->fh, pos, whence); | |
| 169 f->error = dmGetErrno(); | |
| 170 return ret; | |
| 171 } | |
| 172 | |
| 173 | |
| 174 static off_t dm_stdio_fsize(DMResource *f) | |
| 175 { | |
| 176 off_t savePos, fileSize; | |
| 177 | |
| 178 // Check if the size is cached | |
|
721
bb14d7907eb2
Rename many pack & resource handling functions.
Matti Hamalainen <ccr@tnsp.org>
parents:
630
diff
changeset
|
179 if (f->rawSize != 0) |
|
bb14d7907eb2
Rename many pack & resource handling functions.
Matti Hamalainen <ccr@tnsp.org>
parents:
630
diff
changeset
|
180 return f->rawSize; |
| 0 | 181 |
| 182 // Get file size | |
|
406
a0160ffdf7e5
Use fseeko() and ftello() to ensure 64-bit off_t compatibility in stdio backend.
Matti Hamalainen <ccr@tnsp.org>
parents:
359
diff
changeset
|
183 savePos = ftello(f->fh); |
|
a0160ffdf7e5
Use fseeko() and ftello() to ensure 64-bit off_t compatibility in stdio backend.
Matti Hamalainen <ccr@tnsp.org>
parents:
359
diff
changeset
|
184 if (fseeko(f->fh, 0L, SEEK_END) != 0) |
| 0 | 185 { |
| 186 f->error = dmGetErrno(); | |
| 187 return -1; | |
| 188 } | |
| 189 | |
|
406
a0160ffdf7e5
Use fseeko() and ftello() to ensure 64-bit off_t compatibility in stdio backend.
Matti Hamalainen <ccr@tnsp.org>
parents:
359
diff
changeset
|
190 fileSize = ftello(f->fh); |
|
a0160ffdf7e5
Use fseeko() and ftello() to ensure 64-bit off_t compatibility in stdio backend.
Matti Hamalainen <ccr@tnsp.org>
parents:
359
diff
changeset
|
191 if (fseeko(f->fh, savePos, SEEK_SET) != 0) |
| 0 | 192 { |
| 193 f->error = dmGetErrno(); | |
| 194 return -1; | |
| 195 } | |
| 196 | |
|
721
bb14d7907eb2
Rename many pack & resource handling functions.
Matti Hamalainen <ccr@tnsp.org>
parents:
630
diff
changeset
|
197 f->rawSize = fileSize; |
| 0 | 198 return fileSize; |
| 199 } | |
| 200 | |
| 201 | |
| 202 static off_t dm_stdio_ftell(DMResource * f) | |
| 203 { | |
| 204 return ftell(f->fh); | |
| 205 } | |
| 206 | |
| 207 | |
| 208 static BOOL dm_stdio_feof(DMResource * f) | |
| 209 { | |
| 210 return feof(f->fh); | |
| 211 } | |
| 212 | |
| 213 | |
| 214 static int dm_stdio_fgetc(DMResource * f) | |
| 215 { | |
| 216 int ret = fgetc(f->fh); | |
| 217 f->error = dmGetErrno(); | |
| 218 return ret; | |
| 219 } | |
| 220 | |
| 221 | |
|
59
c560703e85ed
Add resource writing functions (only work for stdio backend)
Matti Hamalainen <ccr@tnsp.org>
parents:
33
diff
changeset
|
222 static int dm_stdio_fputc(int v, DMResource * f) |
|
c560703e85ed
Add resource writing functions (only work for stdio backend)
Matti Hamalainen <ccr@tnsp.org>
parents:
33
diff
changeset
|
223 { |
|
c560703e85ed
Add resource writing functions (only work for stdio backend)
Matti Hamalainen <ccr@tnsp.org>
parents:
33
diff
changeset
|
224 int ret = fputc(v, f->fh); |
|
c560703e85ed
Add resource writing functions (only work for stdio backend)
Matti Hamalainen <ccr@tnsp.org>
parents:
33
diff
changeset
|
225 f->error = dmGetErrno(); |
|
c560703e85ed
Add resource writing functions (only work for stdio backend)
Matti Hamalainen <ccr@tnsp.org>
parents:
33
diff
changeset
|
226 return ret; |
|
c560703e85ed
Add resource writing functions (only work for stdio backend)
Matti Hamalainen <ccr@tnsp.org>
parents:
33
diff
changeset
|
227 } |
|
c560703e85ed
Add resource writing functions (only work for stdio backend)
Matti Hamalainen <ccr@tnsp.org>
parents:
33
diff
changeset
|
228 |
|
c560703e85ed
Add resource writing functions (only work for stdio backend)
Matti Hamalainen <ccr@tnsp.org>
parents:
33
diff
changeset
|
229 |
| 0 | 230 static size_t dm_stdio_fread(void *ptr, size_t size, size_t nmemb, DMResource * f) |
| 231 { | |
| 232 size_t ret = fread(ptr, size, nmemb, f->fh); | |
| 233 f->error = dmGetErrno(); | |
| 234 return ret; | |
| 235 } | |
| 236 | |
| 237 | |
|
59
c560703e85ed
Add resource writing functions (only work for stdio backend)
Matti Hamalainen <ccr@tnsp.org>
parents:
33
diff
changeset
|
238 static size_t dm_stdio_fwrite(void *ptr, size_t size, size_t nmemb, DMResource * f) |
|
c560703e85ed
Add resource writing functions (only work for stdio backend)
Matti Hamalainen <ccr@tnsp.org>
parents:
33
diff
changeset
|
239 { |
|
c560703e85ed
Add resource writing functions (only work for stdio backend)
Matti Hamalainen <ccr@tnsp.org>
parents:
33
diff
changeset
|
240 size_t ret = fwrite(ptr, size, nmemb, f->fh); |
|
c560703e85ed
Add resource writing functions (only work for stdio backend)
Matti Hamalainen <ccr@tnsp.org>
parents:
33
diff
changeset
|
241 f->error = dmGetErrno(); |
|
c560703e85ed
Add resource writing functions (only work for stdio backend)
Matti Hamalainen <ccr@tnsp.org>
parents:
33
diff
changeset
|
242 return ret; |
|
c560703e85ed
Add resource writing functions (only work for stdio backend)
Matti Hamalainen <ccr@tnsp.org>
parents:
33
diff
changeset
|
243 } |
|
c560703e85ed
Add resource writing functions (only work for stdio backend)
Matti Hamalainen <ccr@tnsp.org>
parents:
33
diff
changeset
|
244 |
|
c560703e85ed
Add resource writing functions (only work for stdio backend)
Matti Hamalainen <ccr@tnsp.org>
parents:
33
diff
changeset
|
245 |
| 0 | 246 static int dm_stdio_preload(DMResource *handle) |
| 247 { | |
| 248 int ret = dm_stdio_fopen(handle); | |
| 249 if (ret != DMERR_OK) | |
| 250 return ret; | |
| 251 | |
| 252 dm_stdio_fsize(handle); | |
| 253 | |
|
721
bb14d7907eb2
Rename many pack & resource handling functions.
Matti Hamalainen <ccr@tnsp.org>
parents:
630
diff
changeset
|
254 handle->rawData = dmMalloc(handle->rawSize); |
|
bb14d7907eb2
Rename many pack & resource handling functions.
Matti Hamalainen <ccr@tnsp.org>
parents:
630
diff
changeset
|
255 if (handle->rawData == NULL) |
| 0 | 256 return DMERR_MALLOC; |
| 257 | |
|
721
bb14d7907eb2
Rename many pack & resource handling functions.
Matti Hamalainen <ccr@tnsp.org>
parents:
630
diff
changeset
|
258 if (dm_stdio_fread(handle->rawData, sizeof(Uint8), handle->rawSize, handle) != handle->rawSize) |
| 0 | 259 return DMERR_FREAD; |
| 260 | |
| 261 return DMERR_OK; | |
| 262 } | |
| 263 | |
| 264 | |
| 265 DMResourceOps dfStdioFileOps = | |
| 266 { | |
|
728
867fc7f205a8
More work on resource handling cleanup.
Matti Hamalainen <ccr@tnsp.org>
parents:
727
diff
changeset
|
267 "Stdio", |
|
867fc7f205a8
More work on resource handling cleanup.
Matti Hamalainen <ccr@tnsp.org>
parents:
727
diff
changeset
|
268 |
| 0 | 269 dm_stdio_ferror, |
| 270 dm_stdio_fseek, | |
| 271 dm_stdio_fsize, | |
| 272 dm_stdio_ftell, | |
| 273 dm_stdio_feof, | |
| 274 dm_stdio_fgetc, | |
|
59
c560703e85ed
Add resource writing functions (only work for stdio backend)
Matti Hamalainen <ccr@tnsp.org>
parents:
33
diff
changeset
|
275 dm_stdio_fputc, |
| 0 | 276 dm_stdio_fread, |
|
59
c560703e85ed
Add resource writing functions (only work for stdio backend)
Matti Hamalainen <ccr@tnsp.org>
parents:
33
diff
changeset
|
277 dm_stdio_fwrite, |
| 0 | 278 |
| 279 dm_stdio_fopen, | |
| 280 dm_stdio_fclose, | |
| 281 dm_stdio_preload | |
| 282 }; | |
| 283 | |
| 284 DMResourceOps dfStdioFHOps = | |
| 285 { | |
|
728
867fc7f205a8
More work on resource handling cleanup.
Matti Hamalainen <ccr@tnsp.org>
parents:
727
diff
changeset
|
286 "StdioFH", |
|
867fc7f205a8
More work on resource handling cleanup.
Matti Hamalainen <ccr@tnsp.org>
parents:
727
diff
changeset
|
287 |
| 0 | 288 dm_stdio_ferror, |
| 289 dm_stdio_fseek, | |
| 290 dm_stdio_fsize, | |
| 291 dm_stdio_ftell, | |
| 292 dm_stdio_feof, | |
| 293 dm_stdio_fgetc, | |
|
59
c560703e85ed
Add resource writing functions (only work for stdio backend)
Matti Hamalainen <ccr@tnsp.org>
parents:
33
diff
changeset
|
294 dm_stdio_fputc, |
| 0 | 295 dm_stdio_fread, |
|
59
c560703e85ed
Add resource writing functions (only work for stdio backend)
Matti Hamalainen <ccr@tnsp.org>
parents:
33
diff
changeset
|
296 dm_stdio_fwrite, |
| 0 | 297 |
| 298 NULL, | |
| 299 NULL, | |
| 300 NULL | |
| 301 }; | |
| 302 #endif | |
| 303 | |
| 304 | |
| 305 // Some mingw/windows headers define these as macros, which is bad for us | |
| 306 #ifdef __WIN32 | |
| 307 #undef ferror | |
| 308 #undef feof | |
| 309 #endif | |
| 310 | |
| 311 | |
| 312 /* | |
| 313 * PACK file routines | |
| 314 */ | |
|
124
d5cfd29c87c4
Rename some conditional compilation directives.
Matti Hamalainen <ccr@tnsp.org>
parents:
114
diff
changeset
|
315 #ifdef DM_USE_PACKFS |
| 0 | 316 static int dm_pack_preload(DMResource *handle) |
| 317 { | |
| 318 DMPackEntry *node; | |
| 319 int res = DMERR_OK, cres, cdataLeft; | |
| 320 z_stream cstream; | |
| 321 Uint8 * cbuffer = NULL; | |
| 322 | |
|
359
59045853853d
Make resource management re-entrant.
Matti Hamalainen <ccr@tnsp.org>
parents:
237
diff
changeset
|
323 if (handle->lib == NULL || handle->lib->packFile == NULL) |
|
59045853853d
Make resource management re-entrant.
Matti Hamalainen <ccr@tnsp.org>
parents:
237
diff
changeset
|
324 return DMERR_NULLPTR; |
|
59045853853d
Make resource management re-entrant.
Matti Hamalainen <ccr@tnsp.org>
parents:
237
diff
changeset
|
325 |
| 0 | 326 // Search PACK nodelist for file |
|
721
bb14d7907eb2
Rename many pack & resource handling functions.
Matti Hamalainen <ccr@tnsp.org>
parents:
630
diff
changeset
|
327 if ((node = dmPackFind(handle->lib->packFile->entries, handle->filename)) == NULL) |
| 0 | 328 { |
| 329 dmError("Entry '%s' not found in PACK file.\n", handle->filename); | |
| 330 res = DMERR_NOT_FOUND; | |
| 331 goto error; | |
| 332 } | |
| 333 | |
| 334 // Seek to entry | |
|
359
59045853853d
Make resource management re-entrant.
Matti Hamalainen <ccr@tnsp.org>
parents:
237
diff
changeset
|
335 if (fseek(handle->lib->packFile->file, node->offset, SEEK_SET) == -1) |
| 0 | 336 { |
| 337 dmError("Could not seek node position in PACK file.\n"); | |
| 338 res = DMERR_FSEEK; | |
| 339 goto error; | |
| 340 } | |
| 341 | |
| 342 // Allocate a structures and buffers | |
| 343 cbuffer = (Uint8 *) dmMalloc(DPACK_TMPSIZE); | |
| 344 if (cbuffer == NULL) | |
| 345 { | |
| 346 res = DMERR_MALLOC; | |
| 347 goto error; | |
| 348 } | |
| 349 | |
| 350 // Initialize fields | |
|
721
bb14d7907eb2
Rename many pack & resource handling functions.
Matti Hamalainen <ccr@tnsp.org>
parents:
630
diff
changeset
|
351 handle->rawOffset = 0; |
|
bb14d7907eb2
Rename many pack & resource handling functions.
Matti Hamalainen <ccr@tnsp.org>
parents:
630
diff
changeset
|
352 handle->rawSize = node->size; |
|
bb14d7907eb2
Rename many pack & resource handling functions.
Matti Hamalainen <ccr@tnsp.org>
parents:
630
diff
changeset
|
353 handle->rawData = (Uint8 *) dmMalloc(node->size); |
|
bb14d7907eb2
Rename many pack & resource handling functions.
Matti Hamalainen <ccr@tnsp.org>
parents:
630
diff
changeset
|
354 if (handle->rawData == NULL) |
| 0 | 355 { |
| 356 res = DMERR_MALLOC; | |
| 357 goto error; | |
| 358 } | |
| 359 | |
| 360 // Initialize decompression | |
| 361 cstream.zalloc = (alloc_func) Z_NULL; | |
| 362 cstream.zfree = (free_func) Z_NULL; | |
| 363 cstream.opaque = (voidpf) Z_NULL; | |
|
721
bb14d7907eb2
Rename many pack & resource handling functions.
Matti Hamalainen <ccr@tnsp.org>
parents:
630
diff
changeset
|
364 cstream.next_out = handle->rawData; |
|
bb14d7907eb2
Rename many pack & resource handling functions.
Matti Hamalainen <ccr@tnsp.org>
parents:
630
diff
changeset
|
365 cstream.avail_out = handle->rawSize; |
| 0 | 366 cdataLeft = node->length; |
| 367 cres = inflateInit(&(cstream)); | |
| 368 if (cres != Z_OK) | |
| 369 { | |
| 370 dmError("Could not initialize zlib stream inflation.\n"); | |
| 371 res = DMERR_INIT_FAIL; | |
| 372 goto error; | |
| 373 } | |
| 374 | |
| 375 // Uncompress the data | |
| 376 while (cdataLeft > 0 && | |
| 377 cstream.avail_out > 0 && cres == Z_OK) | |
| 378 { | |
| 379 cstream.avail_in = fread( | |
| 380 cbuffer, sizeof(Uint8), | |
| 381 (cdataLeft >= DPACK_TMPSIZE) ? DPACK_TMPSIZE : cdataLeft, | |
|
359
59045853853d
Make resource management re-entrant.
Matti Hamalainen <ccr@tnsp.org>
parents:
237
diff
changeset
|
382 handle->lib->packFile->file); |
| 0 | 383 |
| 384 cdataLeft -= cstream.avail_in; | |
| 385 cstream.next_in = cbuffer; | |
| 386 cres = inflate(&cstream, Z_FULL_FLUSH); | |
| 387 } | |
| 388 | |
| 389 // Cleanup | |
| 390 inflateEnd(&(cstream)); | |
| 391 | |
| 392 error: | |
| 393 dmFree(cbuffer); | |
| 394 return res; | |
| 395 } | |
| 396 | |
| 397 | |
|
728
867fc7f205a8
More work on resource handling cleanup.
Matti Hamalainen <ccr@tnsp.org>
parents:
727
diff
changeset
|
398 static int dm_pack_fopen(DMResource * f) |
|
867fc7f205a8
More work on resource handling cleanup.
Matti Hamalainen <ccr@tnsp.org>
parents:
727
diff
changeset
|
399 { |
|
867fc7f205a8
More work on resource handling cleanup.
Matti Hamalainen <ccr@tnsp.org>
parents:
727
diff
changeset
|
400 if ((f->flags & DMF_LOADED_RAW) == 0) |
|
867fc7f205a8
More work on resource handling cleanup.
Matti Hamalainen <ccr@tnsp.org>
parents:
727
diff
changeset
|
401 { |
|
867fc7f205a8
More work on resource handling cleanup.
Matti Hamalainen <ccr@tnsp.org>
parents:
727
diff
changeset
|
402 int res = dm_pack_preload(f); |
|
867fc7f205a8
More work on resource handling cleanup.
Matti Hamalainen <ccr@tnsp.org>
parents:
727
diff
changeset
|
403 if (res == DMERR_OK) |
|
867fc7f205a8
More work on resource handling cleanup.
Matti Hamalainen <ccr@tnsp.org>
parents:
727
diff
changeset
|
404 f->flags |= DMF_LOADED_RAW; |
|
867fc7f205a8
More work on resource handling cleanup.
Matti Hamalainen <ccr@tnsp.org>
parents:
727
diff
changeset
|
405 |
|
867fc7f205a8
More work on resource handling cleanup.
Matti Hamalainen <ccr@tnsp.org>
parents:
727
diff
changeset
|
406 return res; |
|
867fc7f205a8
More work on resource handling cleanup.
Matti Hamalainen <ccr@tnsp.org>
parents:
727
diff
changeset
|
407 } |
|
867fc7f205a8
More work on resource handling cleanup.
Matti Hamalainen <ccr@tnsp.org>
parents:
727
diff
changeset
|
408 else |
|
867fc7f205a8
More work on resource handling cleanup.
Matti Hamalainen <ccr@tnsp.org>
parents:
727
diff
changeset
|
409 return DMERR_OK; |
|
867fc7f205a8
More work on resource handling cleanup.
Matti Hamalainen <ccr@tnsp.org>
parents:
727
diff
changeset
|
410 } |
|
867fc7f205a8
More work on resource handling cleanup.
Matti Hamalainen <ccr@tnsp.org>
parents:
727
diff
changeset
|
411 |
|
867fc7f205a8
More work on resource handling cleanup.
Matti Hamalainen <ccr@tnsp.org>
parents:
727
diff
changeset
|
412 |
|
166
112eb95f2fba
Improve build system granularity.
Matti Hamalainen <ccr@tnsp.org>
parents:
124
diff
changeset
|
413 static void dm_pack_fclose(DMResource * f) |
| 0 | 414 { |
|
728
867fc7f205a8
More work on resource handling cleanup.
Matti Hamalainen <ccr@tnsp.org>
parents:
727
diff
changeset
|
415 if ((f->flags & DMF_PERSIST) == 0) |
|
867fc7f205a8
More work on resource handling cleanup.
Matti Hamalainen <ccr@tnsp.org>
parents:
727
diff
changeset
|
416 dmResourceFreeRawData(f); |
| 0 | 417 } |
|
166
112eb95f2fba
Improve build system granularity.
Matti Hamalainen <ccr@tnsp.org>
parents:
124
diff
changeset
|
418 #endif |
| 0 | 419 |
| 420 | |
| 421 static int dm_mem_ferror(DMResource * f) | |
| 422 { | |
| 423 return f->error; | |
| 424 } | |
| 425 | |
| 426 | |
| 427 static int dm_mem_fseek(DMResource * f, const off_t offset, const int whence) | |
| 428 { | |
| 429 off_t newPos; | |
| 430 | |
| 431 // Calculate the new position | |
| 432 switch (whence) | |
| 433 { | |
| 434 case SEEK_SET: | |
| 435 newPos = offset; | |
| 436 break; | |
| 437 | |
| 438 case SEEK_CUR: | |
|
721
bb14d7907eb2
Rename many pack & resource handling functions.
Matti Hamalainen <ccr@tnsp.org>
parents:
630
diff
changeset
|
439 newPos = f->rawOffset + offset; |
| 0 | 440 break; |
| 441 | |
| 442 case SEEK_END: | |
|
721
bb14d7907eb2
Rename many pack & resource handling functions.
Matti Hamalainen <ccr@tnsp.org>
parents:
630
diff
changeset
|
443 newPos = f->rawSize + offset; |
| 0 | 444 break; |
| 445 | |
| 446 default: | |
| 447 return -1; | |
| 448 } | |
| 449 | |
| 450 // Set the new position | |
|
721
bb14d7907eb2
Rename many pack & resource handling functions.
Matti Hamalainen <ccr@tnsp.org>
parents:
630
diff
changeset
|
451 f->rawOffset = newPos; |
| 0 | 452 |
| 453 // Check the new position | |
|
721
bb14d7907eb2
Rename many pack & resource handling functions.
Matti Hamalainen <ccr@tnsp.org>
parents:
630
diff
changeset
|
454 if (newPos < 0 && (size_t) newPos >= f->rawSize) |
| 0 | 455 return -1; |
| 456 | |
| 457 return 0; | |
| 458 } | |
| 459 | |
| 460 | |
| 461 static off_t dm_mem_fsize(DMResource * f) | |
| 462 { | |
|
721
bb14d7907eb2
Rename many pack & resource handling functions.
Matti Hamalainen <ccr@tnsp.org>
parents:
630
diff
changeset
|
463 return f->rawSize; |
| 0 | 464 } |
| 465 | |
| 466 | |
| 467 static off_t dm_mem_ftell(DMResource * f) | |
| 468 { | |
|
721
bb14d7907eb2
Rename many pack & resource handling functions.
Matti Hamalainen <ccr@tnsp.org>
parents:
630
diff
changeset
|
469 return f->rawOffset; |
| 0 | 470 } |
| 471 | |
| 472 | |
| 473 static BOOL dm_mem_feof(DMResource * f) | |
| 474 { | |
| 475 // Check for EOF | |
|
721
bb14d7907eb2
Rename many pack & resource handling functions.
Matti Hamalainen <ccr@tnsp.org>
parents:
630
diff
changeset
|
476 if ((size_t) f->rawOffset <= f->rawSize) |
| 0 | 477 return FALSE; |
| 478 else | |
| 479 return TRUE; | |
| 480 } | |
| 481 | |
| 482 | |
| 483 static int dm_mem_fgetc(DMResource * f) | |
| 484 { | |
| 485 // Check for EOF | |
|
721
bb14d7907eb2
Rename many pack & resource handling functions.
Matti Hamalainen <ccr@tnsp.org>
parents:
630
diff
changeset
|
486 if ((size_t) f->rawOffset < f->rawSize) |
|
bb14d7907eb2
Rename many pack & resource handling functions.
Matti Hamalainen <ccr@tnsp.org>
parents:
630
diff
changeset
|
487 return f->rawData[f->rawOffset++]; |
| 0 | 488 else |
| 489 return EOF; | |
| 490 } | |
| 491 | |
| 492 | |
| 493 static size_t dm_mem_fread(void *buf, size_t size, size_t nmemb, DMResource * f) | |
| 494 { | |
| 495 size_t length = (size * nmemb); | |
| 496 | |
| 497 // Check if we can read the whole chunk | |
|
721
bb14d7907eb2
Rename many pack & resource handling functions.
Matti Hamalainen <ccr@tnsp.org>
parents:
630
diff
changeset
|
498 if (((size_t) f->rawOffset + length) >= f->rawSize) |
| 0 | 499 { |
|
721
bb14d7907eb2
Rename many pack & resource handling functions.
Matti Hamalainen <ccr@tnsp.org>
parents:
630
diff
changeset
|
500 nmemb = (f->rawSize - f->rawOffset) / size; |
| 0 | 501 length = size * nmemb; |
| 502 } | |
| 503 | |
|
721
bb14d7907eb2
Rename many pack & resource handling functions.
Matti Hamalainen <ccr@tnsp.org>
parents:
630
diff
changeset
|
504 memcpy(buf, f->rawData + f->rawOffset, length); |
|
bb14d7907eb2
Rename many pack & resource handling functions.
Matti Hamalainen <ccr@tnsp.org>
parents:
630
diff
changeset
|
505 f->rawOffset += length; |
| 0 | 506 return nmemb; |
| 507 } | |
| 508 | |
| 509 | |
|
439
bc1da1f4cb4b
Implement fwrite and fputc in memio resources. They will only operate on pre-allocated memory area, thus not grow-as-write.
Matti Hamalainen <ccr@tnsp.org>
parents:
437
diff
changeset
|
510 static int dm_mem_fputc(int ch, DMResource * f) |
|
bc1da1f4cb4b
Implement fwrite and fputc in memio resources. They will only operate on pre-allocated memory area, thus not grow-as-write.
Matti Hamalainen <ccr@tnsp.org>
parents:
437
diff
changeset
|
511 { |
|
bc1da1f4cb4b
Implement fwrite and fputc in memio resources. They will only operate on pre-allocated memory area, thus not grow-as-write.
Matti Hamalainen <ccr@tnsp.org>
parents:
437
diff
changeset
|
512 // Check for EOF |
|
721
bb14d7907eb2
Rename many pack & resource handling functions.
Matti Hamalainen <ccr@tnsp.org>
parents:
630
diff
changeset
|
513 if ((size_t) f->rawOffset < f->rawSize) |
|
439
bc1da1f4cb4b
Implement fwrite and fputc in memio resources. They will only operate on pre-allocated memory area, thus not grow-as-write.
Matti Hamalainen <ccr@tnsp.org>
parents:
437
diff
changeset
|
514 { |
|
721
bb14d7907eb2
Rename many pack & resource handling functions.
Matti Hamalainen <ccr@tnsp.org>
parents:
630
diff
changeset
|
515 f->rawData[f->rawOffset++] = ch; |
|
439
bc1da1f4cb4b
Implement fwrite and fputc in memio resources. They will only operate on pre-allocated memory area, thus not grow-as-write.
Matti Hamalainen <ccr@tnsp.org>
parents:
437
diff
changeset
|
516 return ch; |
|
bc1da1f4cb4b
Implement fwrite and fputc in memio resources. They will only operate on pre-allocated memory area, thus not grow-as-write.
Matti Hamalainen <ccr@tnsp.org>
parents:
437
diff
changeset
|
517 } |
|
bc1da1f4cb4b
Implement fwrite and fputc in memio resources. They will only operate on pre-allocated memory area, thus not grow-as-write.
Matti Hamalainen <ccr@tnsp.org>
parents:
437
diff
changeset
|
518 else |
|
bc1da1f4cb4b
Implement fwrite and fputc in memio resources. They will only operate on pre-allocated memory area, thus not grow-as-write.
Matti Hamalainen <ccr@tnsp.org>
parents:
437
diff
changeset
|
519 return EOF; |
|
bc1da1f4cb4b
Implement fwrite and fputc in memio resources. They will only operate on pre-allocated memory area, thus not grow-as-write.
Matti Hamalainen <ccr@tnsp.org>
parents:
437
diff
changeset
|
520 } |
|
bc1da1f4cb4b
Implement fwrite and fputc in memio resources. They will only operate on pre-allocated memory area, thus not grow-as-write.
Matti Hamalainen <ccr@tnsp.org>
parents:
437
diff
changeset
|
521 |
|
bc1da1f4cb4b
Implement fwrite and fputc in memio resources. They will only operate on pre-allocated memory area, thus not grow-as-write.
Matti Hamalainen <ccr@tnsp.org>
parents:
437
diff
changeset
|
522 |
|
bc1da1f4cb4b
Implement fwrite and fputc in memio resources. They will only operate on pre-allocated memory area, thus not grow-as-write.
Matti Hamalainen <ccr@tnsp.org>
parents:
437
diff
changeset
|
523 static size_t dm_mem_fwrite(void *buf, size_t size, size_t nmemb, DMResource * f) |
|
bc1da1f4cb4b
Implement fwrite and fputc in memio resources. They will only operate on pre-allocated memory area, thus not grow-as-write.
Matti Hamalainen <ccr@tnsp.org>
parents:
437
diff
changeset
|
524 { |
|
bc1da1f4cb4b
Implement fwrite and fputc in memio resources. They will only operate on pre-allocated memory area, thus not grow-as-write.
Matti Hamalainen <ccr@tnsp.org>
parents:
437
diff
changeset
|
525 size_t length = (size * nmemb); |
|
bc1da1f4cb4b
Implement fwrite and fputc in memio resources. They will only operate on pre-allocated memory area, thus not grow-as-write.
Matti Hamalainen <ccr@tnsp.org>
parents:
437
diff
changeset
|
526 |
|
bc1da1f4cb4b
Implement fwrite and fputc in memio resources. They will only operate on pre-allocated memory area, thus not grow-as-write.
Matti Hamalainen <ccr@tnsp.org>
parents:
437
diff
changeset
|
527 // Check if we can write the whole chunk |
|
721
bb14d7907eb2
Rename many pack & resource handling functions.
Matti Hamalainen <ccr@tnsp.org>
parents:
630
diff
changeset
|
528 if (((size_t) f->rawOffset + length) >= f->rawSize) |
|
439
bc1da1f4cb4b
Implement fwrite and fputc in memio resources. They will only operate on pre-allocated memory area, thus not grow-as-write.
Matti Hamalainen <ccr@tnsp.org>
parents:
437
diff
changeset
|
529 { |
|
721
bb14d7907eb2
Rename many pack & resource handling functions.
Matti Hamalainen <ccr@tnsp.org>
parents:
630
diff
changeset
|
530 nmemb = (f->rawSize - f->rawOffset) / size; |
|
439
bc1da1f4cb4b
Implement fwrite and fputc in memio resources. They will only operate on pre-allocated memory area, thus not grow-as-write.
Matti Hamalainen <ccr@tnsp.org>
parents:
437
diff
changeset
|
531 length = size * nmemb; |
|
bc1da1f4cb4b
Implement fwrite and fputc in memio resources. They will only operate on pre-allocated memory area, thus not grow-as-write.
Matti Hamalainen <ccr@tnsp.org>
parents:
437
diff
changeset
|
532 } |
|
bc1da1f4cb4b
Implement fwrite and fputc in memio resources. They will only operate on pre-allocated memory area, thus not grow-as-write.
Matti Hamalainen <ccr@tnsp.org>
parents:
437
diff
changeset
|
533 |
|
bc1da1f4cb4b
Implement fwrite and fputc in memio resources. They will only operate on pre-allocated memory area, thus not grow-as-write.
Matti Hamalainen <ccr@tnsp.org>
parents:
437
diff
changeset
|
534 if (length > 0) |
|
bc1da1f4cb4b
Implement fwrite and fputc in memio resources. They will only operate on pre-allocated memory area, thus not grow-as-write.
Matti Hamalainen <ccr@tnsp.org>
parents:
437
diff
changeset
|
535 { |
|
721
bb14d7907eb2
Rename many pack & resource handling functions.
Matti Hamalainen <ccr@tnsp.org>
parents:
630
diff
changeset
|
536 memcpy(f->rawData + f->rawOffset, buf, length); |
|
bb14d7907eb2
Rename many pack & resource handling functions.
Matti Hamalainen <ccr@tnsp.org>
parents:
630
diff
changeset
|
537 f->rawOffset += length; |
|
439
bc1da1f4cb4b
Implement fwrite and fputc in memio resources. They will only operate on pre-allocated memory area, thus not grow-as-write.
Matti Hamalainen <ccr@tnsp.org>
parents:
437
diff
changeset
|
538 } |
|
bc1da1f4cb4b
Implement fwrite and fputc in memio resources. They will only operate on pre-allocated memory area, thus not grow-as-write.
Matti Hamalainen <ccr@tnsp.org>
parents:
437
diff
changeset
|
539 return nmemb; |
|
bc1da1f4cb4b
Implement fwrite and fputc in memio resources. They will only operate on pre-allocated memory area, thus not grow-as-write.
Matti Hamalainen <ccr@tnsp.org>
parents:
437
diff
changeset
|
540 } |
|
bc1da1f4cb4b
Implement fwrite and fputc in memio resources. They will only operate on pre-allocated memory area, thus not grow-as-write.
Matti Hamalainen <ccr@tnsp.org>
parents:
437
diff
changeset
|
541 |
|
bc1da1f4cb4b
Implement fwrite and fputc in memio resources. They will only operate on pre-allocated memory area, thus not grow-as-write.
Matti Hamalainen <ccr@tnsp.org>
parents:
437
diff
changeset
|
542 |
|
bc1da1f4cb4b
Implement fwrite and fputc in memio resources. They will only operate on pre-allocated memory area, thus not grow-as-write.
Matti Hamalainen <ccr@tnsp.org>
parents:
437
diff
changeset
|
543 |
|
166
112eb95f2fba
Improve build system granularity.
Matti Hamalainen <ccr@tnsp.org>
parents:
124
diff
changeset
|
544 #ifdef DM_USE_PACKFS |
| 0 | 545 DMResourceOps dfPackFileOps = |
| 546 { | |
|
728
867fc7f205a8
More work on resource handling cleanup.
Matti Hamalainen <ccr@tnsp.org>
parents:
727
diff
changeset
|
547 "PackFS", |
|
867fc7f205a8
More work on resource handling cleanup.
Matti Hamalainen <ccr@tnsp.org>
parents:
727
diff
changeset
|
548 |
| 0 | 549 dm_mem_ferror, |
| 550 dm_mem_fseek, | |
| 551 dm_mem_fsize, | |
| 552 dm_mem_ftell, | |
| 553 dm_mem_feof, | |
| 554 dm_mem_fgetc, | |
|
59
c560703e85ed
Add resource writing functions (only work for stdio backend)
Matti Hamalainen <ccr@tnsp.org>
parents:
33
diff
changeset
|
555 NULL, |
| 0 | 556 dm_mem_fread, |
|
59
c560703e85ed
Add resource writing functions (only work for stdio backend)
Matti Hamalainen <ccr@tnsp.org>
parents:
33
diff
changeset
|
557 NULL, |
| 0 | 558 |
|
728
867fc7f205a8
More work on resource handling cleanup.
Matti Hamalainen <ccr@tnsp.org>
parents:
727
diff
changeset
|
559 dm_pack_fopen, |
|
166
112eb95f2fba
Improve build system granularity.
Matti Hamalainen <ccr@tnsp.org>
parents:
124
diff
changeset
|
560 dm_pack_fclose, |
| 0 | 561 dm_pack_preload |
| 562 }; | |
|
166
112eb95f2fba
Improve build system granularity.
Matti Hamalainen <ccr@tnsp.org>
parents:
124
diff
changeset
|
563 #endif |
| 0 | 564 |
| 565 | |
| 566 DMResourceOps dfMemIOFileOps = | |
| 567 { | |
|
728
867fc7f205a8
More work on resource handling cleanup.
Matti Hamalainen <ccr@tnsp.org>
parents:
727
diff
changeset
|
568 "MemIO", |
|
867fc7f205a8
More work on resource handling cleanup.
Matti Hamalainen <ccr@tnsp.org>
parents:
727
diff
changeset
|
569 |
| 0 | 570 dm_mem_ferror, |
| 571 dm_mem_fseek, | |
| 572 dm_mem_fsize, | |
| 573 dm_mem_ftell, | |
| 574 dm_mem_feof, | |
| 575 dm_mem_fgetc, | |
|
439
bc1da1f4cb4b
Implement fwrite and fputc in memio resources. They will only operate on pre-allocated memory area, thus not grow-as-write.
Matti Hamalainen <ccr@tnsp.org>
parents:
437
diff
changeset
|
576 dm_mem_fputc, |
| 0 | 577 dm_mem_fread, |
|
439
bc1da1f4cb4b
Implement fwrite and fputc in memio resources. They will only operate on pre-allocated memory area, thus not grow-as-write.
Matti Hamalainen <ccr@tnsp.org>
parents:
437
diff
changeset
|
578 dm_mem_fwrite, |
| 0 | 579 |
| 580 NULL, | |
|
730
3d813c81f33c
More work on resources API.
Matti Hamalainen <ccr@tnsp.org>
parents:
728
diff
changeset
|
581 dmResourceFree, |
| 0 | 582 NULL |
| 583 }; | |
| 584 | |
| 585 | |
| 586 /* FS file handling functions. These functions call the actual | |
| 587 * functions depending on where the file is located. | |
| 588 */ | |
|
730
3d813c81f33c
More work on resources API.
Matti Hamalainen <ccr@tnsp.org>
parents:
728
diff
changeset
|
589 static void dmResourceReset(DMResource *handle) |
|
603
36b544eb6f4b
Fixes in resource management.
Matti Hamalainen <ccr@tnsp.org>
parents:
602
diff
changeset
|
590 { |
|
609
877dba1b8a1f
Fix some resource code checks.
Matti Hamalainen <ccr@tnsp.org>
parents:
604
diff
changeset
|
591 if (handle != NULL && handle->fops != NULL) |
|
603
36b544eb6f4b
Fixes in resource management.
Matti Hamalainen <ccr@tnsp.org>
parents:
602
diff
changeset
|
592 dmfseek(handle, 0, SEEK_SET); |
|
36b544eb6f4b
Fixes in resource management.
Matti Hamalainen <ccr@tnsp.org>
parents:
602
diff
changeset
|
593 } |
|
36b544eb6f4b
Fixes in resource management.
Matti Hamalainen <ccr@tnsp.org>
parents:
602
diff
changeset
|
594 |
|
36b544eb6f4b
Fixes in resource management.
Matti Hamalainen <ccr@tnsp.org>
parents:
602
diff
changeset
|
595 |
|
728
867fc7f205a8
More work on resource handling cleanup.
Matti Hamalainen <ccr@tnsp.org>
parents:
727
diff
changeset
|
596 static int dmResourcePreload(DMResource *handle) |
|
29
e9f562f07cb0
Modularize some more and fix a nasty bug when raw data is not preloaded but
Matti Hamalainen <ccr@tnsp.org>
parents:
27
diff
changeset
|
597 { |
|
e9f562f07cb0
Modularize some more and fix a nasty bug when raw data is not preloaded but
Matti Hamalainen <ccr@tnsp.org>
parents:
27
diff
changeset
|
598 int ret = DMERR_INIT_FAIL; |
|
e9f562f07cb0
Modularize some more and fix a nasty bug when raw data is not preloaded but
Matti Hamalainen <ccr@tnsp.org>
parents:
27
diff
changeset
|
599 |
|
e9f562f07cb0
Modularize some more and fix a nasty bug when raw data is not preloaded but
Matti Hamalainen <ccr@tnsp.org>
parents:
27
diff
changeset
|
600 // Check if we want to preload raw data? |
|
721
bb14d7907eb2
Rename many pack & resource handling functions.
Matti Hamalainen <ccr@tnsp.org>
parents:
630
diff
changeset
|
601 if (handle->lib->flags & DRF_PRELOAD_RAW) |
|
29
e9f562f07cb0
Modularize some more and fix a nasty bug when raw data is not preloaded but
Matti Hamalainen <ccr@tnsp.org>
parents:
27
diff
changeset
|
602 { |
|
602
c1a5652e473d
Sanitize resource preloading function a bit.
Matti Hamalainen <ccr@tnsp.org>
parents:
553
diff
changeset
|
603 if (handle->flags & DMF_LOADED_RAW) |
|
c1a5652e473d
Sanitize resource preloading function a bit.
Matti Hamalainen <ccr@tnsp.org>
parents:
553
diff
changeset
|
604 ret = DMERR_OK; |
|
c1a5652e473d
Sanitize resource preloading function a bit.
Matti Hamalainen <ccr@tnsp.org>
parents:
553
diff
changeset
|
605 else |
|
c1a5652e473d
Sanitize resource preloading function a bit.
Matti Hamalainen <ccr@tnsp.org>
parents:
553
diff
changeset
|
606 if (handle->fops->preload != NULL) |
|
29
e9f562f07cb0
Modularize some more and fix a nasty bug when raw data is not preloaded but
Matti Hamalainen <ccr@tnsp.org>
parents:
27
diff
changeset
|
607 { |
|
602
c1a5652e473d
Sanitize resource preloading function a bit.
Matti Hamalainen <ccr@tnsp.org>
parents:
553
diff
changeset
|
608 ret = handle->fops->preload(handle); |
|
c1a5652e473d
Sanitize resource preloading function a bit.
Matti Hamalainen <ccr@tnsp.org>
parents:
553
diff
changeset
|
609 if (ret == DMERR_OK) |
|
728
867fc7f205a8
More work on resource handling cleanup.
Matti Hamalainen <ccr@tnsp.org>
parents:
727
diff
changeset
|
610 handle->flags |= DMF_LOADED_RAW | DMF_PERSIST; |
|
29
e9f562f07cb0
Modularize some more and fix a nasty bug when raw data is not preloaded but
Matti Hamalainen <ccr@tnsp.org>
parents:
27
diff
changeset
|
611 } |
|
728
867fc7f205a8
More work on resource handling cleanup.
Matti Hamalainen <ccr@tnsp.org>
parents:
727
diff
changeset
|
612 |
|
730
3d813c81f33c
More work on resources API.
Matti Hamalainen <ccr@tnsp.org>
parents:
728
diff
changeset
|
613 dmResourceReset(handle); |
|
29
e9f562f07cb0
Modularize some more and fix a nasty bug when raw data is not preloaded but
Matti Hamalainen <ccr@tnsp.org>
parents:
27
diff
changeset
|
614 } |
|
625
e8fc083b7499
More work on resource management.
Matti Hamalainen <ccr@tnsp.org>
parents:
613
diff
changeset
|
615 |
|
29
e9f562f07cb0
Modularize some more and fix a nasty bug when raw data is not preloaded but
Matti Hamalainen <ccr@tnsp.org>
parents:
27
diff
changeset
|
616 // Check if resource data is to be preloaded |
|
721
bb14d7907eb2
Rename many pack & resource handling functions.
Matti Hamalainen <ccr@tnsp.org>
parents:
630
diff
changeset
|
617 if (handle->lib->flags & DRF_PRELOAD_RES) |
|
29
e9f562f07cb0
Modularize some more and fix a nasty bug when raw data is not preloaded but
Matti Hamalainen <ccr@tnsp.org>
parents:
27
diff
changeset
|
618 { |
|
602
c1a5652e473d
Sanitize resource preloading function a bit.
Matti Hamalainen <ccr@tnsp.org>
parents:
553
diff
changeset
|
619 if (handle->flags & DMF_LOADED_RES) |
|
c1a5652e473d
Sanitize resource preloading function a bit.
Matti Hamalainen <ccr@tnsp.org>
parents:
553
diff
changeset
|
620 ret = DMERR_OK; |
|
c1a5652e473d
Sanitize resource preloading function a bit.
Matti Hamalainen <ccr@tnsp.org>
parents:
553
diff
changeset
|
621 else |
|
c1a5652e473d
Sanitize resource preloading function a bit.
Matti Hamalainen <ccr@tnsp.org>
parents:
553
diff
changeset
|
622 if (handle->rops != NULL && |
|
c1a5652e473d
Sanitize resource preloading function a bit.
Matti Hamalainen <ccr@tnsp.org>
parents:
553
diff
changeset
|
623 handle->rops->load != NULL) |
|
29
e9f562f07cb0
Modularize some more and fix a nasty bug when raw data is not preloaded but
Matti Hamalainen <ccr@tnsp.org>
parents:
27
diff
changeset
|
624 { |
|
728
867fc7f205a8
More work on resource handling cleanup.
Matti Hamalainen <ccr@tnsp.org>
parents:
727
diff
changeset
|
625 if ((ret = handle->fops->fopen(handle)) == DMERR_OK) |
|
602
c1a5652e473d
Sanitize resource preloading function a bit.
Matti Hamalainen <ccr@tnsp.org>
parents:
553
diff
changeset
|
626 { |
|
728
867fc7f205a8
More work on resource handling cleanup.
Matti Hamalainen <ccr@tnsp.org>
parents:
727
diff
changeset
|
627 ret = handle->rops->load(handle); |
|
867fc7f205a8
More work on resource handling cleanup.
Matti Hamalainen <ccr@tnsp.org>
parents:
727
diff
changeset
|
628 handle->fops->fclose(handle); |
|
867fc7f205a8
More work on resource handling cleanup.
Matti Hamalainen <ccr@tnsp.org>
parents:
727
diff
changeset
|
629 } |
|
867fc7f205a8
More work on resource handling cleanup.
Matti Hamalainen <ccr@tnsp.org>
parents:
727
diff
changeset
|
630 |
|
867fc7f205a8
More work on resource handling cleanup.
Matti Hamalainen <ccr@tnsp.org>
parents:
727
diff
changeset
|
631 if (ret == DMERR_OK) |
|
602
c1a5652e473d
Sanitize resource preloading function a bit.
Matti Hamalainen <ccr@tnsp.org>
parents:
553
diff
changeset
|
632 handle->flags |= DMF_LOADED_RES; |
|
728
867fc7f205a8
More work on resource handling cleanup.
Matti Hamalainen <ccr@tnsp.org>
parents:
727
diff
changeset
|
633 } |
|
29
e9f562f07cb0
Modularize some more and fix a nasty bug when raw data is not preloaded but
Matti Hamalainen <ccr@tnsp.org>
parents:
27
diff
changeset
|
634 |
|
730
3d813c81f33c
More work on resources API.
Matti Hamalainen <ccr@tnsp.org>
parents:
728
diff
changeset
|
635 dmResourceReset(handle); |
|
29
e9f562f07cb0
Modularize some more and fix a nasty bug when raw data is not preloaded but
Matti Hamalainen <ccr@tnsp.org>
parents:
27
diff
changeset
|
636 } |
|
e9f562f07cb0
Modularize some more and fix a nasty bug when raw data is not preloaded but
Matti Hamalainen <ccr@tnsp.org>
parents:
27
diff
changeset
|
637 |
|
e9f562f07cb0
Modularize some more and fix a nasty bug when raw data is not preloaded but
Matti Hamalainen <ccr@tnsp.org>
parents:
27
diff
changeset
|
638 return ret; |
|
e9f562f07cb0
Modularize some more and fix a nasty bug when raw data is not preloaded but
Matti Hamalainen <ccr@tnsp.org>
parents:
27
diff
changeset
|
639 } |
|
e9f562f07cb0
Modularize some more and fix a nasty bug when raw data is not preloaded but
Matti Hamalainen <ccr@tnsp.org>
parents:
27
diff
changeset
|
640 |
|
e9f562f07cb0
Modularize some more and fix a nasty bug when raw data is not preloaded but
Matti Hamalainen <ccr@tnsp.org>
parents:
27
diff
changeset
|
641 |
|
730
3d813c81f33c
More work on resources API.
Matti Hamalainen <ccr@tnsp.org>
parents:
728
diff
changeset
|
642 int dmf_open(DMResourceLib *lib, const char *filename, DMResource **phandle) |
| 0 | 643 { |
|
730
3d813c81f33c
More work on resources API.
Matti Hamalainen <ccr@tnsp.org>
parents:
728
diff
changeset
|
644 DMResource *handle; |
|
728
867fc7f205a8
More work on resource handling cleanup.
Matti Hamalainen <ccr@tnsp.org>
parents:
727
diff
changeset
|
645 int res; |
| 0 | 646 |
| 647 // Check master directory for resource | |
|
730
3d813c81f33c
More work on resources API.
Matti Hamalainen <ccr@tnsp.org>
parents:
728
diff
changeset
|
648 if ((*phandle = handle = dmResourceFind(lib, filename)) == NULL) |
| 0 | 649 { |
|
124
d5cfd29c87c4
Rename some conditional compilation directives.
Matti Hamalainen <ccr@tnsp.org>
parents:
114
diff
changeset
|
650 #ifdef DM_USE_STDIO |
|
613
15cd5b8a29b2
Add DRF_USE_STDIO flag for resources.
Matti Hamalainen <ccr@tnsp.org>
parents:
609
diff
changeset
|
651 if (lib->flags & DRF_USE_STDIO) |
|
15cd5b8a29b2
Add DRF_USE_STDIO flag for resources.
Matti Hamalainen <ccr@tnsp.org>
parents:
609
diff
changeset
|
652 { |
|
15cd5b8a29b2
Add DRF_USE_STDIO flag for resources.
Matti Hamalainen <ccr@tnsp.org>
parents:
609
diff
changeset
|
653 // Hmm.. does not exist? Fall back to a stdio file |
|
730
3d813c81f33c
More work on resources API.
Matti Hamalainen <ccr@tnsp.org>
parents:
728
diff
changeset
|
654 *phandle = handle = dmResourceNew(lib, filename, 0); |
|
3d813c81f33c
More work on resources API.
Matti Hamalainen <ccr@tnsp.org>
parents:
728
diff
changeset
|
655 if (handle == NULL) |
|
3d813c81f33c
More work on resources API.
Matti Hamalainen <ccr@tnsp.org>
parents:
728
diff
changeset
|
656 return DMERR_MALLOC; |
|
613
15cd5b8a29b2
Add DRF_USE_STDIO flag for resources.
Matti Hamalainen <ccr@tnsp.org>
parents:
609
diff
changeset
|
657 |
|
730
3d813c81f33c
More work on resources API.
Matti Hamalainen <ccr@tnsp.org>
parents:
728
diff
changeset
|
658 handle->fops = &dfStdioFileOps; |
|
613
15cd5b8a29b2
Add DRF_USE_STDIO flag for resources.
Matti Hamalainen <ccr@tnsp.org>
parents:
609
diff
changeset
|
659 } |
|
15cd5b8a29b2
Add DRF_USE_STDIO flag for resources.
Matti Hamalainen <ccr@tnsp.org>
parents:
609
diff
changeset
|
660 else |
|
730
3d813c81f33c
More work on resources API.
Matti Hamalainen <ccr@tnsp.org>
parents:
728
diff
changeset
|
661 return DMERR_INIT_FAIL; |
| 0 | 662 #else |
| 663 // Stdio not enabled, fail | |
|
730
3d813c81f33c
More work on resources API.
Matti Hamalainen <ccr@tnsp.org>
parents:
728
diff
changeset
|
664 return DMERR_INIT_FAIL; |
| 0 | 665 #endif |
| 666 } | |
| 667 | |
| 668 // Check if the data is preloaded | |
|
728
867fc7f205a8
More work on resource handling cleanup.
Matti Hamalainen <ccr@tnsp.org>
parents:
727
diff
changeset
|
669 if ((res = handle->fops->fopen(handle)) == DMERR_OK) |
|
730
3d813c81f33c
More work on resources API.
Matti Hamalainen <ccr@tnsp.org>
parents:
728
diff
changeset
|
670 { |
|
721
bb14d7907eb2
Rename many pack & resource handling functions.
Matti Hamalainen <ccr@tnsp.org>
parents:
630
diff
changeset
|
671 dmResourceRef(handle); |
|
730
3d813c81f33c
More work on resources API.
Matti Hamalainen <ccr@tnsp.org>
parents:
728
diff
changeset
|
672 if (handle->flags & DMF_TEMPORARY) |
|
3d813c81f33c
More work on resources API.
Matti Hamalainen <ccr@tnsp.org>
parents:
728
diff
changeset
|
673 { |
|
3d813c81f33c
More work on resources API.
Matti Hamalainen <ccr@tnsp.org>
parents:
728
diff
changeset
|
674 handle->flags &= ~DMF_TEMPORARY; |
|
3d813c81f33c
More work on resources API.
Matti Hamalainen <ccr@tnsp.org>
parents:
728
diff
changeset
|
675 dmResourceInsert(lib, handle); |
|
3d813c81f33c
More work on resources API.
Matti Hamalainen <ccr@tnsp.org>
parents:
728
diff
changeset
|
676 } |
|
3d813c81f33c
More work on resources API.
Matti Hamalainen <ccr@tnsp.org>
parents:
728
diff
changeset
|
677 } |
|
3d813c81f33c
More work on resources API.
Matti Hamalainen <ccr@tnsp.org>
parents:
728
diff
changeset
|
678 else |
|
3d813c81f33c
More work on resources API.
Matti Hamalainen <ccr@tnsp.org>
parents:
728
diff
changeset
|
679 if (handle->flags & DMF_TEMPORARY) |
|
3d813c81f33c
More work on resources API.
Matti Hamalainen <ccr@tnsp.org>
parents:
728
diff
changeset
|
680 { |
|
3d813c81f33c
More work on resources API.
Matti Hamalainen <ccr@tnsp.org>
parents:
728
diff
changeset
|
681 dmResourceFree(handle); |
|
3d813c81f33c
More work on resources API.
Matti Hamalainen <ccr@tnsp.org>
parents:
728
diff
changeset
|
682 *phandle = handle = NULL; |
|
3d813c81f33c
More work on resources API.
Matti Hamalainen <ccr@tnsp.org>
parents:
728
diff
changeset
|
683 } |
| 0 | 684 |
|
728
867fc7f205a8
More work on resource handling cleanup.
Matti Hamalainen <ccr@tnsp.org>
parents:
727
diff
changeset
|
685 return res; |
| 0 | 686 } |
| 687 | |
| 688 | |
|
730
3d813c81f33c
More work on resources API.
Matti Hamalainen <ccr@tnsp.org>
parents:
728
diff
changeset
|
689 int dmf_create_memio(DMResourceLib *lib, const char *filename, |
|
3d813c81f33c
More work on resources API.
Matti Hamalainen <ccr@tnsp.org>
parents:
728
diff
changeset
|
690 Uint8 *buf, const size_t size, DMResource **phandle) |
| 0 | 691 { |
| 692 DMResource *handle; | |
| 693 | |
| 694 // Check master directory for resource | |
|
730
3d813c81f33c
More work on resources API.
Matti Hamalainen <ccr@tnsp.org>
parents:
728
diff
changeset
|
695 if ((*phandle = handle = dmResourceFind(lib, filename)) == NULL) |
| 0 | 696 { |
|
730
3d813c81f33c
More work on resources API.
Matti Hamalainen <ccr@tnsp.org>
parents:
728
diff
changeset
|
697 if ((*phandle = handle = dmResourceNew(lib, filename, size)) == NULL) |
|
3d813c81f33c
More work on resources API.
Matti Hamalainen <ccr@tnsp.org>
parents:
728
diff
changeset
|
698 return DMERR_MALLOC; |
| 0 | 699 |
|
721
bb14d7907eb2
Rename many pack & resource handling functions.
Matti Hamalainen <ccr@tnsp.org>
parents:
630
diff
changeset
|
700 handle->flags = DMF_LOADED_RAW; |
|
bb14d7907eb2
Rename many pack & resource handling functions.
Matti Hamalainen <ccr@tnsp.org>
parents:
630
diff
changeset
|
701 handle->fops = &dfMemIOFileOps; |
|
bb14d7907eb2
Rename many pack & resource handling functions.
Matti Hamalainen <ccr@tnsp.org>
parents:
630
diff
changeset
|
702 handle->rawData = buf; |
|
bb14d7907eb2
Rename many pack & resource handling functions.
Matti Hamalainen <ccr@tnsp.org>
parents:
630
diff
changeset
|
703 dmResourceInsert(lib, handle); |
| 0 | 704 } |
| 705 | |
| 706 // Increase refcount | |
|
721
bb14d7907eb2
Rename many pack & resource handling functions.
Matti Hamalainen <ccr@tnsp.org>
parents:
630
diff
changeset
|
707 dmResourceRef(handle); |
|
730
3d813c81f33c
More work on resources API.
Matti Hamalainen <ccr@tnsp.org>
parents:
728
diff
changeset
|
708 dmResourceReset(handle); |
|
3d813c81f33c
More work on resources API.
Matti Hamalainen <ccr@tnsp.org>
parents:
728
diff
changeset
|
709 return DMERR_OK; |
| 0 | 710 } |
| 711 | |
| 712 | |
|
124
d5cfd29c87c4
Rename some conditional compilation directives.
Matti Hamalainen <ccr@tnsp.org>
parents:
114
diff
changeset
|
713 #ifdef DM_USE_STDIO |
|
730
3d813c81f33c
More work on resources API.
Matti Hamalainen <ccr@tnsp.org>
parents:
728
diff
changeset
|
714 int dmf_create_stdio(const char *filename, const char *mode, DMResource **phandle) |
| 0 | 715 { |
|
730
3d813c81f33c
More work on resources API.
Matti Hamalainen <ccr@tnsp.org>
parents:
728
diff
changeset
|
716 DMResource *handle; |
|
3d813c81f33c
More work on resources API.
Matti Hamalainen <ccr@tnsp.org>
parents:
728
diff
changeset
|
717 if ((*phandle = handle = dmResourceNew(NULL, filename, 0)) == NULL) |
|
3d813c81f33c
More work on resources API.
Matti Hamalainen <ccr@tnsp.org>
parents:
728
diff
changeset
|
718 return DMERR_MALLOC; |
| 0 | 719 |
|
721
bb14d7907eb2
Rename many pack & resource handling functions.
Matti Hamalainen <ccr@tnsp.org>
parents:
630
diff
changeset
|
720 handle->fops = &dfStdioFileOps; |
|
bb14d7907eb2
Rename many pack & resource handling functions.
Matti Hamalainen <ccr@tnsp.org>
parents:
630
diff
changeset
|
721 handle->fh = fopen(filename, mode); |
| 0 | 722 handle->error = dmGetErrno(); |
| 723 | |
|
730
3d813c81f33c
More work on resources API.
Matti Hamalainen <ccr@tnsp.org>
parents:
728
diff
changeset
|
724 if (handle->fh == NULL) |
| 0 | 725 { |
|
721
bb14d7907eb2
Rename many pack & resource handling functions.
Matti Hamalainen <ccr@tnsp.org>
parents:
630
diff
changeset
|
726 dmResourceFree(handle); |
|
730
3d813c81f33c
More work on resources API.
Matti Hamalainen <ccr@tnsp.org>
parents:
728
diff
changeset
|
727 return handle->error; |
| 0 | 728 } |
|
730
3d813c81f33c
More work on resources API.
Matti Hamalainen <ccr@tnsp.org>
parents:
728
diff
changeset
|
729 |
|
3d813c81f33c
More work on resources API.
Matti Hamalainen <ccr@tnsp.org>
parents:
728
diff
changeset
|
730 dmResourceRef(handle); |
|
3d813c81f33c
More work on resources API.
Matti Hamalainen <ccr@tnsp.org>
parents:
728
diff
changeset
|
731 return DMERR_OK; |
| 0 | 732 } |
| 733 | |
| 734 | |
|
730
3d813c81f33c
More work on resources API.
Matti Hamalainen <ccr@tnsp.org>
parents:
728
diff
changeset
|
735 int dmf_create_stdio_stream(FILE *fh, DMResource **phandle) |
| 0 | 736 { |
|
730
3d813c81f33c
More work on resources API.
Matti Hamalainen <ccr@tnsp.org>
parents:
728
diff
changeset
|
737 DMResource *handle; |
|
3d813c81f33c
More work on resources API.
Matti Hamalainen <ccr@tnsp.org>
parents:
728
diff
changeset
|
738 if ((*phandle = handle = dmResourceNew(NULL, "", 0)) == NULL) |
|
3d813c81f33c
More work on resources API.
Matti Hamalainen <ccr@tnsp.org>
parents:
728
diff
changeset
|
739 return DMERR_MALLOC; |
| 0 | 740 |
| 741 handle->fops = &dfStdioFHOps; | |
|
721
bb14d7907eb2
Rename many pack & resource handling functions.
Matti Hamalainen <ccr@tnsp.org>
parents:
630
diff
changeset
|
742 handle->fh = fh; |
|
bb14d7907eb2
Rename many pack & resource handling functions.
Matti Hamalainen <ccr@tnsp.org>
parents:
630
diff
changeset
|
743 dmResourceRef(handle); |
|
730
3d813c81f33c
More work on resources API.
Matti Hamalainen <ccr@tnsp.org>
parents:
728
diff
changeset
|
744 return DMERR_OK; |
| 0 | 745 } |
| 746 #endif | |
| 747 | |
| 748 | |
| 749 void dmf_close(DMResource * f) | |
| 750 { | |
| 751 if (f == NULL) | |
| 752 return; | |
| 753 | |
| 754 if (f->fops->fclose != NULL) | |
| 755 f->fops->fclose(f); | |
| 756 | |
|
721
bb14d7907eb2
Rename many pack & resource handling functions.
Matti Hamalainen <ccr@tnsp.org>
parents:
630
diff
changeset
|
757 dmResourceUnref(f); |
| 0 | 758 } |
| 759 | |
| 760 | |
| 761 int dmferror(DMResource * f) | |
| 762 { | |
| 763 f->atime = time(NULL); | |
| 764 return f->fops->ferror(f); | |
| 765 } | |
| 766 | |
| 767 int dmfseek(DMResource * f, off_t offset, int whence) | |
| 768 { | |
| 769 f->atime = time(NULL); | |
| 770 return f->fops->fseek(f, offset, whence); | |
| 771 } | |
| 772 | |
| 773 off_t dmfsize(DMResource * f) | |
| 774 { | |
| 775 f->atime = time(NULL); | |
| 776 return f->fops->fsize(f); | |
| 777 } | |
| 778 | |
| 779 off_t dmftell(DMResource * f) | |
| 780 { | |
| 781 f->atime = time(NULL); | |
| 782 return f->fops->ftell(f); | |
| 783 } | |
| 784 | |
| 785 BOOL dmfeof(DMResource * f) | |
| 786 { | |
| 787 f->atime = time(NULL); | |
| 788 return f->fops->feof(f); | |
| 789 } | |
| 790 | |
| 791 int dmfgetc(DMResource * f) | |
| 792 { | |
| 793 f->atime = time(NULL); | |
| 794 return f->fops->fgetc(f); | |
| 795 } | |
| 796 | |
|
74
23ac82365a65
Add file mode to dmf_create_stdio().
Matti Hamalainen <ccr@tnsp.org>
parents:
72
diff
changeset
|
797 int dmfputc(int v, DMResource * f) |
|
72
be6160981428
Improve and finish write functions in resource subsystem.
Matti Hamalainen <ccr@tnsp.org>
parents:
59
diff
changeset
|
798 { |
|
be6160981428
Improve and finish write functions in resource subsystem.
Matti Hamalainen <ccr@tnsp.org>
parents:
59
diff
changeset
|
799 f->atime = time(NULL); |
|
be6160981428
Improve and finish write functions in resource subsystem.
Matti Hamalainen <ccr@tnsp.org>
parents:
59
diff
changeset
|
800 return f->fops->fputc(v, f); |
|
be6160981428
Improve and finish write functions in resource subsystem.
Matti Hamalainen <ccr@tnsp.org>
parents:
59
diff
changeset
|
801 } |
|
be6160981428
Improve and finish write functions in resource subsystem.
Matti Hamalainen <ccr@tnsp.org>
parents:
59
diff
changeset
|
802 |
| 0 | 803 size_t dmfread(void *ptr, size_t size, size_t nmemb, DMResource * f) |
| 804 { | |
| 805 f->atime = time(NULL); | |
| 806 return f->fops->fread(ptr, size, nmemb, f); | |
| 807 } | |
| 808 | |
|
72
be6160981428
Improve and finish write functions in resource subsystem.
Matti Hamalainen <ccr@tnsp.org>
parents:
59
diff
changeset
|
809 size_t dmfwrite(void *ptr, size_t size, size_t nmemb, DMResource * f) |
|
be6160981428
Improve and finish write functions in resource subsystem.
Matti Hamalainen <ccr@tnsp.org>
parents:
59
diff
changeset
|
810 { |
|
be6160981428
Improve and finish write functions in resource subsystem.
Matti Hamalainen <ccr@tnsp.org>
parents:
59
diff
changeset
|
811 f->atime = time(NULL); |
|
be6160981428
Improve and finish write functions in resource subsystem.
Matti Hamalainen <ccr@tnsp.org>
parents:
59
diff
changeset
|
812 return f->fops->fwrite(ptr, size, nmemb, f); |
|
be6160981428
Improve and finish write functions in resource subsystem.
Matti Hamalainen <ccr@tnsp.org>
parents:
59
diff
changeset
|
813 } |
|
be6160981428
Improve and finish write functions in resource subsystem.
Matti Hamalainen <ccr@tnsp.org>
parents:
59
diff
changeset
|
814 |
| 235 | 815 char *dmfgets(char *s, int size, DMResource * f) |
| 816 { | |
| 817 char *p = s, c; | |
| 818 int n = 0; | |
| 819 | |
| 820 while ((c = f->fops->fgetc(f)) != EOF) | |
| 821 { | |
|
237
6d9d43bb68eb
Oops, another silly issue in dmfgets().
Matti Hamalainen <ccr@tnsp.org>
parents:
236
diff
changeset
|
822 n++; |
| 235 | 823 if (c == '\n') |
| 824 break; | |
| 825 else | |
| 826 if (n < size - 1) | |
| 827 *p++ = c; | |
| 828 } | |
| 829 *p = 0; | |
| 830 | |
|
236
8189be40ed7c
Oops, dmfgets() had a nasty think-o and counted the remaining buffer space
Matti Hamalainen <ccr@tnsp.org>
parents:
235
diff
changeset
|
831 return (n > 0) ? s : NULL; |
| 235 | 832 } |
| 833 | |
| 834 | |
|
721
bb14d7907eb2
Rename many pack & resource handling functions.
Matti Hamalainen <ccr@tnsp.org>
parents:
630
diff
changeset
|
835 int dmResourceRef(DMResource *node) |
| 0 | 836 { |
|
359
59045853853d
Make resource management re-entrant.
Matti Hamalainen <ccr@tnsp.org>
parents:
237
diff
changeset
|
837 if (node->lib != NULL) dmMutexLock(node->lib->mutex); |
|
27
21c14afbf63d
Modularize the resource system a bit.
Matti Hamalainen <ccr@tnsp.org>
parents:
26
diff
changeset
|
838 node->atime = time(NULL); |
|
21c14afbf63d
Modularize the resource system a bit.
Matti Hamalainen <ccr@tnsp.org>
parents:
26
diff
changeset
|
839 node->refcount++; |
|
359
59045853853d
Make resource management re-entrant.
Matti Hamalainen <ccr@tnsp.org>
parents:
237
diff
changeset
|
840 if (node->lib != NULL) dmMutexUnlock(node->lib->mutex); |
| 0 | 841 |
|
27
21c14afbf63d
Modularize the resource system a bit.
Matti Hamalainen <ccr@tnsp.org>
parents:
26
diff
changeset
|
842 return node->refcount; |
| 0 | 843 } |
| 844 | |
| 845 | |
|
721
bb14d7907eb2
Rename many pack & resource handling functions.
Matti Hamalainen <ccr@tnsp.org>
parents:
630
diff
changeset
|
846 int dmResourceUnref(DMResource *node) |
| 0 | 847 { |
|
359
59045853853d
Make resource management re-entrant.
Matti Hamalainen <ccr@tnsp.org>
parents:
237
diff
changeset
|
848 if (node->lib != NULL) dmMutexLock(node->lib->mutex); |
|
27
21c14afbf63d
Modularize the resource system a bit.
Matti Hamalainen <ccr@tnsp.org>
parents:
26
diff
changeset
|
849 node->refcount--; |
|
359
59045853853d
Make resource management re-entrant.
Matti Hamalainen <ccr@tnsp.org>
parents:
237
diff
changeset
|
850 if (node->lib != NULL) dmMutexUnlock(node->lib->mutex); |
| 0 | 851 |
|
27
21c14afbf63d
Modularize the resource system a bit.
Matti Hamalainen <ccr@tnsp.org>
parents:
26
diff
changeset
|
852 return node->refcount; |
| 0 | 853 } |
| 854 | |
| 855 | |
|
625
e8fc083b7499
More work on resource management.
Matti Hamalainen <ccr@tnsp.org>
parents:
613
diff
changeset
|
856 #ifdef DM_USE_STDIO |
| 727 | 857 static int dmResourcesLoadDirectory(DMResourceLib *lib, const char *path) |
| 0 | 858 { |
|
625
e8fc083b7499
More work on resource management.
Matti Hamalainen <ccr@tnsp.org>
parents:
613
diff
changeset
|
859 int res = DMERR_OK; |
| 630 | 860 struct dirent *dh; |
|
625
e8fc083b7499
More work on resource management.
Matti Hamalainen <ccr@tnsp.org>
parents:
613
diff
changeset
|
861 DIR *hdir = opendir(path); |
|
e8fc083b7499
More work on resource management.
Matti Hamalainen <ccr@tnsp.org>
parents:
613
diff
changeset
|
862 if (hdir == NULL) |
|
e8fc083b7499
More work on resource management.
Matti Hamalainen <ccr@tnsp.org>
parents:
613
diff
changeset
|
863 return dmGetErrno(); |
| 0 | 864 |
|
359
59045853853d
Make resource management re-entrant.
Matti Hamalainen <ccr@tnsp.org>
parents:
237
diff
changeset
|
865 dmMutexLock(lib->mutex); |
| 0 | 866 |
|
625
e8fc083b7499
More work on resource management.
Matti Hamalainen <ccr@tnsp.org>
parents:
613
diff
changeset
|
867 do |
| 0 | 868 { |
|
625
e8fc083b7499
More work on resource management.
Matti Hamalainen <ccr@tnsp.org>
parents:
613
diff
changeset
|
869 DMResource *node = NULL; |
| 630 | 870 dh = readdir(hdir); |
| 871 if (dh != NULL) | |
| 0 | 872 { |
|
625
e8fc083b7499
More work on resource management.
Matti Hamalainen <ccr@tnsp.org>
parents:
613
diff
changeset
|
873 struct stat sbuf; |
|
e8fc083b7499
More work on resource management.
Matti Hamalainen <ccr@tnsp.org>
parents:
613
diff
changeset
|
874 char *fname = dm_strdup_printf("%s/%s", path, dh->d_name); |
|
e8fc083b7499
More work on resource management.
Matti Hamalainen <ccr@tnsp.org>
parents:
613
diff
changeset
|
875 if (stat(fname, &sbuf) == -1) |
|
e8fc083b7499
More work on resource management.
Matti Hamalainen <ccr@tnsp.org>
parents:
613
diff
changeset
|
876 { |
|
e8fc083b7499
More work on resource management.
Matti Hamalainen <ccr@tnsp.org>
parents:
613
diff
changeset
|
877 res = dmGetErrno(); |
|
e8fc083b7499
More work on resource management.
Matti Hamalainen <ccr@tnsp.org>
parents:
613
diff
changeset
|
878 dmError("Could not stat() %s, #%d: %s\n", |
|
e8fc083b7499
More work on resource management.
Matti Hamalainen <ccr@tnsp.org>
parents:
613
diff
changeset
|
879 fname, res, dmErrorStr(res)); |
|
e8fc083b7499
More work on resource management.
Matti Hamalainen <ccr@tnsp.org>
parents:
613
diff
changeset
|
880 dmFree(fname); |
|
e8fc083b7499
More work on resource management.
Matti Hamalainen <ccr@tnsp.org>
parents:
613
diff
changeset
|
881 goto out; |
|
e8fc083b7499
More work on resource management.
Matti Hamalainen <ccr@tnsp.org>
parents:
613
diff
changeset
|
882 } |
| 0 | 883 |
|
625
e8fc083b7499
More work on resource management.
Matti Hamalainen <ccr@tnsp.org>
parents:
613
diff
changeset
|
884 if (S_ISREG(sbuf.st_mode)) |
|
721
bb14d7907eb2
Rename many pack & resource handling functions.
Matti Hamalainen <ccr@tnsp.org>
parents:
630
diff
changeset
|
885 node = dmResourceNew(lib, dh->d_name, sbuf.st_size); |
|
625
e8fc083b7499
More work on resource management.
Matti Hamalainen <ccr@tnsp.org>
parents:
613
diff
changeset
|
886 } |
| 630 | 887 |
|
625
e8fc083b7499
More work on resource management.
Matti Hamalainen <ccr@tnsp.org>
parents:
613
diff
changeset
|
888 if (node != NULL) |
|
e8fc083b7499
More work on resource management.
Matti Hamalainen <ccr@tnsp.org>
parents:
613
diff
changeset
|
889 { |
|
e8fc083b7499
More work on resource management.
Matti Hamalainen <ccr@tnsp.org>
parents:
613
diff
changeset
|
890 node->fops = &dfStdioFileOps; |
|
721
bb14d7907eb2
Rename many pack & resource handling functions.
Matti Hamalainen <ccr@tnsp.org>
parents:
630
diff
changeset
|
891 dmResourceInsert(lib, node); |
|
625
e8fc083b7499
More work on resource management.
Matti Hamalainen <ccr@tnsp.org>
parents:
613
diff
changeset
|
892 } |
| 630 | 893 } while (dh != NULL); |
| 0 | 894 |
|
625
e8fc083b7499
More work on resource management.
Matti Hamalainen <ccr@tnsp.org>
parents:
613
diff
changeset
|
895 out: |
|
e8fc083b7499
More work on resource management.
Matti Hamalainen <ccr@tnsp.org>
parents:
613
diff
changeset
|
896 dmMutexUnlock(lib->mutex); |
| 0 | 897 |
|
625
e8fc083b7499
More work on resource management.
Matti Hamalainen <ccr@tnsp.org>
parents:
613
diff
changeset
|
898 #ifdef __WIN32 |
|
e8fc083b7499
More work on resource management.
Matti Hamalainen <ccr@tnsp.org>
parents:
613
diff
changeset
|
899 #else |
|
e8fc083b7499
More work on resource management.
Matti Hamalainen <ccr@tnsp.org>
parents:
613
diff
changeset
|
900 closedir(hdir); |
|
e8fc083b7499
More work on resource management.
Matti Hamalainen <ccr@tnsp.org>
parents:
613
diff
changeset
|
901 #endif |
|
e8fc083b7499
More work on resource management.
Matti Hamalainen <ccr@tnsp.org>
parents:
613
diff
changeset
|
902 |
|
e8fc083b7499
More work on resource management.
Matti Hamalainen <ccr@tnsp.org>
parents:
613
diff
changeset
|
903 return res; |
| 0 | 904 } |
|
625
e8fc083b7499
More work on resource management.
Matti Hamalainen <ccr@tnsp.org>
parents:
613
diff
changeset
|
905 #endif |
| 0 | 906 |
| 907 | |
| 908 /* Resources subsystem initialization and shutdown routines | |
| 909 */ | |
|
721
bb14d7907eb2
Rename many pack & resource handling functions.
Matti Hamalainen <ccr@tnsp.org>
parents:
630
diff
changeset
|
910 int dmResourcesInit(DMResourceLib **plib, const char *filename, const char *path, const int flags, int (*classifier)(DMResource *)) |
| 0 | 911 { |
|
359
59045853853d
Make resource management re-entrant.
Matti Hamalainen <ccr@tnsp.org>
parents:
237
diff
changeset
|
912 DMResourceLib *lib; |
|
625
e8fc083b7499
More work on resource management.
Matti Hamalainen <ccr@tnsp.org>
parents:
613
diff
changeset
|
913 BOOL initialized = FALSE; |
|
e8fc083b7499
More work on resource management.
Matti Hamalainen <ccr@tnsp.org>
parents:
613
diff
changeset
|
914 |
|
359
59045853853d
Make resource management re-entrant.
Matti Hamalainen <ccr@tnsp.org>
parents:
237
diff
changeset
|
915 // Allocate the resource library structure |
|
59045853853d
Make resource management re-entrant.
Matti Hamalainen <ccr@tnsp.org>
parents:
237
diff
changeset
|
916 if ((*plib = lib = dmMalloc0(sizeof(DMResourceLib))) == NULL) |
|
59045853853d
Make resource management re-entrant.
Matti Hamalainen <ccr@tnsp.org>
parents:
237
diff
changeset
|
917 return DMERR_MALLOC; |
| 0 | 918 |
|
359
59045853853d
Make resource management re-entrant.
Matti Hamalainen <ccr@tnsp.org>
parents:
237
diff
changeset
|
919 // Basic data |
|
59045853853d
Make resource management re-entrant.
Matti Hamalainen <ccr@tnsp.org>
parents:
237
diff
changeset
|
920 lib->mutex = dmCreateMutex(); |
|
59045853853d
Make resource management re-entrant.
Matti Hamalainen <ccr@tnsp.org>
parents:
237
diff
changeset
|
921 lib->flags = flags; |
|
59045853853d
Make resource management re-entrant.
Matti Hamalainen <ccr@tnsp.org>
parents:
237
diff
changeset
|
922 lib->resPath = dm_strdup((path != NULL) ? path : DMRES_DATA_PATH); |
| 0 | 923 |
| 107 | 924 |
|
625
e8fc083b7499
More work on resource management.
Matti Hamalainen <ccr@tnsp.org>
parents:
613
diff
changeset
|
925 #ifdef DM_USE_PACKFS |
|
e8fc083b7499
More work on resource management.
Matti Hamalainen <ccr@tnsp.org>
parents:
613
diff
changeset
|
926 if (!initialized && (flags & DRF_USE_PACK)) |
| 0 | 927 { |
| 928 int ret; | |
| 929 DMPackEntry *node; | |
| 930 | |
|
359
59045853853d
Make resource management re-entrant.
Matti Hamalainen <ccr@tnsp.org>
parents:
237
diff
changeset
|
931 lib->packFilename = dm_strdup((filename != NULL) ? filename : DMRES_DATA_PACK); |
| 0 | 932 |
| 933 // Initialize PACK, open as read-only | |
|
721
bb14d7907eb2
Rename many pack & resource handling functions.
Matti Hamalainen <ccr@tnsp.org>
parents:
630
diff
changeset
|
934 ret = dmPackOpen(lib->packFilename, &lib->packFile, TRUE); |
| 0 | 935 if (ret != DMERR_OK) |
| 936 { | |
|
625
e8fc083b7499
More work on resource management.
Matti Hamalainen <ccr@tnsp.org>
parents:
613
diff
changeset
|
937 if ((flags & DRF_USE_STDIO) == 0) |
|
e8fc083b7499
More work on resource management.
Matti Hamalainen <ccr@tnsp.org>
parents:
613
diff
changeset
|
938 { |
|
e8fc083b7499
More work on resource management.
Matti Hamalainen <ccr@tnsp.org>
parents:
613
diff
changeset
|
939 dmError("Error opening PACK file '%s', #%i: %s\n", |
|
359
59045853853d
Make resource management re-entrant.
Matti Hamalainen <ccr@tnsp.org>
parents:
237
diff
changeset
|
940 lib->packFilename, ret, dmErrorStr(ret)); |
| 0 | 941 |
| 942 return DMERR_INIT_FAIL; | |
| 943 } | |
| 944 } | |
|
625
e8fc083b7499
More work on resource management.
Matti Hamalainen <ccr@tnsp.org>
parents:
613
diff
changeset
|
945 else |
|
e8fc083b7499
More work on resource management.
Matti Hamalainen <ccr@tnsp.org>
parents:
613
diff
changeset
|
946 { |
|
e8fc083b7499
More work on resource management.
Matti Hamalainen <ccr@tnsp.org>
parents:
613
diff
changeset
|
947 // Initialize resources from a PACK file |
|
e8fc083b7499
More work on resource management.
Matti Hamalainen <ccr@tnsp.org>
parents:
613
diff
changeset
|
948 for (node = lib->packFile->entries; node != NULL; node = node->next) |
|
e8fc083b7499
More work on resource management.
Matti Hamalainen <ccr@tnsp.org>
parents:
613
diff
changeset
|
949 { |
|
721
bb14d7907eb2
Rename many pack & resource handling functions.
Matti Hamalainen <ccr@tnsp.org>
parents:
630
diff
changeset
|
950 DMResource *res = dmResourceNew(lib, node->filename, node->size); |
|
625
e8fc083b7499
More work on resource management.
Matti Hamalainen <ccr@tnsp.org>
parents:
613
diff
changeset
|
951 if (res == NULL) |
|
e8fc083b7499
More work on resource management.
Matti Hamalainen <ccr@tnsp.org>
parents:
613
diff
changeset
|
952 { |
|
e8fc083b7499
More work on resource management.
Matti Hamalainen <ccr@tnsp.org>
parents:
613
diff
changeset
|
953 dmError("Could not allocate memory for resource node '%s' [0x%08x], %d.\n", |
|
721
bb14d7907eb2
Rename many pack & resource handling functions.
Matti Hamalainen <ccr@tnsp.org>
parents:
630
diff
changeset
|
954 node->filename, node->flags, node->size); |
|
625
e8fc083b7499
More work on resource management.
Matti Hamalainen <ccr@tnsp.org>
parents:
613
diff
changeset
|
955 return DMERR_INIT_FAIL; |
|
e8fc083b7499
More work on resource management.
Matti Hamalainen <ccr@tnsp.org>
parents:
613
diff
changeset
|
956 } |
|
e8fc083b7499
More work on resource management.
Matti Hamalainen <ccr@tnsp.org>
parents:
613
diff
changeset
|
957 |
|
721
bb14d7907eb2
Rename many pack & resource handling functions.
Matti Hamalainen <ccr@tnsp.org>
parents:
630
diff
changeset
|
958 dmResourceInsert(lib, res); |
|
625
e8fc083b7499
More work on resource management.
Matti Hamalainen <ccr@tnsp.org>
parents:
613
diff
changeset
|
959 } |
|
e8fc083b7499
More work on resource management.
Matti Hamalainen <ccr@tnsp.org>
parents:
613
diff
changeset
|
960 |
|
e8fc083b7499
More work on resource management.
Matti Hamalainen <ccr@tnsp.org>
parents:
613
diff
changeset
|
961 initialized = TRUE; |
|
e8fc083b7499
More work on resource management.
Matti Hamalainen <ccr@tnsp.org>
parents:
613
diff
changeset
|
962 } |
|
e8fc083b7499
More work on resource management.
Matti Hamalainen <ccr@tnsp.org>
parents:
613
diff
changeset
|
963 } |
| 0 | 964 #endif |
|
625
e8fc083b7499
More work on resource management.
Matti Hamalainen <ccr@tnsp.org>
parents:
613
diff
changeset
|
965 |
|
e8fc083b7499
More work on resource management.
Matti Hamalainen <ccr@tnsp.org>
parents:
613
diff
changeset
|
966 #ifdef DM_USE_STDIO |
|
e8fc083b7499
More work on resource management.
Matti Hamalainen <ccr@tnsp.org>
parents:
613
diff
changeset
|
967 if (!initialized && (flags & DRF_USE_STDIO)) |
| 0 | 968 { |
| 969 // Initialize resources from a resource directory | |
| 727 | 970 int ret = dmResourcesLoadDirectory(lib, lib->resPath); |
| 0 | 971 if (ret != DMERR_OK) |
|
625
e8fc083b7499
More work on resource management.
Matti Hamalainen <ccr@tnsp.org>
parents:
613
diff
changeset
|
972 return ret; |
|
e8fc083b7499
More work on resource management.
Matti Hamalainen <ccr@tnsp.org>
parents:
613
diff
changeset
|
973 initialized = TRUE; |
| 0 | 974 } |
|
625
e8fc083b7499
More work on resource management.
Matti Hamalainen <ccr@tnsp.org>
parents:
613
diff
changeset
|
975 #endif |
|
e8fc083b7499
More work on resource management.
Matti Hamalainen <ccr@tnsp.org>
parents:
613
diff
changeset
|
976 |
|
e8fc083b7499
More work on resource management.
Matti Hamalainen <ccr@tnsp.org>
parents:
613
diff
changeset
|
977 if (!initialized) |
|
e8fc083b7499
More work on resource management.
Matti Hamalainen <ccr@tnsp.org>
parents:
613
diff
changeset
|
978 return DMERR_INIT_FAIL; |
| 0 | 979 |
|
26
2f463a59d732
Implement rudimentary resource system.
Matti Hamalainen <ccr@tnsp.org>
parents:
4
diff
changeset
|
980 // Okay, classify resources |
|
359
59045853853d
Make resource management re-entrant.
Matti Hamalainen <ccr@tnsp.org>
parents:
237
diff
changeset
|
981 if (lib->resources != NULL && classifier != NULL) |
|
26
2f463a59d732
Implement rudimentary resource system.
Matti Hamalainen <ccr@tnsp.org>
parents:
4
diff
changeset
|
982 { |
|
2f463a59d732
Implement rudimentary resource system.
Matti Hamalainen <ccr@tnsp.org>
parents:
4
diff
changeset
|
983 DMResource *node; |
|
359
59045853853d
Make resource management re-entrant.
Matti Hamalainen <ccr@tnsp.org>
parents:
237
diff
changeset
|
984 for (node = lib->resources; node != NULL; node = node->next) |
|
26
2f463a59d732
Implement rudimentary resource system.
Matti Hamalainen <ccr@tnsp.org>
parents:
4
diff
changeset
|
985 { |
|
2f463a59d732
Implement rudimentary resource system.
Matti Hamalainen <ccr@tnsp.org>
parents:
4
diff
changeset
|
986 int ret = classifier(node); |
|
2f463a59d732
Implement rudimentary resource system.
Matti Hamalainen <ccr@tnsp.org>
parents:
4
diff
changeset
|
987 if (ret != DMERR_OK) |
| 107 | 988 return ret; |
|
26
2f463a59d732
Implement rudimentary resource system.
Matti Hamalainen <ccr@tnsp.org>
parents:
4
diff
changeset
|
989 } |
|
2f463a59d732
Implement rudimentary resource system.
Matti Hamalainen <ccr@tnsp.org>
parents:
4
diff
changeset
|
990 } |
| 0 | 991 |
| 992 // Initialization complete | |
| 993 return DMERR_OK; | |
| 994 } | |
| 995 | |
| 996 | |
|
721
bb14d7907eb2
Rename many pack & resource handling functions.
Matti Hamalainen <ccr@tnsp.org>
parents:
630
diff
changeset
|
997 int dmResourcesClose(DMResourceLib *lib) |
| 0 | 998 { |
| 999 DMResource *node; | |
|
359
59045853853d
Make resource management re-entrant.
Matti Hamalainen <ccr@tnsp.org>
parents:
237
diff
changeset
|
1000 |
|
59045853853d
Make resource management re-entrant.
Matti Hamalainen <ccr@tnsp.org>
parents:
237
diff
changeset
|
1001 if (lib == NULL) |
|
59045853853d
Make resource management re-entrant.
Matti Hamalainen <ccr@tnsp.org>
parents:
237
diff
changeset
|
1002 return DMERR_NULLPTR; |
|
59045853853d
Make resource management re-entrant.
Matti Hamalainen <ccr@tnsp.org>
parents:
237
diff
changeset
|
1003 |
|
59045853853d
Make resource management re-entrant.
Matti Hamalainen <ccr@tnsp.org>
parents:
237
diff
changeset
|
1004 dmMutexLock(lib->mutex); |
| 0 | 1005 |
| 1006 // Shutdown possible subsystems | |
|
124
d5cfd29c87c4
Rename some conditional compilation directives.
Matti Hamalainen <ccr@tnsp.org>
parents:
114
diff
changeset
|
1007 #ifdef DM_USE_PACKFS |
|
359
59045853853d
Make resource management re-entrant.
Matti Hamalainen <ccr@tnsp.org>
parents:
237
diff
changeset
|
1008 if (lib->flags & DRF_USE_PACK) |
| 0 | 1009 { |
|
721
bb14d7907eb2
Rename many pack & resource handling functions.
Matti Hamalainen <ccr@tnsp.org>
parents:
630
diff
changeset
|
1010 int res = dmPackClose(lib->packFile); |
| 0 | 1011 if (res != DMERR_OK) |
| 1012 { | |
| 1013 dmError("Error closing PACK, #%i: %s\n", | |
|
721
bb14d7907eb2
Rename many pack & resource handling functions.
Matti Hamalainen <ccr@tnsp.org>
parents:
630
diff
changeset
|
1014 res, dmErrorStr(res)); |
| 0 | 1015 } |
| 1016 | |
|
359
59045853853d
Make resource management re-entrant.
Matti Hamalainen <ccr@tnsp.org>
parents:
237
diff
changeset
|
1017 dmFree(lib->packFilename); |
| 0 | 1018 } |
| 1019 #endif | |
| 1020 | |
| 1021 // Free resource entries | |
|
359
59045853853d
Make resource management re-entrant.
Matti Hamalainen <ccr@tnsp.org>
parents:
237
diff
changeset
|
1022 node = lib->resources; |
| 0 | 1023 while (node != NULL) |
| 1024 { | |
| 1025 DMResource *next = node->next; | |
|
721
bb14d7907eb2
Rename many pack & resource handling functions.
Matti Hamalainen <ccr@tnsp.org>
parents:
630
diff
changeset
|
1026 dmResourceFree(node); |
| 0 | 1027 node = next; |
| 1028 } | |
| 1029 | |
| 1030 // Etc. | |
|
359
59045853853d
Make resource management re-entrant.
Matti Hamalainen <ccr@tnsp.org>
parents:
237
diff
changeset
|
1031 dmFree(lib->resPath); |
|
59045853853d
Make resource management re-entrant.
Matti Hamalainen <ccr@tnsp.org>
parents:
237
diff
changeset
|
1032 dmMutexUnlock(lib->mutex); |
|
59045853853d
Make resource management re-entrant.
Matti Hamalainen <ccr@tnsp.org>
parents:
237
diff
changeset
|
1033 dmDestroyMutex(lib->mutex); |
|
59045853853d
Make resource management re-entrant.
Matti Hamalainen <ccr@tnsp.org>
parents:
237
diff
changeset
|
1034 return DMERR_OK; |
| 0 | 1035 } |
| 1036 | |
| 1037 | |
|
721
bb14d7907eb2
Rename many pack & resource handling functions.
Matti Hamalainen <ccr@tnsp.org>
parents:
630
diff
changeset
|
1038 int dmResourcesPreload(DMResourceLib *lib, BOOL start, int *loaded, int *total) |
| 0 | 1039 { |
|
26
2f463a59d732
Implement rudimentary resource system.
Matti Hamalainen <ccr@tnsp.org>
parents:
4
diff
changeset
|
1040 int ret = DMERR_OK; |
| 0 | 1041 |
|
359
59045853853d
Make resource management re-entrant.
Matti Hamalainen <ccr@tnsp.org>
parents:
237
diff
changeset
|
1042 dmMutexLock(lib->mutex); |
| 0 | 1043 |
|
26
2f463a59d732
Implement rudimentary resource system.
Matti Hamalainen <ccr@tnsp.org>
parents:
4
diff
changeset
|
1044 // Initialize preloading |
|
359
59045853853d
Make resource management re-entrant.
Matti Hamalainen <ccr@tnsp.org>
parents:
237
diff
changeset
|
1045 if (lib->preload == NULL || start) |
| 0 | 1046 { |
| 1047 DMResource *node; | |
|
26
2f463a59d732
Implement rudimentary resource system.
Matti Hamalainen <ccr@tnsp.org>
parents:
4
diff
changeset
|
1048 |
|
359
59045853853d
Make resource management re-entrant.
Matti Hamalainen <ccr@tnsp.org>
parents:
237
diff
changeset
|
1049 lib->preload = lib->resources; |
| 0 | 1050 *loaded = 0; |
| 1051 *total = 0; | |
|
26
2f463a59d732
Implement rudimentary resource system.
Matti Hamalainen <ccr@tnsp.org>
parents:
4
diff
changeset
|
1052 |
|
2f463a59d732
Implement rudimentary resource system.
Matti Hamalainen <ccr@tnsp.org>
parents:
4
diff
changeset
|
1053 // Calculate total number of resources to be preloaded |
|
721
bb14d7907eb2
Rename many pack & resource handling functions.
Matti Hamalainen <ccr@tnsp.org>
parents:
630
diff
changeset
|
1054 if (lib->flags & (DRF_PRELOAD_RAW | DRF_PRELOAD_RES)) |
| 0 | 1055 { |
|
721
bb14d7907eb2
Rename many pack & resource handling functions.
Matti Hamalainen <ccr@tnsp.org>
parents:
630
diff
changeset
|
1056 for (node = lib->resources; node != NULL; node = node->next) |
| 0 | 1057 (*total)++; |
| 1058 } | |
| 1059 } | |
|
26
2f463a59d732
Implement rudimentary resource system.
Matti Hamalainen <ccr@tnsp.org>
parents:
4
diff
changeset
|
1060 else |
|
359
59045853853d
Make resource management re-entrant.
Matti Hamalainen <ccr@tnsp.org>
parents:
237
diff
changeset
|
1061 if (lib->preload != NULL) |
| 0 | 1062 { |
|
728
867fc7f205a8
More work on resource handling cleanup.
Matti Hamalainen <ccr@tnsp.org>
parents:
727
diff
changeset
|
1063 // Attempt to preload the resource |
|
867fc7f205a8
More work on resource handling cleanup.
Matti Hamalainen <ccr@tnsp.org>
parents:
727
diff
changeset
|
1064 if ((ret = dmResourcePreload(lib->preload)) != DMERR_OK) |
|
628
0533f94e843b
Add error message to failed preloading.
Matti Hamalainen <ccr@tnsp.org>
parents:
627
diff
changeset
|
1065 { |
|
0533f94e843b
Add error message to failed preloading.
Matti Hamalainen <ccr@tnsp.org>
parents:
627
diff
changeset
|
1066 dmError("Error preloading '%s', %d: %s\n", |
|
0533f94e843b
Add error message to failed preloading.
Matti Hamalainen <ccr@tnsp.org>
parents:
627
diff
changeset
|
1067 lib->preload->filename, ret, dmErrorStr(ret)); |
|
29
e9f562f07cb0
Modularize some more and fix a nasty bug when raw data is not preloaded but
Matti Hamalainen <ccr@tnsp.org>
parents:
27
diff
changeset
|
1068 goto error; |
|
628
0533f94e843b
Add error message to failed preloading.
Matti Hamalainen <ccr@tnsp.org>
parents:
627
diff
changeset
|
1069 } |
|
26
2f463a59d732
Implement rudimentary resource system.
Matti Hamalainen <ccr@tnsp.org>
parents:
4
diff
changeset
|
1070 |
|
29
e9f562f07cb0
Modularize some more and fix a nasty bug when raw data is not preloaded but
Matti Hamalainen <ccr@tnsp.org>
parents:
27
diff
changeset
|
1071 (*loaded)++; |
|
359
59045853853d
Make resource management re-entrant.
Matti Hamalainen <ccr@tnsp.org>
parents:
237
diff
changeset
|
1072 lib->preload = lib->preload->next; |
| 0 | 1073 } |
| 1074 | |
|
359
59045853853d
Make resource management re-entrant.
Matti Hamalainen <ccr@tnsp.org>
parents:
237
diff
changeset
|
1075 dmMutexUnlock(lib->mutex); |
|
59045853853d
Make resource management re-entrant.
Matti Hamalainen <ccr@tnsp.org>
parents:
237
diff
changeset
|
1076 return (lib->preload == NULL) ? DMERR_OK : DMERR_PROGRESS; |
|
26
2f463a59d732
Implement rudimentary resource system.
Matti Hamalainen <ccr@tnsp.org>
parents:
4
diff
changeset
|
1077 |
|
2f463a59d732
Implement rudimentary resource system.
Matti Hamalainen <ccr@tnsp.org>
parents:
4
diff
changeset
|
1078 error: |
|
359
59045853853d
Make resource management re-entrant.
Matti Hamalainen <ccr@tnsp.org>
parents:
237
diff
changeset
|
1079 dmMutexUnlock(lib->mutex); |
|
26
2f463a59d732
Implement rudimentary resource system.
Matti Hamalainen <ccr@tnsp.org>
parents:
4
diff
changeset
|
1080 return ret; |
| 0 | 1081 } |
| 1082 | |
| 1083 | |
|
721
bb14d7907eb2
Rename many pack & resource handling functions.
Matti Hamalainen <ccr@tnsp.org>
parents:
630
diff
changeset
|
1084 void dmResourcePrune(DMResourceLib *lib, const int agems, int const flags) |
| 0 | 1085 { |
|
26
2f463a59d732
Implement rudimentary resource system.
Matti Hamalainen <ccr@tnsp.org>
parents:
4
diff
changeset
|
1086 DMResource *node; |
|
721
bb14d7907eb2
Rename many pack & resource handling functions.
Matti Hamalainen <ccr@tnsp.org>
parents:
630
diff
changeset
|
1087 const int stamp = time(NULL); |
|
359
59045853853d
Make resource management re-entrant.
Matti Hamalainen <ccr@tnsp.org>
parents:
237
diff
changeset
|
1088 dmMutexLock(lib->mutex); |
| 0 | 1089 |
|
359
59045853853d
Make resource management re-entrant.
Matti Hamalainen <ccr@tnsp.org>
parents:
237
diff
changeset
|
1090 for (node = lib->resources; node != NULL; node = node->next) |
| 0 | 1091 { |
| 1092 // Check if node has refcount of 0 and is | |
| 1093 // not marked as persistent resource | |
|
26
2f463a59d732
Implement rudimentary resource system.
Matti Hamalainen <ccr@tnsp.org>
parents:
4
diff
changeset
|
1094 if (node->refcount == 0 && |
|
2f463a59d732
Implement rudimentary resource system.
Matti Hamalainen <ccr@tnsp.org>
parents:
4
diff
changeset
|
1095 (node->flags & DMF_PERSIST) == 0 && |
|
2f463a59d732
Implement rudimentary resource system.
Matti Hamalainen <ccr@tnsp.org>
parents:
4
diff
changeset
|
1096 (node->flags & (DMF_LOADED_RES | DMF_LOADED_RAW))) |
| 0 | 1097 { |
|
721
bb14d7907eb2
Rename many pack & resource handling functions.
Matti Hamalainen <ccr@tnsp.org>
parents:
630
diff
changeset
|
1098 if (((flags & DMPRUNE_ATIME) && stamp - node->atime >= agems) || |
|
bb14d7907eb2
Rename many pack & resource handling functions.
Matti Hamalainen <ccr@tnsp.org>
parents:
630
diff
changeset
|
1099 ((flags & DMPRUNE_MTIME) && stamp - node->mtime >= agems)) |
| 0 | 1100 { |
|
721
bb14d7907eb2
Rename many pack & resource handling functions.
Matti Hamalainen <ccr@tnsp.org>
parents:
630
diff
changeset
|
1101 dmResourceFreeResData(node); |
|
bb14d7907eb2
Rename many pack & resource handling functions.
Matti Hamalainen <ccr@tnsp.org>
parents:
630
diff
changeset
|
1102 dmResourceFreeRawData(node); |
| 0 | 1103 } |
| 1104 } | |
| 1105 } | |
| 1106 | |
|
359
59045853853d
Make resource management re-entrant.
Matti Hamalainen <ccr@tnsp.org>
parents:
237
diff
changeset
|
1107 dmMutexUnlock(lib->mutex); |
| 0 | 1108 } |
| 1109 | |
| 1110 | |
| 1111 /* Helper resource access routines | |
| 1112 */ | |
|
553
b60220fd1669
s/Uint8/void/ in dmf_{read,write}_str().
Matti Hamalainen <ccr@tnsp.org>
parents:
439
diff
changeset
|
1113 int dmf_read_str(DMResource *f, void *s, size_t l) |
| 0 | 1114 { |
|
553
b60220fd1669
s/Uint8/void/ in dmf_{read,write}_str().
Matti Hamalainen <ccr@tnsp.org>
parents:
439
diff
changeset
|
1115 return dmfread(s, 1, l, f) == l; |
| 0 | 1116 } |
| 1117 | |
|
437
3d9c044ec08d
Add dmf_{write,read}_byte() convenience functions.
Matti Hamalainen <ccr@tnsp.org>
parents:
406
diff
changeset
|
1118 BOOL dmf_read_byte(DMResource *f, Uint8 *val) |
|
3d9c044ec08d
Add dmf_{write,read}_byte() convenience functions.
Matti Hamalainen <ccr@tnsp.org>
parents:
406
diff
changeset
|
1119 { |
|
3d9c044ec08d
Add dmf_{write,read}_byte() convenience functions.
Matti Hamalainen <ccr@tnsp.org>
parents:
406
diff
changeset
|
1120 int tmp = dmfgetc(f); |
|
3d9c044ec08d
Add dmf_{write,read}_byte() convenience functions.
Matti Hamalainen <ccr@tnsp.org>
parents:
406
diff
changeset
|
1121 *val = tmp; |
|
3d9c044ec08d
Add dmf_{write,read}_byte() convenience functions.
Matti Hamalainen <ccr@tnsp.org>
parents:
406
diff
changeset
|
1122 return tmp != EOF; |
|
3d9c044ec08d
Add dmf_{write,read}_byte() convenience functions.
Matti Hamalainen <ccr@tnsp.org>
parents:
406
diff
changeset
|
1123 } |
| 0 | 1124 |
| 1125 #define DM_DEFINE_FUNC(xname, xtype, xmacro) \ | |
| 1126 BOOL dmf_read_ ## xname (DMResource *f, xtype *v) { \ | |
| 1127 xtype result; \ | |
| 1128 if (dmfread(&result, sizeof( xtype ), 1, f) != 1) \ | |
| 1129 return FALSE; \ | |
| 1130 *v = DM_ ## xmacro ## _TO_NATIVE (result); \ | |
| 1131 return TRUE; \ | |
| 1132 } | |
| 1133 | |
| 1134 DM_DEFINE_FUNC(le16, Uint16, LE16) | |
| 1135 DM_DEFINE_FUNC(le32, Uint32, LE32) | |
| 1136 | |
| 1137 DM_DEFINE_FUNC(be16, Uint16, BE16) | |
| 1138 DM_DEFINE_FUNC(be32, Uint32, BE32) | |
| 1139 | |
| 1140 #ifdef DM_HAVE_64BIT | |
| 1141 DM_DEFINE_FUNC(le64, Uint64, LE64) | |
| 1142 DM_DEFINE_FUNC(be64, Uint64, BE64) | |
| 1143 #endif |