-
#include "quakedef.h"
#include "dpvsimpledecode.h"
}
hz_bitstream_readblocks_t;
-hz_bitstream_read_t *hz_bitstream_read_open(char *filename)
+static hz_bitstream_read_t *hz_bitstream_read_open(char *filename)
{
qfile_t *file;
hz_bitstream_read_t *stream;
- if ((file = FS_Open (filename, "rb", false, false)))
+ if ((file = FS_OpenVirtualFile(filename, false)))
{
- stream = (hz_bitstream_read_t *)malloc(sizeof(hz_bitstream_read_t));
+ stream = (hz_bitstream_read_t *)Z_Malloc(sizeof(hz_bitstream_read_t));
memset(stream, 0, sizeof(*stream));
stream->file = file;
return stream;
return NULL;
}
-void hz_bitstream_read_close(hz_bitstream_read_t *stream)
+static void hz_bitstream_read_close(hz_bitstream_read_t *stream)
{
if (stream)
{
FS_Close(stream->file);
- free(stream);
+ Z_Free(stream);
}
}
-hz_bitstream_readblocks_t *hz_bitstream_read_blocks_new(void)
+static hz_bitstream_readblocks_t *hz_bitstream_read_blocks_new(void)
{
hz_bitstream_readblocks_t *blocks;
- blocks = (hz_bitstream_readblocks_t *)malloc(sizeof(hz_bitstream_readblocks_t));
+ blocks = (hz_bitstream_readblocks_t *)Z_Malloc(sizeof(hz_bitstream_readblocks_t));
if (blocks == NULL)
return NULL;
memset(blocks, 0, sizeof(hz_bitstream_readblocks_t));
return blocks;
}
-void hz_bitstream_read_blocks_free(hz_bitstream_readblocks_t *blocks)
+static void hz_bitstream_read_blocks_free(hz_bitstream_readblocks_t *blocks)
{
hz_bitstream_readblock_t *b, *n;
if (blocks == NULL)
for (b = blocks->blocks;b;b = n)
{
n = b->next;
- free(b);
+ Z_Free(b);
}
- free(blocks);
+ Z_Free(blocks);
}
-void hz_bitstream_read_flushbits(hz_bitstream_readblocks_t *blocks)
+static void hz_bitstream_read_flushbits(hz_bitstream_readblocks_t *blocks)
{
blocks->store = 0;
blocks->count = 0;
}
-int hz_bitstream_read_blocks_read(hz_bitstream_readblocks_t *blocks, hz_bitstream_read_t *stream, unsigned int size)
+static int hz_bitstream_read_blocks_read(hz_bitstream_readblocks_t *blocks, hz_bitstream_read_t *stream, unsigned int size)
{
int s;
hz_bitstream_readblock_t *b, *p;
{
if (b == NULL)
{
- b = (hz_bitstream_readblock_t *)malloc(sizeof(hz_bitstream_readblock_t));
+ b = (hz_bitstream_readblock_t *)Z_Malloc(sizeof(hz_bitstream_readblock_t));
if (b == NULL)
return HZREADERROR_MALLOCFAILED;
b->next = NULL;
return HZREADERROR_OK;
}
-unsigned int hz_bitstream_read_blocks_getbyte(hz_bitstream_readblocks_t *blocks)
+static unsigned int hz_bitstream_read_blocks_getbyte(hz_bitstream_readblocks_t *blocks)
{
while (blocks->current != NULL && blocks->position >= blocks->current->size)
{
return blocks->current->data[blocks->position++];
}
-int hz_bitstream_read_bit(hz_bitstream_readblocks_t *blocks)
+static int hz_bitstream_read_bit(hz_bitstream_readblocks_t *blocks)
{
if (!blocks->count)
{
return (blocks->store >> blocks->count) & 1;
}
-unsigned int hz_bitstream_read_bits(hz_bitstream_readblocks_t *blocks, int size)
+static unsigned int hz_bitstream_read_bits(hz_bitstream_readblocks_t *blocks, int size)
{
unsigned int num = 0;
// we can only handle about 24 bits at a time safely
return num;
}
-unsigned int hz_bitstream_read_byte(hz_bitstream_readblocks_t *blocks)
+static unsigned int hz_bitstream_read_byte(hz_bitstream_readblocks_t *blocks)
{
return hz_bitstream_read_blocks_getbyte(blocks);
}
-unsigned int hz_bitstream_read_short(hz_bitstream_readblocks_t *blocks)
+static unsigned int hz_bitstream_read_short(hz_bitstream_readblocks_t *blocks)
{
return (hz_bitstream_read_byte(blocks) << 8)
| (hz_bitstream_read_byte(blocks));
}
-unsigned int hz_bitstream_read_int(hz_bitstream_readblocks_t *blocks)
+static unsigned int hz_bitstream_read_int(hz_bitstream_readblocks_t *blocks)
{
return (hz_bitstream_read_byte(blocks) << 24)
| (hz_bitstream_read_byte(blocks) << 16)
| (hz_bitstream_read_byte(blocks));
}
-void hz_bitstream_read_bytes(hz_bitstream_readblocks_t *blocks, void *outdata, unsigned int size)
+static void hz_bitstream_read_bytes(hz_bitstream_readblocks_t *blocks, void *outdata, unsigned int size)
{
unsigned char *out;
out = (unsigned char *)outdata;
unsigned int info_imageBmask;
unsigned int info_imageBshift;
unsigned int info_imagesize;
+ double info_aspectratio;
// current video frame (needed because of delta compression)
int videoframenum;
default:
s->error = DPVSIMPLEDECODEERROR_UNSUPPORTEDBPP;
return s->error;
- break;
}
for (Rshift = 0;!(Rmask & 1);Rshift++, Rmask >>= 1);
for (Gshift = 0;!(Gmask & 1);Gshift++, Gmask >>= 1);
// opening and closing streams
-static void StripExtension(char *in, char *out)
-{
- char *dot, *c;
- dot = NULL;
- for (c = in;*c;c++)
- {
- if (*c == ':' || *c == '\\' || *c == '/')
- dot = NULL;
- if (*c == '.')
- dot = c;
- }
- if (dot == NULL)
- {
- // nothing to remove
- strcpy(out, in);
- return;
- }
- else
- {
- memcpy(out, in, dot - in);
- out[dot - in] = 0;
- }
-}
-
// opens a stream
-void *dpvsimpledecode_open(char *filename, char **errorstring)
+void *dpvsimpledecode_open(clvideo_t *video, char *filename, const char **errorstring)
{
dpvsimpledecodestream_t *s;
char t[8], *wavename;
s->info_imagewidth = hz_bitstream_read_short(s->framedatablocks);
s->info_imageheight = hz_bitstream_read_short(s->framedatablocks);
s->info_framerate = (double) hz_bitstream_read_int(s->framedatablocks) * (1.0 / 65536.0);
+ s->info_aspectratio = (double)s->info_imagewidth / (double)s->info_imageheight;
if (s->info_framerate > 0.0)
{
s->videopixels = (unsigned int *)Z_Malloc(s->info_imagewidth * s->info_imageheight * sizeof(*s->videopixels));
if (s->videopixels != NULL)
{
- wavename = (char *)Z_Malloc(strlen(filename) + 10);
+ size_t namelen;
+
+ namelen = strlen(filename) + 10;
+ wavename = (char *)Z_Malloc(namelen);
if (wavename)
{
sfx_t* sfx;
- StripExtension(filename, wavename);
- strcat(wavename, ".wav");
+ FS_StripExtension(filename, wavename, namelen);
+ strlcat(wavename, ".wav", namelen);
sfx = S_PrecacheSound (wavename, false, false);
if (sfx != NULL)
s->sndchan = S_StartSound (-1, 0, sfx, vec3_origin, 1.0f, 0);
else
s->sndchan = -1;
- free(wavename);
+ Z_Free(wavename);
}
// all is well...
+ // set the module functions
s->videoframenum = -10000;
+ video->close = dpvsimpledecode_close;
+ video->getwidth = dpvsimpledecode_getwidth;
+ video->getheight = dpvsimpledecode_getheight;
+ video->getframerate = dpvsimpledecode_getframerate;
+ video->decodeframe = dpvsimpledecode_video;
+ video->getaspectratio = dpvsimpledecode_getaspectratio;
+
return s;
}
else if (errorstring != NULL)
}
else if (errorstring != NULL)
*errorstring = "unable to open file";
- free(s);
+ Z_Free(s);
}
else if (errorstring != NULL)
*errorstring = "unable to allocate memory for stream info structure";
if (s == NULL)
return;
if (s->videopixels)
- free(s->videopixels);
+ Z_Free(s->videopixels);
if (s->sndchan != -1)
- S_StopChannel (s->sndchan);
+ S_StopChannel (s->sndchan, true, true);
if (s->framedatablocks)
hz_bitstream_read_blocks_free(s->framedatablocks);
if (s->bitstream)
hz_bitstream_read_close(s->bitstream);
- free(s);
+ Z_Free(s);
}
// utilitarian functions
// number to DPVSIMPLEDECODEERROR_NONE
// if the supplied string pointer variable is not NULL, it will be set to the
// error message
-int dpvsimpledecode_error(void *stream, char **errorstring)
+int dpvsimpledecode_error(void *stream, const char **errorstring)
{
dpvsimpledecodestream_t *s = (dpvsimpledecodestream_t *)stream;
int e;
return s->info_framerate;
}
-
-
-
+// return aspect ratio of the stream
+double dpvsimpledecode_getaspectratio(void *stream)
+{
+ dpvsimpledecodestream_t *s = (dpvsimpledecodestream_t *)stream;
+ return s->info_aspectratio;
+}
static int dpvsimpledecode_convertpixels(dpvsimpledecodestream_t *s, void *imagedata, int imagebytesperrow)
{
projects / xonotic / darkplaces.git / blobdiff