libmve/mvelib.c

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