19d28e13eab3e5876f0881979516f7176b2e62a8
[btb/d2x.git] / libmve / mvelib.c
1 #include <string.h> // for mem* functions
2 #ifndef _WIN32
3 #include <unistd.h>
4 #include <sys/types.h>
5 #include <sys/stat.h>
6 #include <fcntl.h>
7 #endif
8
9 #include "mvelib.h"
10
11 static const char  MVE_HEADER[]  = "Interplay MVE File\x1A";
12 static const short MVE_HDRCONST1 = 0x001A;
13 static const short MVE_HDRCONST2 = 0x0100;
14 static const short MVE_HDRCONST3 = 0x1133;
15
16 mve_cb_Read mve_read;
17 mve_cb_Alloc mve_alloc;
18 mve_cb_Free mve_free;
19 mve_cb_ShowFrame mve_showframe;
20 mve_cb_SetPalette mve_setpalette;
21
22 /*
23  * private utility functions
24  */
25 static short _mve_get_short(unsigned char *data);
26 static unsigned short _mve_get_ushort(unsigned char *data);
27
28 /*
29  * private functions for mvefile
30  */
31 static MVEFILE *_mvefile_alloc(void);
32 static void _mvefile_free(MVEFILE *movie);
33 static int _mvefile_open(MVEFILE *movie, void *stream);
34 static void _mvefile_reset(MVEFILE *movie);
35 static int  _mvefile_read_header(MVEFILE *movie);
36 static void _mvefile_set_buffer_size(MVEFILE *movie, int buf_size);
37 static int _mvefile_fetch_next_chunk(MVEFILE *movie);
38
39 /*
40  * private functions for mvestream
41  */
42 static MVESTREAM *_mvestream_alloc(void);
43 static void _mvestream_free(MVESTREAM *movie);
44 static int _mvestream_open(MVESTREAM *movie, void *stream);
45 static void _mvestream_reset(MVESTREAM *movie);
46
47 /************************************************************
48  * public MVEFILE functions
49  ************************************************************/
50
51 /*
52  * open an MVE file
53  */
54 MVEFILE *mvefile_open(void *stream)
55 {
56     MVEFILE *file;
57
58     /* create the file */
59     file = _mvefile_alloc();
60     if (! _mvefile_open(file, stream))
61     {
62         _mvefile_free(file);
63         return NULL;
64     }
65
66     /* initialize the file */
67     _mvefile_set_buffer_size(file, 1024);
68
69     /* verify the file's header */
70     if (! _mvefile_read_header(file))
71     {
72         _mvefile_free(file);
73         return NULL;
74     }
75
76     /* now, prefetch the next chunk */
77     _mvefile_fetch_next_chunk(file);
78
79     return file;
80 }
81
82 /*
83  * close a MVE file
84  */
85 void mvefile_close(MVEFILE *movie)
86 {
87     _mvefile_free(movie);
88 }
89
90 /*
91  * reset a MVE file
92  */
93 void mvefile_reset(MVEFILE *file)
94 {
95         _mvefile_reset(file);
96
97     /* initialize the file */
98     _mvefile_set_buffer_size(file, 1024);
99
100     /* verify the file's header */
101     if (! _mvefile_read_header(file))
102     {
103         _mvefile_free(file);
104                 //return NULL;
105     }
106
107     /* now, prefetch the next chunk */
108     _mvefile_fetch_next_chunk(file);
109 }
110
111 /*
112  * get the size of the next segment
113  */
114 int mvefile_get_next_segment_size(MVEFILE *movie)
115 {
116     /* if nothing is cached, fail */
117     if (movie->cur_chunk == NULL  ||  movie->next_segment >= movie->cur_fill)
118         return -1;
119
120     /* if we don't have enough data to get a segment, fail */
121     if (movie->cur_fill - movie->next_segment < 4)
122         return -1;
123
124     /* otherwise, get the data length */
125     return _mve_get_short(movie->cur_chunk + movie->next_segment);
126 }
127
128 /*
129  * get type of next segment in chunk (0xff if no more segments in chunk)
130  */
131 unsigned char mvefile_get_next_segment_major(MVEFILE *movie)
132 {
133     /* if nothing is cached, fail */
134     if (movie->cur_chunk == NULL  ||  movie->next_segment >= movie->cur_fill)
135         return 0xff;
136
137     /* if we don't have enough data to get a segment, fail */
138     if (movie->cur_fill - movie->next_segment < 4)
139         return 0xff;
140
141     /* otherwise, get the data length */
142     return movie->cur_chunk[movie->next_segment + 2];
143 }
144
145 /*
146  * get subtype (version) of next segment in chunk (0xff if no more segments in
147  * chunk)
148  */
149 unsigned char mvefile_get_next_segment_minor(MVEFILE *movie)
150 {
151     /* if nothing is cached, fail */
152     if (movie->cur_chunk == NULL  ||  movie->next_segment >= movie->cur_fill)
153         return 0xff;
154
155     /* if we don't have enough data to get a segment, fail */
156     if (movie->cur_fill - movie->next_segment < 4)
157         return 0xff;
158
159     /* otherwise, get the data length */
160     return movie->cur_chunk[movie->next_segment + 3];
161 }
162
163 /*
164  * see next segment (return NULL if no next segment)
165  */
166 unsigned char *mvefile_get_next_segment(MVEFILE *movie)
167 {
168     /* if nothing is cached, fail */
169     if (movie->cur_chunk == NULL  ||  movie->next_segment >= movie->cur_fill)
170         return NULL;
171
172     /* if we don't have enough data to get a segment, fail */
173     if (movie->cur_fill - movie->next_segment < 4)
174         return NULL;
175
176     /* otherwise, get the data length */
177     return movie->cur_chunk + movie->next_segment + 4;
178 }
179
180 /*
181  * advance to next segment
182  */
183 void mvefile_advance_segment(MVEFILE *movie)
184 {
185     /* if nothing is cached, fail */
186     if (movie->cur_chunk == NULL  ||  movie->next_segment >= movie->cur_fill)
187         return;
188
189     /* if we don't have enough data to get a segment, fail */
190     if (movie->cur_fill - movie->next_segment < 4)
191         return;
192
193     /* else, advance to next segment */
194     movie->next_segment +=
195         (4 + _mve_get_ushort(movie->cur_chunk + movie->next_segment));
196 }
197
198 /*
199  * fetch the next chunk (return 0 if at end of stream)
200  */
201 int mvefile_fetch_next_chunk(MVEFILE *movie)
202 {
203     return _mvefile_fetch_next_chunk(movie);
204 }
205
206 /************************************************************
207  * public MVESTREAM functions
208  ************************************************************/
209
210 /*
211  * open an MVE stream
212  */
213 MVESTREAM *mve_open(void *stream)
214 {
215     MVESTREAM *movie;
216
217     /* allocate */
218     movie = _mvestream_alloc();
219
220     /* open */
221     if (! _mvestream_open(movie, stream))
222     {
223         _mvestream_free(movie);
224         return NULL;
225     }
226
227     return movie;
228 }
229
230 /*
231  * close an MVE stream
232  */
233 void mve_close(MVESTREAM *movie)
234 {
235     _mvestream_free(movie);
236 }
237
238 /*
239  * reset an MVE stream
240  */
241 void mve_reset(MVESTREAM *movie)
242 {
243         _mvestream_reset(movie);
244 }
245
246 /*
247  * set segment type handler
248  */
249 void mve_set_handler(MVESTREAM *movie, unsigned char major, MVESEGMENTHANDLER handler)
250 {
251     if (major < 32)
252         movie->handlers[major] = handler;
253 }
254
255 /*
256  * set segment handler context
257  */
258 void mve_set_handler_context(MVESTREAM *movie, void *context)
259 {
260     movie->context = context;
261 }
262
263 /*
264  * play next chunk
265  */
266 int mve_play_next_chunk(MVESTREAM *movie)
267 {
268     unsigned char major, minor;
269     unsigned char *data;
270     int len;
271
272     /* loop over segments */
273     major = mvefile_get_next_segment_major(movie->movie);
274     while (major != 0xff)
275     {
276         /* check whether to handle the segment */
277         if (major < 32  &&  movie->handlers[major] != NULL)
278         {
279             minor = mvefile_get_next_segment_minor(movie->movie);
280             len = mvefile_get_next_segment_size(movie->movie);
281             data = mvefile_get_next_segment(movie->movie);
282
283             if (! movie->handlers[major](major, minor, data, len, movie->context))
284                 return 0;
285         }
286
287         /* advance to next segment */
288         mvefile_advance_segment(movie->movie);
289         major = mvefile_get_next_segment_major(movie->movie);
290     }
291
292     if (! mvefile_fetch_next_chunk(movie->movie))
293         return 0;
294
295     /* return status */
296     return 1;
297 }
298
299 /************************************************************
300  * private functions
301  ************************************************************/
302
303 /*
304  * allocate an MVEFILE
305  */
306 static MVEFILE *_mvefile_alloc(void)
307 {
308     MVEFILE *file = (MVEFILE *)mve_alloc(sizeof(MVEFILE));
309     file->stream = NULL;
310     file->cur_chunk = NULL;
311     file->buf_size = 0;
312     file->cur_fill = 0;
313     file->next_segment = 0;
314
315     return file;
316 }
317
318 /*
319  * free an MVE file
320  */
321 static void _mvefile_free(MVEFILE *movie)
322 {
323     /* free the stream */
324         movie->stream = NULL;
325
326     /* free the buffer */
327     if (movie->cur_chunk)
328         mve_free(movie->cur_chunk);
329     movie->cur_chunk = NULL;
330
331     /* not strictly necessary */
332     movie->buf_size = 0;
333     movie->cur_fill = 0;
334     movie->next_segment = 0;
335
336     /* free the struct */
337     mve_free(movie);
338 }
339
340 /*
341  * open the file stream in thie object
342  */
343 static int _mvefile_open(MVEFILE *file, void *stream)
344 {
345     file->stream = stream;
346     if (! file->stream)
347         return 0;
348
349     return 1;
350 }
351
352 /*
353  * allocate an MVEFILE
354  */
355 static void _mvefile_reset(MVEFILE *file)
356 {
357 #if 0
358     file->cur_chunk = NULL;
359     file->buf_size = 0;
360     file->cur_fill = 0;
361     file->next_segment = 0;
362 #endif
363 }
364
365 /*
366  * read and verify the header of the recently opened file
367  */
368 static int _mvefile_read_header(MVEFILE *movie)
369 {
370     unsigned char buffer[26];
371
372     /* check the file is open */
373     if (! movie->stream)
374         return 0;
375
376     /* check the file is long enough */
377     if (! mve_read(movie->stream, buffer, 26))
378         return 0;
379
380     /* check the signature */
381     if (memcmp(buffer, MVE_HEADER, 20))
382         return 0;
383
384     /* check the hard-coded constants */
385     if (_mve_get_short(buffer+20) != MVE_HDRCONST1)
386         return 0;
387     if (_mve_get_short(buffer+22) != MVE_HDRCONST2)
388         return 0;
389     if (_mve_get_short(buffer+24) != MVE_HDRCONST3)
390         return 0;
391
392     return 1;
393 }
394
395 static void _mvefile_set_buffer_size(MVEFILE *movie, int buf_size)
396 {
397     unsigned char *new_buffer;
398     int new_len;
399
400     /* check if this would be a redundant operation */
401     if (buf_size  <=  movie->buf_size)
402         return;
403
404     /* allocate new buffer */
405     new_len = 100 + buf_size;
406     new_buffer = (unsigned char *)mve_alloc(new_len);
407
408     /* copy old data */
409     if (movie->cur_chunk  &&  movie->cur_fill)
410         memcpy(new_buffer, movie->cur_chunk, movie->cur_fill);
411
412     /* free old buffer */
413     if (movie->cur_chunk)
414     {
415         mve_free(movie->cur_chunk);
416         movie->cur_chunk = 0;
417     }
418
419     /* install new buffer */
420     movie->cur_chunk = new_buffer;
421     movie->buf_size = new_len;
422 }
423
424 static int _mvefile_fetch_next_chunk(MVEFILE *movie)
425 {
426     unsigned char buffer[4];
427     unsigned short length;
428
429     /* fail if not open */
430     if (! movie->stream)
431         return 0;
432
433     /* fail if we can't read the next segment descriptor */
434     if (! mve_read(movie->stream, buffer, 4))
435         return 0;
436
437     /* pull out the next length */
438     length = _mve_get_short(buffer);
439
440     /* make sure we've got sufficient space */
441     _mvefile_set_buffer_size(movie, length);
442
443     /* read the chunk */
444     if (! mve_read(movie->stream, movie->cur_chunk, length))
445         return 0;
446     movie->cur_fill = length;
447     movie->next_segment = 0;
448
449     return 1;
450 }
451
452 static short _mve_get_short(unsigned char *data)
453 {
454     short value;
455     value = data[0] | (data[1] << 8);
456     return value;
457 }
458
459 static unsigned short _mve_get_ushort(unsigned char *data)
460 {
461     unsigned short value;
462     value = data[0] | (data[1] << 8);
463     return value;
464 }
465
466 /*
467  * allocate an MVESTREAM
468  */
469 static MVESTREAM *_mvestream_alloc(void)
470 {
471     MVESTREAM *movie;
472
473     /* allocate and zero-initialize everything */
474     movie = (MVESTREAM *)mve_alloc(sizeof(MVESTREAM));
475     movie->movie = NULL;
476     movie->context = 0;
477     memset(movie->handlers, 0, sizeof(movie->handlers));
478
479     return movie;
480 }
481
482 /*
483  * free an MVESTREAM
484  */
485 static void _mvestream_free(MVESTREAM *movie)
486 {
487     /* close MVEFILE */
488     if (movie->movie)
489         mvefile_close(movie->movie);
490     movie->movie = NULL;
491
492     /* clear context and handlers */
493     movie->context = NULL;
494     memset(movie->handlers, 0, sizeof(movie->handlers));
495
496         /* free the struct */
497         mve_free(movie);
498 }
499
500 /*
501  * open an MVESTREAM object
502  */
503 static int _mvestream_open(MVESTREAM *movie, void *stream)
504 {
505     movie->movie = mvefile_open(stream);
506
507     return (movie->movie == NULL) ? 0 : 1;
508 }
509
510 /*
511  * reset an MVESTREAM
512  */
513 static void _mvestream_reset(MVESTREAM *movie)
514 {
515         mvefile_reset(movie->movie);
516 }