Update Glulxercise unit tests
[projects/chimara/chimara.git] / libchimara / gi_blorb.c
1 /* gi_blorb.c: Blorb library layer for Glk API.
2     gi_blorb version 1.4.
3     Designed by Andrew Plotkin <erkyrath@eblong.com>
4     http://www.eblong.com/zarf/glk/index.html
5
6     This file is copyright 1998-2000 by Andrew Plotkin. You may copy,
7     distribute, and incorporate it into your own programs, by any means
8     and under any conditions, as long as you do not modify it. You may
9     also modify this file, incorporate it into your own programs,
10     and distribute the modified version, as long as you retain a notice
11     in your program or documentation which mentions my name and the URL
12     shown above.
13 */
14
15 #include "glk.h"
16 #include "gi_blorb.h"
17
18 #ifndef NULL
19 #define NULL 0
20 #endif
21 #ifndef TRUE
22 #define TRUE 1
23 #endif
24 #ifndef FALSE
25 #define FALSE 0
26 #endif
27
28 /* The magic macro of endian conversion. */
29
30 #define giblorb_native4(v)   \
31     ( (((glui32)((v)[3])      ) & 0x000000ff)    \
32     | (((glui32)((v)[2]) <<  8) & 0x0000ff00)    \
33     | (((glui32)((v)[1]) << 16) & 0x00ff0000)    \
34     | (((glui32)((v)[0]) << 24) & 0xff000000))
35
36 /* More four-byte constants. */
37
38 #define giblorb_ID_FORM (giblorb_make_id('F', 'O', 'R', 'M'))
39 #define giblorb_ID_IFRS (giblorb_make_id('I', 'F', 'R', 'S'))
40 #define giblorb_ID_RIdx (giblorb_make_id('R', 'I', 'd', 'x'))
41
42 /* giblorb_chunkdesc_t: Describes one chunk of the Blorb file. */
43 typedef struct giblorb_chunkdesc_struct {
44     glui32 type;
45     glui32 len;
46     glui32 startpos; /* start of chunk header */
47     glui32 datpos; /* start of data (either startpos or startpos+8) */
48     
49     void *ptr; /* pointer to malloc'd data, if loaded */
50     int auxdatnum; /* entry in the auxsound/auxpict array; -1 if none.
51         This only applies to chunks that represent resources;  */
52     
53 } giblorb_chunkdesc_t;
54
55 /* giblorb_resdesc_t: Describes one resource in the Blorb file. */
56 typedef struct giblorb_resdesc_struct {
57     glui32 usage;
58     glui32 resnum;
59     glui32 chunknum;
60 } giblorb_resdesc_t;
61
62 /* giblorb_map_t: Holds the complete description of an open Blorb file. */
63 struct giblorb_map_struct {
64     glui32 inited; /* holds giblorb_Inited_Magic if the map structure is 
65         valid */
66     strid_t file;
67     
68     int numchunks;
69     giblorb_chunkdesc_t *chunks; /* list of chunk descriptors */
70     
71     int numresources;
72     giblorb_resdesc_t *resources; /* list of resource descriptors */
73     giblorb_resdesc_t **ressorted; /* list of pointers to descriptors 
74         in map->resources -- sorted by usage and resource number. */
75 };
76
77 #define giblorb_Inited_Magic (0xB7012BED) 
78
79 /* Static variables. */
80
81 static int lib_inited = FALSE;
82
83 static giblorb_err_t giblorb_initialize(void);
84 static giblorb_err_t giblorb_initialize_map(giblorb_map_t *map);
85 static void giblorb_qsort(giblorb_resdesc_t **list, int len);
86 static giblorb_resdesc_t *giblorb_bsearch(giblorb_resdesc_t *sample, 
87     giblorb_resdesc_t **list, int len);
88 static void *giblorb_malloc(glui32 len);
89 static void *giblorb_realloc(void *ptr, glui32 len);
90 static void giblorb_free(void *ptr);
91
92 static giblorb_err_t giblorb_initialize()
93 {
94     return giblorb_err_None;
95 }
96
97 giblorb_err_t giblorb_create_map(strid_t file, giblorb_map_t **newmap)
98 {
99     giblorb_err_t err;
100     giblorb_map_t *map;
101     glui32 readlen;
102     glui32 nextpos, totallength;
103     giblorb_chunkdesc_t *chunks;
104     int chunks_size, numchunks;
105     char buffer[16];
106     
107     *newmap = NULL;
108     
109     if (!lib_inited) {
110         err = giblorb_initialize();
111         if (err)
112             return err;
113         lib_inited = TRUE;
114     }
115
116     /* First, chew through the file and index the chunks. */
117     
118     glk_stream_set_position(file, 0, seekmode_Start);
119     
120     readlen = glk_get_buffer_stream(file, buffer, 12);
121     if (readlen != 12)
122         return giblorb_err_Read;
123     
124     if (giblorb_native4(buffer+0) != giblorb_ID_FORM)
125         return giblorb_err_Format;
126     if (giblorb_native4(buffer+8) != giblorb_ID_IFRS)
127         return giblorb_err_Format;
128     
129     totallength = giblorb_native4(buffer+4) + 8;
130     nextpos = 12;
131
132     chunks_size = 8;
133     numchunks = 0;
134     chunks = (giblorb_chunkdesc_t *)giblorb_malloc(sizeof(giblorb_chunkdesc_t) 
135         * chunks_size);
136
137     while (nextpos < totallength) {
138         glui32 type, len;
139         int chunum;
140         giblorb_chunkdesc_t *chu;
141         
142         glk_stream_set_position(file, nextpos, seekmode_Start);
143         
144         readlen = glk_get_buffer_stream(file, buffer, 8);
145         if (readlen != 8)
146             return giblorb_err_Read;
147         
148         type = giblorb_native4(buffer+0);
149         len = giblorb_native4(buffer+4);
150         
151         if (numchunks >= chunks_size) {
152             chunks_size *= 2;
153             chunks = (giblorb_chunkdesc_t *)giblorb_realloc(chunks, 
154                 sizeof(giblorb_chunkdesc_t) * chunks_size);
155         }
156         
157         chunum = numchunks;
158         chu = &(chunks[chunum]);
159         numchunks++;
160         
161         chu->type = type;
162         chu->startpos = nextpos;
163         if (type == giblorb_ID_FORM) {
164             chu->datpos = nextpos;
165             chu->len = len+8;
166         }
167         else {
168             chu->datpos = nextpos+8;
169             chu->len = len;
170         }
171         chu->ptr = NULL;
172         chu->auxdatnum = -1;
173         
174         nextpos = nextpos + len + 8;
175         if (nextpos & 1)
176             nextpos++;
177             
178         if (nextpos > totallength)
179             return giblorb_err_Format;
180     }
181     
182     /* The basic IFF structure seems to be ok, and we have a list of
183         chunks. Now we allocate the map structure itself. */
184     
185     map = (giblorb_map_t *)giblorb_malloc(sizeof(giblorb_map_t));
186     if (!map) {
187         giblorb_free(chunks);
188         return giblorb_err_Alloc;
189     }
190         
191     map->inited = giblorb_Inited_Magic;
192     map->file = file;
193     map->chunks = chunks;
194     map->numchunks = numchunks;
195     map->resources = NULL;
196     map->ressorted = NULL;
197     map->numresources = 0;
198     /*map->releasenum = 0;
199     map->zheader = NULL;
200     map->resolution = NULL;
201     map->palettechunk = -1;
202     map->palette = NULL;
203     map->auxsound = NULL;
204     map->auxpict = NULL;*/
205     
206     /* Now we do everything else involved in loading the Blorb file,
207         such as building resource lists. */
208     
209     err = giblorb_initialize_map(map);
210     if (err) {
211         giblorb_destroy_map(map);
212         return err;
213     }
214     
215     *newmap = map;
216     return giblorb_err_None;
217 }
218
219 static giblorb_err_t giblorb_initialize_map(giblorb_map_t *map)
220 {
221     /* It is important that the map structure be kept valid during this
222         function. If this returns an error, giblorb_destroy_map() will 
223         be called. */
224         
225     int ix, jx;
226     giblorb_result_t chunkres;
227     giblorb_err_t err;
228     char *ptr;
229     glui32 len;
230     glui32 numres;
231     int gotindex = FALSE; 
232
233     for (ix=0; ix<map->numchunks; ix++) {
234         giblorb_chunkdesc_t *chu = &map->chunks[ix];
235         
236         switch (chu->type) {
237         
238             case giblorb_ID_RIdx:
239                 /* Resource index chunk: build the resource list and 
240                 sort it. */
241                 
242                 if (gotindex) 
243                     return giblorb_err_Format; /* duplicate index chunk */
244                 err = giblorb_load_chunk_by_number(map, giblorb_method_Memory, 
245                     &chunkres, ix);
246                 if (err) 
247                     return err;
248                 
249                 ptr = chunkres.data.ptr;
250                 len = chunkres.length;
251                 numres = giblorb_native4(ptr+0);
252
253                 if (numres) {
254                     int ix2;
255                     giblorb_resdesc_t *resources;
256                     giblorb_resdesc_t **ressorted;
257                     
258                     if (len != numres*12+4)
259                         return giblorb_err_Format; /* bad length field */
260                     
261                     resources = (giblorb_resdesc_t *)giblorb_malloc(numres 
262                         * sizeof(giblorb_resdesc_t));
263                     ressorted = (giblorb_resdesc_t **)giblorb_malloc(numres 
264                         * sizeof(giblorb_resdesc_t *));
265                     if (!ressorted || !resources)
266                         return giblorb_err_Alloc;
267                     
268                     ix2 = 0;
269                     for (jx=0; jx<numres; jx++) {
270                         giblorb_resdesc_t *res = &(resources[jx]);
271                         glui32 respos;
272                         
273                         res->usage = giblorb_native4(ptr+jx*12+4);
274                         res->resnum = giblorb_native4(ptr+jx*12+8);
275                         respos = giblorb_native4(ptr+jx*12+12);
276                         
277                         while (ix2 < map->numchunks 
278                             && map->chunks[ix2].startpos < respos)
279                             ix2++;
280                         
281                         if (ix2 >= map->numchunks 
282                             || map->chunks[ix2].startpos != respos)
283                             return giblorb_err_Format; /* start pos does  
284                                 not match a real chunk */
285                         
286                         res->chunknum = ix2;
287                         
288                         ressorted[jx] = res;
289                     }
290                     
291                     /* Sort a resource list (actually a list of pointers to 
292                         structures in map->resources.) This makes it easy 
293                         to find resources by usage and resource number. */
294                     giblorb_qsort(ressorted, numres);
295                     
296                     map->numresources = numres;
297                     map->resources = resources;
298                     map->ressorted = ressorted;
299                 }
300                 
301                 giblorb_unload_chunk(map, ix);
302                 gotindex = TRUE;
303                 break;
304             
305         }
306     }
307     
308     return giblorb_err_None;
309 }
310
311 giblorb_err_t giblorb_destroy_map(giblorb_map_t *map)
312 {
313     int ix;
314     
315     if (!map || !map->chunks || map->inited != giblorb_Inited_Magic)
316         return giblorb_err_NotAMap;
317     
318     for (ix=0; ix<map->numchunks; ix++) {
319         giblorb_chunkdesc_t *chu = &(map->chunks[ix]);
320         if (chu->ptr) {
321             giblorb_free(chu->ptr);
322             chu->ptr = NULL;
323         }
324     }
325     
326     if (map->chunks) {
327         giblorb_free(map->chunks);
328         map->chunks = NULL;
329     }
330     
331     map->numchunks = 0;
332     
333     if (map->resources) {
334         giblorb_free(map->resources);
335         map->resources = NULL;
336     }
337     
338     if (map->ressorted) {
339         giblorb_free(map->ressorted);
340         map->ressorted = NULL;
341     }
342     
343     map->numresources = 0;
344     
345     map->file = NULL;
346     map->inited = 0;
347     
348     giblorb_free(map);
349
350     return giblorb_err_None;
351 }
352
353 /* Chunk-handling functions. */
354
355 giblorb_err_t giblorb_load_chunk_by_type(giblorb_map_t *map, 
356     glui32 method, giblorb_result_t *res, glui32 type, 
357     glui32 count)
358 {
359     int ix;
360     
361     for (ix=0; ix < map->numchunks; ix++) {
362         if (map->chunks[ix].type == type) {
363             if (count == 0)
364                 break;
365             count--;
366         }
367     }
368     
369     if (ix >= map->numchunks) {
370         return giblorb_err_NotFound;
371     }
372     
373     return giblorb_load_chunk_by_number(map, method, res, ix);
374 }
375
376 giblorb_err_t giblorb_load_chunk_by_number(giblorb_map_t *map, 
377     glui32 method, giblorb_result_t *res, glui32 chunknum)
378 {
379     giblorb_chunkdesc_t *chu;
380     
381     if (chunknum < 0 || chunknum >= map->numchunks)
382         return giblorb_err_NotFound;
383
384     chu = &(map->chunks[chunknum]);
385     
386     switch (method) {
387     
388         case giblorb_method_DontLoad:
389             /* do nothing */
390             break;
391             
392         case giblorb_method_FilePos:
393             res->data.startpos = chu->datpos;
394             break;
395             
396         case giblorb_method_Memory:
397             if (!chu->ptr) {
398                 glui32 readlen;
399                 void *dat = giblorb_malloc(chu->len);
400                 
401                 if (!dat)
402                     return giblorb_err_Alloc;
403                 
404                 glk_stream_set_position(map->file, chu->datpos, 
405                     seekmode_Start);
406                 
407                 readlen = glk_get_buffer_stream(map->file, dat, 
408                     chu->len);
409                 if (readlen != chu->len)
410                     return giblorb_err_Read;
411                 
412                 chu->ptr = dat;
413             }
414             res->data.ptr = chu->ptr;
415             break;
416     }
417     
418     res->chunknum = chunknum;
419     res->length = chu->len;
420     res->chunktype = chu->type;
421     
422     return giblorb_err_None;
423 }
424
425 giblorb_err_t giblorb_load_resource(giblorb_map_t *map, glui32 method, 
426     giblorb_result_t *res, glui32 usage, glui32 resnum)
427 {
428     giblorb_resdesc_t sample;
429     giblorb_resdesc_t *found;
430     
431     sample.usage = usage;
432     sample.resnum = resnum;
433     
434     found = giblorb_bsearch(&sample, map->ressorted, map->numresources);
435     
436     if (!found)
437         return giblorb_err_NotFound;
438     
439     return giblorb_load_chunk_by_number(map, method, res, found->chunknum);
440 }
441
442 giblorb_err_t giblorb_unload_chunk(giblorb_map_t *map, glui32 chunknum)
443 {
444     giblorb_chunkdesc_t *chu;
445     
446     if (chunknum < 0 || chunknum >= map->numchunks)
447         return giblorb_err_NotFound;
448
449     chu = &(map->chunks[chunknum]);
450     
451     if (chu->ptr) {
452         giblorb_free(chu->ptr);
453         chu->ptr = NULL;
454     }
455     
456     return giblorb_err_None;
457 }
458
459 giblorb_err_t giblorb_count_resources(giblorb_map_t *map, glui32 usage,
460     glui32 *num, glui32 *min, glui32 *max)
461 {
462     int ix;
463     int count;
464     glui32 val;
465     glui32 minval, maxval;
466     
467     count = 0;
468     minval = 0;
469     maxval = 0;
470     
471     for (ix=0; ix<map->numresources; ix++) {
472         if (map->resources[ix].usage == usage) {
473             val = map->resources[ix].resnum;
474             if (count == 0) {
475                 count++;
476                 minval = val;
477                 maxval = val;
478             }
479             else {
480                 count++;
481                 if (val < minval)
482                     minval = val;
483                 if (val > maxval)
484                     maxval = val;
485             }
486         }
487     }
488     
489     if (num)
490         *num = count;
491     if (min)
492         *min = minval;
493     if (max)
494         *max = maxval;
495     
496     return giblorb_err_None;
497 }
498
499 /* Sorting and searching. */
500
501 static int sortsplot(giblorb_resdesc_t *v1, giblorb_resdesc_t *v2)
502 {
503     if (v1->usage < v2->usage)
504         return -1;
505     if (v1->usage > v2->usage)
506         return 1;
507     if (v1->resnum < v2->resnum)
508         return -1;
509     if (v1->resnum > v2->resnum)
510         return 1;
511     return 0;
512 }
513
514 static void giblorb_qsort(giblorb_resdesc_t **list, int len)
515 {
516     int ix, jx, res;
517     giblorb_resdesc_t *tmpptr, *pivot;
518     
519     if (len < 6) {
520         /* The list is short enough for a bubble-sort. */
521         for (jx=len-1; jx>0; jx--) {
522             for (ix=0; ix<jx; ix++) {
523                 res = sortsplot(list[ix], list[ix+1]);
524                 if (res > 0) {
525                     tmpptr = list[ix];
526                     list[ix] = list[ix+1];
527                     list[ix+1] = tmpptr;
528                 }
529             }
530         }
531     }
532     else {
533         /* Split the list. */
534         pivot = list[len/2];
535         ix=0;
536         jx=len;
537         while (1) {
538             while (ix < jx-1 && sortsplot(list[ix], pivot) < 0)
539                 ix++;
540             while (ix < jx-1 && sortsplot(list[jx-1], pivot) > 0)
541                 jx--;
542             if (ix >= jx-1)
543                 break;
544             tmpptr = list[ix];
545             list[ix] = list[jx-1];
546             list[jx-1] = tmpptr;
547         }
548         ix++;
549         /* Sort the halves. */
550         giblorb_qsort(list+0, ix);
551         giblorb_qsort(list+ix, len-ix);
552     }
553 }
554
555 giblorb_resdesc_t *giblorb_bsearch(giblorb_resdesc_t *sample, 
556     giblorb_resdesc_t **list, int len)
557 {
558     int top, bot, val, res;
559     
560     bot = 0;
561     top = len;
562     
563     while (bot < top) {
564         val = (top+bot) / 2;
565         res = sortsplot(list[val], sample);
566         if (res == 0)
567             return list[val];
568         if (res < 0) {
569             bot = val+1;
570         }
571         else {
572             top = val;
573         }
574     }
575     
576     return NULL;
577 }
578
579
580 /* Boring utility functions. If your platform doesn't support ANSI 
581     malloc(), feel free to edit these however you like. */
582
583 #include <glib.h> /* The OS-native header file -- you can edit 
584     this too. */
585
586 static void *giblorb_malloc(glui32 len)
587 {
588     return g_malloc(len);
589 }
590
591 static void *giblorb_realloc(void *ptr, glui32 len)
592 {
593     return g_realloc(ptr, len);
594 }
595
596 static void giblorb_free(void *ptr)
597 {
598     g_free(ptr);
599 }