944 lines
23 KiB
C
944 lines
23 KiB
C
/* $Id: mveplay.c,v 1.9 2003-04-12 00:45:03 btb Exp $ */
|
|
#ifdef HAVE_CONFIG_H
|
|
#include <conf.h>
|
|
#endif
|
|
|
|
#ifndef __MSDOS__
|
|
#define AUDIO
|
|
#endif
|
|
//#define DEBUG
|
|
|
|
#include <string.h>
|
|
#include <errno.h>
|
|
#include <time.h>
|
|
#include <sys/time.h>
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
#include <fcntl.h>
|
|
#include <unistd.h>
|
|
|
|
#if defined(STANDALONE) || defined(AUDIO)
|
|
#include <SDL.h>
|
|
#endif
|
|
|
|
#include "mvelib.h"
|
|
#include "mve_audio.h"
|
|
|
|
#include "decoders.h"
|
|
|
|
#ifndef STANDALONE
|
|
#include "libmve.h"
|
|
#include "u_mem.h"
|
|
#include "gr.h"
|
|
#include "palette.h"
|
|
#endif
|
|
|
|
#ifdef STANDALONE
|
|
#define d_malloc(size) malloc(size)
|
|
#define d_free(ptr) free(ptr)
|
|
#endif
|
|
|
|
#ifndef MIN
|
|
#define MIN(a,b) ((a)<(b)?(a):(b))
|
|
#endif
|
|
|
|
#define MVE_OPCODE_ENDOFSTREAM 0x00
|
|
#define MVE_OPCODE_ENDOFCHUNK 0x01
|
|
#define MVE_OPCODE_CREATETIMER 0x02
|
|
#define MVE_OPCODE_INITAUDIOBUFFERS 0x03
|
|
#define MVE_OPCODE_STARTSTOPAUDIO 0x04
|
|
#define MVE_OPCODE_INITVIDEOBUFFERS 0x05
|
|
|
|
#define MVE_OPCODE_DISPLAYVIDEO 0x07
|
|
#define MVE_OPCODE_AUDIOFRAMEDATA 0x08
|
|
#define MVE_OPCODE_AUDIOFRAMESILENCE 0x09
|
|
#define MVE_OPCODE_INITVIDEOMODE 0x0A
|
|
|
|
#define MVE_OPCODE_SETPALETTE 0x0C
|
|
#define MVE_OPCODE_SETPALETTECOMPRESSED 0x0D
|
|
|
|
#define MVE_OPCODE_SETDECODINGMAP 0x0F
|
|
|
|
#define MVE_OPCODE_VIDEODATA 0x11
|
|
|
|
#define MVE_AUDIO_FLAGS_STEREO 1
|
|
#define MVE_AUDIO_FLAGS_16BIT 2
|
|
#define MVE_AUDIO_FLAGS_COMPRESSED 4
|
|
|
|
int g_spdFactorNum=0;
|
|
static int g_spdFactorDenom=10;
|
|
static int g_frameUpdated = 0;
|
|
|
|
#ifdef STANDALONE
|
|
static int playing = 1;
|
|
int g_sdlVidFlags = SDL_ANYFORMAT | SDL_DOUBLEBUF;
|
|
int g_loop = 0;
|
|
|
|
void initializeMovie(MVESTREAM *mve);
|
|
void playMovie(MVESTREAM *mve);
|
|
void shutdownMovie(MVESTREAM *mve);
|
|
#endif
|
|
|
|
static short get_short(unsigned char *data)
|
|
{
|
|
short value;
|
|
value = data[0] | (data[1] << 8);
|
|
return value;
|
|
}
|
|
|
|
static unsigned short get_ushort(unsigned char *data)
|
|
{
|
|
unsigned short value;
|
|
value = data[0] | (data[1] << 8);
|
|
return value;
|
|
}
|
|
|
|
static int get_int(unsigned char *data)
|
|
{
|
|
int value;
|
|
value = data[0] | (data[1] << 8) | (data[2] << 16) | (data[3] << 24);
|
|
return value;
|
|
}
|
|
|
|
static unsigned int unhandled_chunks[32*256];
|
|
|
|
static int default_seg_handler(unsigned char major, unsigned char minor, unsigned char *data, int len, void *context)
|
|
{
|
|
unhandled_chunks[major<<8|minor]++;
|
|
//fprintf(stderr, "unknown chunk type %02x/%02x\n", major, minor);
|
|
return 1;
|
|
}
|
|
|
|
|
|
/*************************
|
|
* general handlers
|
|
*************************/
|
|
static int end_movie_handler(unsigned char major, unsigned char minor, unsigned char *data, int len, void *context)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
/*************************
|
|
* timer handlers
|
|
*************************/
|
|
|
|
/*
|
|
* timer variables
|
|
*/
|
|
static int timer_created = 0;
|
|
static int micro_frame_delay=0;
|
|
static int timer_started=0;
|
|
static struct timeval timer_expire = {0, 0};
|
|
|
|
#if defined(__APPLE__) && defined(__MACH__)
|
|
int nanosleep(struct timespec *ts, void *rem);
|
|
#endif
|
|
|
|
#ifdef __WIN32
|
|
#include <sys/timeb.h>
|
|
|
|
struct timespec
|
|
{
|
|
long int tv_sec; /* Seconds. */
|
|
long int tv_nsec; /* Nanoseconds. */
|
|
};
|
|
|
|
int gettimeofday(struct timeval *tv, void *tz)
|
|
{
|
|
static int counter = 0;
|
|
struct timeb tm;
|
|
|
|
counter++; /* to avoid collisions */
|
|
ftime(&tm);
|
|
tv->tv_sec = tm.time;
|
|
tv->tv_usec = (tm.millitm * 1000) + counter;
|
|
|
|
return 0;
|
|
}
|
|
|
|
int nanosleep(struct timespec *ts, void *rem)
|
|
{
|
|
_sleep(ts->tv_sec * 1000 + ts->tv_nsec / 1000000);
|
|
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
static int create_timer_handler(unsigned char major, unsigned char minor, unsigned char *data, int len, void *context)
|
|
{
|
|
__extension__ long long temp;
|
|
|
|
if (timer_created)
|
|
return 1;
|
|
else
|
|
timer_created = 1;
|
|
|
|
micro_frame_delay = get_int(data) * (int)get_short(data+4);
|
|
if (g_spdFactorNum != 0)
|
|
{
|
|
temp = micro_frame_delay;
|
|
temp *= g_spdFactorNum;
|
|
temp /= g_spdFactorDenom;
|
|
micro_frame_delay = (int)temp;
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
static void timer_stop(void)
|
|
{
|
|
timer_expire.tv_sec = 0;
|
|
timer_expire.tv_usec = 0;
|
|
timer_started = 0;
|
|
}
|
|
|
|
static void timer_start(void)
|
|
{
|
|
int nsec=0;
|
|
gettimeofday(&timer_expire, NULL);
|
|
timer_expire.tv_usec += micro_frame_delay;
|
|
if (timer_expire.tv_usec > 1000000)
|
|
{
|
|
nsec = timer_expire.tv_usec / 1000000;
|
|
timer_expire.tv_sec += nsec;
|
|
timer_expire.tv_usec -= nsec*1000000;
|
|
}
|
|
timer_started=1;
|
|
}
|
|
|
|
static void do_timer_wait(void)
|
|
{
|
|
int nsec=0;
|
|
struct timespec ts;
|
|
struct timeval tv;
|
|
if (! timer_started)
|
|
return;
|
|
|
|
gettimeofday(&tv, NULL);
|
|
if (tv.tv_sec > timer_expire.tv_sec)
|
|
goto end;
|
|
else if (tv.tv_sec == timer_expire.tv_sec && tv.tv_usec >= timer_expire.tv_usec)
|
|
goto end;
|
|
|
|
ts.tv_sec = timer_expire.tv_sec - tv.tv_sec;
|
|
ts.tv_nsec = 1000 * (timer_expire.tv_usec - tv.tv_usec);
|
|
if (ts.tv_nsec < 0)
|
|
{
|
|
ts.tv_nsec += 1000000000UL;
|
|
--ts.tv_sec;
|
|
}
|
|
#ifdef __CYGWIN__
|
|
usleep(ts.tv_sec * 1000000 + ts.tv_nsec / 1000);
|
|
#else
|
|
if (nanosleep(&ts, NULL) == -1 && errno == EINTR)
|
|
exit(1);
|
|
#endif
|
|
|
|
end:
|
|
timer_expire.tv_usec += micro_frame_delay;
|
|
if (timer_expire.tv_usec > 1000000)
|
|
{
|
|
nsec = timer_expire.tv_usec / 1000000;
|
|
timer_expire.tv_sec += nsec;
|
|
timer_expire.tv_usec -= nsec*1000000;
|
|
}
|
|
}
|
|
|
|
/*************************
|
|
* audio handlers
|
|
*************************/
|
|
#ifdef AUDIO
|
|
#define TOTAL_AUDIO_BUFFERS 64
|
|
|
|
static int audiobuf_created = 0;
|
|
static void mve_audio_callback(void *userdata, unsigned char *stream, int len);
|
|
static short *mve_audio_buffers[TOTAL_AUDIO_BUFFERS];
|
|
static int mve_audio_buflens[TOTAL_AUDIO_BUFFERS];
|
|
static int mve_audio_curbuf_curpos=0;
|
|
static int mve_audio_bufhead=0;
|
|
static int mve_audio_buftail=0;
|
|
static int mve_audio_playing=0;
|
|
static int mve_audio_canplay=0;
|
|
static int mve_audio_compressed=0;
|
|
static int mve_audio_enabled = 1;
|
|
static SDL_AudioSpec *mve_audio_spec=NULL;
|
|
|
|
static void mve_audio_callback(void *userdata, unsigned char *stream, int len)
|
|
{
|
|
int total=0;
|
|
int length;
|
|
if (mve_audio_bufhead == mve_audio_buftail)
|
|
return /* 0 */;
|
|
|
|
//fprintf(stderr, "+ <%d (%d), %d, %d>\n", mve_audio_bufhead, mve_audio_curbuf_curpos, mve_audio_buftail, len);
|
|
|
|
while (mve_audio_bufhead != mve_audio_buftail /* while we have more buffers */
|
|
&& len > (mve_audio_buflens[mve_audio_bufhead]-mve_audio_curbuf_curpos)) /* and while we need more data */
|
|
{
|
|
length = mve_audio_buflens[mve_audio_bufhead]-mve_audio_curbuf_curpos;
|
|
memcpy(stream, /* cur output position */
|
|
((unsigned char *)mve_audio_buffers[mve_audio_bufhead])+mve_audio_curbuf_curpos, /* cur input position */
|
|
length); /* cur input length */
|
|
|
|
total += length;
|
|
stream += length; /* advance output */
|
|
len -= length; /* decrement avail ospace */
|
|
d_free(mve_audio_buffers[mve_audio_bufhead]); /* free the buffer */
|
|
mve_audio_buffers[mve_audio_bufhead]=NULL; /* free the buffer */
|
|
mve_audio_buflens[mve_audio_bufhead]=0; /* free the buffer */
|
|
|
|
if (++mve_audio_bufhead == TOTAL_AUDIO_BUFFERS) /* next buffer */
|
|
mve_audio_bufhead = 0;
|
|
mve_audio_curbuf_curpos = 0;
|
|
}
|
|
|
|
//fprintf(stderr, "= <%d (%d), %d, %d>: %d\n", mve_audio_bufhead, mve_audio_curbuf_curpos, mve_audio_buftail, len, total);
|
|
/* return total; */
|
|
|
|
if (len != 0 /* ospace remaining */
|
|
&& mve_audio_bufhead != mve_audio_buftail) /* buffers remaining */
|
|
{
|
|
memcpy(stream, /* dest */
|
|
((unsigned char *)mve_audio_buffers[mve_audio_bufhead]) + mve_audio_curbuf_curpos, /* src */
|
|
len); /* length */
|
|
|
|
mve_audio_curbuf_curpos += len; /* advance input */
|
|
stream += len; /* advance output (unnecessary) */
|
|
len -= len; /* advance output (unnecessary) */
|
|
|
|
if (mve_audio_curbuf_curpos >= mve_audio_buflens[mve_audio_bufhead]) /* if this ends the current chunk */
|
|
{
|
|
d_free(mve_audio_buffers[mve_audio_bufhead]); /* free buffer */
|
|
mve_audio_buffers[mve_audio_bufhead]=NULL;
|
|
mve_audio_buflens[mve_audio_bufhead]=0;
|
|
|
|
if (++mve_audio_bufhead == TOTAL_AUDIO_BUFFERS) /* next buffer */
|
|
mve_audio_bufhead = 0;
|
|
mve_audio_curbuf_curpos = 0;
|
|
}
|
|
}
|
|
|
|
//fprintf(stderr, "- <%d (%d), %d, %d>\n", mve_audio_bufhead, mve_audio_curbuf_curpos, mve_audio_buftail, len);
|
|
}
|
|
#endif
|
|
|
|
static int create_audiobuf_handler(unsigned char major, unsigned char minor, unsigned char *data, int len, void *context)
|
|
{
|
|
#ifdef AUDIO
|
|
int flags;
|
|
int sample_rate;
|
|
int desired_buffer;
|
|
|
|
int stereo;
|
|
int bitsize;
|
|
int compressed;
|
|
|
|
int format;
|
|
|
|
if (!mve_audio_enabled)
|
|
return 1;
|
|
|
|
if (audiobuf_created)
|
|
return 1;
|
|
else
|
|
audiobuf_created = 1;
|
|
|
|
flags = get_ushort(data + 2);
|
|
sample_rate = get_ushort(data + 4);
|
|
desired_buffer = get_int(data + 6);
|
|
|
|
stereo = (flags & MVE_AUDIO_FLAGS_STEREO) ? 1 : 0;
|
|
bitsize = (flags & MVE_AUDIO_FLAGS_16BIT) ? 1 : 0;
|
|
|
|
if (minor > 0) {
|
|
compressed = flags & MVE_AUDIO_FLAGS_COMPRESSED ? 1 : 0;
|
|
} else {
|
|
compressed = 0;
|
|
}
|
|
|
|
mve_audio_compressed = compressed;
|
|
|
|
if (bitsize == 1) {
|
|
#ifdef WORDS_BIGENDIAN
|
|
format = AUDIO_S16MSB;
|
|
#else
|
|
format = AUDIO_S16LSB;
|
|
#endif
|
|
} else {
|
|
format = AUDIO_U8;
|
|
}
|
|
|
|
fprintf(stderr, "creating audio buffers:\n");
|
|
fprintf(stderr, "sample rate = %d, stereo = %d, bitsize = %d, compressed = %d\n",
|
|
sample_rate, stereo, bitsize ? 16 : 8, compressed);
|
|
|
|
mve_audio_spec = (SDL_AudioSpec *)d_malloc(sizeof(SDL_AudioSpec));
|
|
mve_audio_spec->freq = sample_rate;
|
|
mve_audio_spec->format = format;
|
|
mve_audio_spec->channels = (stereo) ? 2 : 1;
|
|
mve_audio_spec->samples = 4096;
|
|
mve_audio_spec->callback = mve_audio_callback;
|
|
mve_audio_spec->userdata = NULL;
|
|
if (SDL_OpenAudio(mve_audio_spec, NULL) >= 0)
|
|
{
|
|
fprintf(stderr, " success\n");
|
|
mve_audio_canplay = 1;
|
|
}
|
|
else
|
|
{
|
|
fprintf(stderr, " failure : %s\n", SDL_GetError());
|
|
mve_audio_canplay = 0;
|
|
}
|
|
|
|
memset(mve_audio_buffers, 0, sizeof(mve_audio_buffers));
|
|
memset(mve_audio_buflens, 0, sizeof(mve_audio_buflens));
|
|
#endif
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int play_audio_handler(unsigned char major, unsigned char minor, unsigned char *data, int len, void *context)
|
|
{
|
|
#ifdef AUDIO
|
|
if (mve_audio_canplay && !mve_audio_playing && mve_audio_bufhead != mve_audio_buftail)
|
|
{
|
|
SDL_PauseAudio(0);
|
|
mve_audio_playing = 1;
|
|
}
|
|
#endif
|
|
return 1;
|
|
}
|
|
|
|
static int audio_data_handler(unsigned char major, unsigned char minor, unsigned char *data, int len, void *context)
|
|
{
|
|
#ifdef AUDIO
|
|
static const int selected_chan=1;
|
|
int chan;
|
|
int nsamp;
|
|
if (mve_audio_canplay)
|
|
{
|
|
if (mve_audio_playing)
|
|
SDL_LockAudio();
|
|
|
|
chan = get_ushort(data + 2);
|
|
nsamp = get_ushort(data + 4);
|
|
if (chan & selected_chan)
|
|
{
|
|
/* HACK: +4 mveaudio_uncompress adds 4 more bytes */
|
|
if (major == MVE_OPCODE_AUDIOFRAMEDATA) {
|
|
if (mve_audio_compressed) {
|
|
nsamp += 4;
|
|
|
|
mve_audio_buflens[mve_audio_buftail] = nsamp;
|
|
mve_audio_buffers[mve_audio_buftail] = (short *)d_malloc(nsamp);
|
|
mveaudio_uncompress(mve_audio_buffers[mve_audio_buftail], data, -1); /* XXX */
|
|
} else {
|
|
nsamp -= 8;
|
|
data += 8;
|
|
|
|
mve_audio_buflens[mve_audio_buftail] = nsamp;
|
|
mve_audio_buffers[mve_audio_buftail] = (short *)d_malloc(nsamp);
|
|
memcpy(mve_audio_buffers[mve_audio_buftail], data, nsamp);
|
|
}
|
|
} else {
|
|
mve_audio_buflens[mve_audio_buftail] = nsamp;
|
|
mve_audio_buffers[mve_audio_buftail] = (short *)d_malloc(nsamp);
|
|
|
|
memset(mve_audio_buffers[mve_audio_buftail], 0, nsamp); /* XXX */
|
|
}
|
|
|
|
if (++mve_audio_buftail == TOTAL_AUDIO_BUFFERS)
|
|
mve_audio_buftail = 0;
|
|
|
|
if (mve_audio_buftail == mve_audio_bufhead)
|
|
fprintf(stderr, "d'oh! buffer ring overrun (%d)\n", mve_audio_bufhead);
|
|
}
|
|
|
|
if (mve_audio_playing)
|
|
SDL_UnlockAudio();
|
|
}
|
|
#endif
|
|
|
|
return 1;
|
|
}
|
|
|
|
/*************************
|
|
* video handlers
|
|
*************************/
|
|
static int videobuf_created = 0;
|
|
static int video_initialized = 0;
|
|
int g_width, g_height;
|
|
void *g_vBuffers = NULL, *g_vBackBuf1, *g_vBackBuf2;
|
|
|
|
#ifdef STANDALONE
|
|
static SDL_Surface *g_screen;
|
|
#else
|
|
static int g_destX, g_destY;
|
|
#endif
|
|
static int g_screenWidth, g_screenHeight;
|
|
static unsigned char g_palette[768];
|
|
static unsigned char *g_pCurMap=NULL;
|
|
static int g_nMapLength=0;
|
|
static int g_truecolor;
|
|
|
|
static int create_videobuf_handler(unsigned char major, unsigned char minor, unsigned char *data, int len, void *context)
|
|
{
|
|
short w, h;
|
|
short count, truecolor;
|
|
|
|
if (videobuf_created)
|
|
return 1;
|
|
else
|
|
videobuf_created = 1;
|
|
|
|
w = get_short(data);
|
|
h = get_short(data+2);
|
|
|
|
if (minor > 0) {
|
|
count = get_short(data+4);
|
|
} else {
|
|
count = 1;
|
|
}
|
|
|
|
if (minor > 1) {
|
|
truecolor = get_short(data+6);
|
|
} else {
|
|
truecolor = 0;
|
|
}
|
|
|
|
g_width = w << 3;
|
|
g_height = h << 3;
|
|
|
|
/* TODO: * 4 causes crashes on some files */
|
|
g_vBackBuf1 = g_vBuffers = d_malloc(g_width * g_height * 8);
|
|
if (truecolor) {
|
|
g_vBackBuf2 = (unsigned short *)g_vBackBuf1 + (g_width * g_height);
|
|
} else {
|
|
g_vBackBuf2 = (unsigned char *)g_vBackBuf1 + (g_width * g_height);
|
|
}
|
|
|
|
memset(g_vBackBuf1, 0, g_width * g_height * 4);
|
|
|
|
#ifdef DEBUG
|
|
fprintf(stderr, "DEBUG: w,h=%d,%d count=%d, tc=%d\n", w, h, count, truecolor);
|
|
#endif
|
|
|
|
g_truecolor = truecolor;
|
|
|
|
return 1;
|
|
}
|
|
|
|
#ifdef STANDALONE
|
|
static int do_sdl_events()
|
|
{
|
|
SDL_Event event;
|
|
int retr = 0;
|
|
while (SDL_PollEvent(&event)) {
|
|
switch(event.type) {
|
|
case SDL_QUIT:
|
|
playing=0;
|
|
break;
|
|
case SDL_KEYDOWN:
|
|
if (event.key.keysym.sym == SDLK_ESCAPE)
|
|
playing=0;
|
|
break;
|
|
case SDL_KEYUP:
|
|
retr = 1;
|
|
break;
|
|
case SDL_MOUSEBUTTONDOWN:
|
|
/*
|
|
if (event.button.button == SDL_BUTTON_LEFT) {
|
|
printf("GRID: %d,%d (pix:%d,%d)\n",
|
|
event.button.x / 16, event.button.y / 8,
|
|
event.button.x, event.button.y);
|
|
}
|
|
*/
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
return retr;
|
|
}
|
|
|
|
static void ConvertAndDraw()
|
|
{
|
|
int i;
|
|
unsigned char *pal = g_palette;
|
|
unsigned char *pDest;
|
|
unsigned char *pixels = g_vBackBuf1;
|
|
SDL_Surface *screenSprite, *initSprite;
|
|
SDL_Rect renderArea;
|
|
int x, y;
|
|
|
|
initSprite = SDL_CreateRGBSurface(SDL_SWSURFACE, g_width, g_height, g_truecolor?16:8, 0x7C00, 0x03E0, 0x001F, 0);
|
|
|
|
if (!g_truecolor) {
|
|
for(i = 0; i < 256; i++) {
|
|
initSprite->format->palette->colors[i].r = (*pal++) << 2;
|
|
initSprite->format->palette->colors[i].g = (*pal++) << 2;
|
|
initSprite->format->palette->colors[i].b = (*pal++) << 2;
|
|
initSprite->format->palette->colors[i].unused = 0;
|
|
}
|
|
}
|
|
|
|
pDest = initSprite->pixels;
|
|
|
|
if (0 /*g_truecolor*/) {
|
|
|
|
unsigned short *pSrcs, *pDests;
|
|
|
|
pSrcs = (unsigned short *)pixels;
|
|
pDests = (unsigned short *)pDest;
|
|
|
|
for (y=0; y<g_height; y++) {
|
|
for (x = 0; x < g_width; x++) {
|
|
pDests[x] = (1<<15)|*pSrcs;
|
|
pSrcs++;
|
|
}
|
|
pDests += g_screenWidth;
|
|
}
|
|
|
|
} else {
|
|
|
|
for (i=0; i<g_height; i++) {
|
|
memcpy(pDest, pixels, g_width * (g_truecolor?2:1));
|
|
pixels += g_width* (g_truecolor?2:1);
|
|
pDest += initSprite->pitch;
|
|
}
|
|
}
|
|
|
|
screenSprite = SDL_DisplayFormat(initSprite);
|
|
SDL_FreeSurface(initSprite);
|
|
|
|
if (g_screenWidth > screenSprite->w)
|
|
x = (g_screenWidth - screenSprite->w) >> 1;
|
|
else
|
|
x=0;
|
|
if (g_screenHeight > screenSprite->h)
|
|
y = (g_screenHeight - screenSprite->h) >> 1;
|
|
else
|
|
y=0;
|
|
renderArea.x = x;
|
|
renderArea.y = y;
|
|
renderArea.w = MIN(g_screenWidth - x, screenSprite->w);
|
|
renderArea.h = MIN(g_screenHeight - y, screenSprite->h);
|
|
SDL_BlitSurface(screenSprite, NULL, g_screen, &renderArea);
|
|
|
|
SDL_FreeSurface(screenSprite);
|
|
}
|
|
#endif
|
|
|
|
static int display_video_handler(unsigned char major, unsigned char minor, unsigned char *data, int len, void *context)
|
|
{
|
|
#ifdef STANDALONE
|
|
ConvertAndDraw();
|
|
|
|
SDL_Flip(g_screen);
|
|
|
|
do_sdl_events();
|
|
#else
|
|
grs_bitmap *bitmap;
|
|
|
|
bitmap = gr_create_bitmap_raw(g_width, g_height, g_vBackBuf1);
|
|
|
|
if (g_destX == -1) // center it
|
|
g_destX = (g_screenWidth - g_width) >> 1;
|
|
if (g_destY == -1) // center it
|
|
g_destY = (g_screenHeight - g_height) >> 1;
|
|
|
|
gr_palette_load(g_palette);
|
|
|
|
gr_bitmap(g_destX, g_destY, bitmap);
|
|
|
|
gr_free_sub_bitmap(bitmap);
|
|
#endif
|
|
g_frameUpdated = 1;
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int init_video_handler(unsigned char major, unsigned char minor, unsigned char *data, int len, void *context)
|
|
{
|
|
short width, height;
|
|
|
|
if (video_initialized)
|
|
return 1;
|
|
else
|
|
video_initialized = 1;
|
|
|
|
width = get_short(data);
|
|
height = get_short(data+2);
|
|
#ifdef STANDALONE
|
|
g_screen = SDL_SetVideoMode(width, height, 16, g_sdlVidFlags);
|
|
#endif
|
|
g_screenWidth = width;
|
|
g_screenHeight = height;
|
|
memset(g_palette, 0, 765);
|
|
// 255 needs to default to white, for subtitles, etc
|
|
memset(g_palette + 765, 63, 3);
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int video_palette_handler(unsigned char major, unsigned char minor, unsigned char *data, int len, void *context)
|
|
{
|
|
short start, count;
|
|
start = get_short(data);
|
|
count = get_short(data+2);
|
|
memcpy(g_palette + 3*start, data+4, 3*count);
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int video_codemap_handler(unsigned char major, unsigned char minor, unsigned char *data, int len, void *context)
|
|
{
|
|
g_pCurMap = data;
|
|
g_nMapLength = len;
|
|
return 1;
|
|
}
|
|
|
|
static int video_data_handler(unsigned char major, unsigned char minor, unsigned char *data, int len, void *context)
|
|
{
|
|
short nFrameHot, nFrameCold;
|
|
short nXoffset, nYoffset;
|
|
short nXsize, nYsize;
|
|
unsigned short nFlags;
|
|
unsigned char *temp;
|
|
|
|
nFrameHot = get_short(data);
|
|
nFrameCold = get_short(data+2);
|
|
nXoffset = get_short(data+4);
|
|
nYoffset = get_short(data+6);
|
|
nXsize = get_short(data+8);
|
|
nYsize = get_short(data+10);
|
|
nFlags = get_ushort(data+12);
|
|
|
|
if (nFlags & 1)
|
|
{
|
|
temp = (unsigned char *)g_vBackBuf1;
|
|
g_vBackBuf1 = g_vBackBuf2;
|
|
g_vBackBuf2 = temp;
|
|
}
|
|
|
|
/* convert the frame */
|
|
if (g_truecolor) {
|
|
decodeFrame16((unsigned char *)g_vBackBuf1, g_pCurMap, g_nMapLength, data+14, len-14);
|
|
} else {
|
|
decodeFrame8(g_vBackBuf1, g_pCurMap, g_nMapLength, data+14, len-14);
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int end_chunk_handler(unsigned char major, unsigned char minor, unsigned char *data, int len, void *context)
|
|
{
|
|
g_pCurMap=NULL;
|
|
return 1;
|
|
}
|
|
|
|
|
|
#ifdef STANDALONE
|
|
void initializeMovie(MVESTREAM *mve)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < 32; i++)
|
|
mve_set_handler(mve, i, default_seg_handler);
|
|
|
|
memset(unhandled_chunks, 0, 32*256);
|
|
|
|
mve_set_handler(mve, MVE_OPCODE_ENDOFSTREAM, end_movie_handler);
|
|
mve_set_handler(mve, MVE_OPCODE_ENDOFCHUNK, end_chunk_handler);
|
|
mve_set_handler(mve, MVE_OPCODE_CREATETIMER, create_timer_handler);
|
|
mve_set_handler(mve, MVE_OPCODE_INITAUDIOBUFFERS, create_audiobuf_handler);
|
|
mve_set_handler(mve, MVE_OPCODE_STARTSTOPAUDIO, play_audio_handler);
|
|
mve_set_handler(mve, MVE_OPCODE_INITVIDEOBUFFERS, create_videobuf_handler);
|
|
|
|
mve_set_handler(mve, MVE_OPCODE_DISPLAYVIDEO, display_video_handler);
|
|
mve_set_handler(mve, MVE_OPCODE_AUDIOFRAMEDATA, audio_data_handler);
|
|
mve_set_handler(mve, MVE_OPCODE_AUDIOFRAMESILENCE, audio_data_handler);
|
|
mve_set_handler(mve, MVE_OPCODE_INITVIDEOMODE, init_video_handler);
|
|
|
|
mve_set_handler(mve, MVE_OPCODE_SETPALETTE, video_palette_handler);
|
|
mve_set_handler(mve, MVE_OPCODE_SETPALETTECOMPRESSED, video_palette_handler);
|
|
mve_set_handler(mve, MVE_OPCODE_SETDECODINGMAP, video_codemap_handler);
|
|
|
|
mve_set_handler(mve, MVE_OPCODE_VIDEODATA, video_data_handler);
|
|
}
|
|
|
|
void playMovie(MVESTREAM *mve)
|
|
{
|
|
int init_timer=0;
|
|
int cont=1;
|
|
|
|
mve_audio_enabled = 1;
|
|
|
|
while (cont && playing)
|
|
{
|
|
cont = mve_play_next_chunk(mve);
|
|
if (micro_frame_delay && !init_timer)
|
|
{
|
|
timer_start();
|
|
init_timer = 1;
|
|
}
|
|
|
|
do_timer_wait();
|
|
|
|
if (g_loop && !cont) {
|
|
mve_reset(mve);
|
|
cont = 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
void shutdownMovie(MVESTREAM *mve)
|
|
{
|
|
#ifdef DEBUG
|
|
int i;
|
|
#endif
|
|
|
|
timer_stop();
|
|
|
|
#ifdef DEBUG
|
|
for (i = 0; i < 32*256; i++) {
|
|
if (unhandled_chunks[i]) {
|
|
fprintf(stderr, "unhandled chunks of type %02x/%02x: %d\n", i>>8, i&0xFF, unhandled_chunks[i]);
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
#else
|
|
static MVESTREAM *mve = NULL;
|
|
|
|
int MVE_rmPrepMovie(int filehandle, int x, int y, int track)
|
|
{
|
|
int i;
|
|
|
|
if (mve) {
|
|
mve_reset(mve);
|
|
return 0;
|
|
}
|
|
|
|
mve = mve_open_filehandle(filehandle);
|
|
|
|
if (!mve)
|
|
return 1;
|
|
|
|
g_destX = x;
|
|
g_destY = y;
|
|
|
|
for (i = 0; i < 32; i++)
|
|
mve_set_handler(mve, i, default_seg_handler);
|
|
|
|
mve_set_handler(mve, MVE_OPCODE_ENDOFSTREAM, end_movie_handler);
|
|
mve_set_handler(mve, MVE_OPCODE_ENDOFCHUNK, end_chunk_handler);
|
|
mve_set_handler(mve, MVE_OPCODE_CREATETIMER, create_timer_handler);
|
|
mve_set_handler(mve, MVE_OPCODE_INITAUDIOBUFFERS, create_audiobuf_handler);
|
|
mve_set_handler(mve, MVE_OPCODE_STARTSTOPAUDIO, play_audio_handler);
|
|
mve_set_handler(mve, MVE_OPCODE_INITVIDEOBUFFERS, create_videobuf_handler);
|
|
|
|
mve_set_handler(mve, MVE_OPCODE_DISPLAYVIDEO, display_video_handler);
|
|
mve_set_handler(mve, MVE_OPCODE_AUDIOFRAMEDATA, audio_data_handler);
|
|
mve_set_handler(mve, MVE_OPCODE_AUDIOFRAMESILENCE, audio_data_handler);
|
|
mve_set_handler(mve, MVE_OPCODE_INITVIDEOMODE, init_video_handler);
|
|
|
|
mve_set_handler(mve, MVE_OPCODE_SETPALETTE, video_palette_handler);
|
|
mve_set_handler(mve, MVE_OPCODE_SETPALETTECOMPRESSED, default_seg_handler);
|
|
|
|
mve_set_handler(mve, MVE_OPCODE_SETDECODINGMAP, video_codemap_handler);
|
|
|
|
mve_set_handler(mve, MVE_OPCODE_VIDEODATA, video_data_handler);
|
|
|
|
return 0;
|
|
}
|
|
|
|
int MVE_rmStepMovie()
|
|
{
|
|
static int init_timer=0;
|
|
int cont=1;
|
|
|
|
if (!timer_started)
|
|
timer_start();
|
|
|
|
while (cont && !g_frameUpdated) // make a "step" be a frame, not a chunk...
|
|
cont = mve_play_next_chunk(mve);
|
|
g_frameUpdated = 0;
|
|
|
|
if (micro_frame_delay && !init_timer) {
|
|
timer_start();
|
|
init_timer = 1;
|
|
}
|
|
|
|
do_timer_wait();
|
|
|
|
if (cont)
|
|
return 0;
|
|
else
|
|
return MVE_ERR_EOF;
|
|
}
|
|
|
|
void MVE_rmEndMovie()
|
|
{
|
|
#ifdef AUDIO
|
|
int i;
|
|
#endif
|
|
|
|
timer_stop();
|
|
timer_created = 0;
|
|
|
|
#ifdef AUDIO
|
|
if (mve_audio_canplay) {
|
|
// only close audio if we opened it
|
|
SDL_CloseAudio();
|
|
mve_audio_canplay = 0;
|
|
}
|
|
for (i = 0; i < TOTAL_AUDIO_BUFFERS; i++)
|
|
if (mve_audio_buffers[i] != NULL)
|
|
d_free(mve_audio_buffers[i]);
|
|
memset(mve_audio_buffers, 0, sizeof(mve_audio_buffers));
|
|
memset(mve_audio_buflens, 0, sizeof(mve_audio_buflens));
|
|
mve_audio_curbuf_curpos=0;
|
|
mve_audio_bufhead=0;
|
|
mve_audio_buftail=0;
|
|
mve_audio_playing=0;
|
|
mve_audio_canplay=0;
|
|
mve_audio_compressed=0;
|
|
if (mve_audio_spec)
|
|
d_free(mve_audio_spec);
|
|
mve_audio_spec=NULL;
|
|
audiobuf_created = 0;
|
|
#endif
|
|
|
|
d_free(g_vBuffers);
|
|
g_vBuffers = NULL;
|
|
g_pCurMap=NULL;
|
|
g_nMapLength=0;
|
|
videobuf_created = 0;
|
|
video_initialized = 0;
|
|
|
|
mve_close_filehandle(mve);
|
|
mve = NULL;
|
|
}
|
|
|
|
|
|
void MVE_rmHoldMovie()
|
|
{
|
|
timer_started = 0;
|
|
}
|
|
|
|
|
|
void MVE_sndInit(int x)
|
|
{
|
|
#ifdef AUDIO
|
|
if (x == -1)
|
|
mve_audio_enabled = 0;
|
|
else
|
|
mve_audio_enabled = 1;
|
|
#endif
|
|
}
|
|
|
|
#endif
|