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