X-Git-Url: http://de.git.xonotic.org/?p=xonotic%2Fdarkplaces.git;a=blobdiff_plain;f=dpvsimpledecode.c;h=ed89260a9f97a857617d01c55a4f8fb8c445ade1;hp=9927a7606e06eab2a1c75c2a709d7f309bc5d613;hb=35b7d263c31d6576b488a3df4c1b06ad5acb3ecd;hpb=f3e79d752a76a9d6329759a83ec9800a5e4cc92b

diff --git a/dpvsimpledecode.c b/dpvsimpledecode.c
index 9927a760..ed89260a 100644
--- a/dpvsimpledecode.c
+++ b/dpvsimpledecode.c
@@ -1,4 +1,3 @@
-
 #include "quakedef.h"
 #include "dpvsimpledecode.h"
 
@@ -6,9 +5,10 @@
 #define HZREADERROR_EOF 1
 #define HZREADERROR_MALLOCFAILED 2
 
-#define HZREADBLOCKSIZE 16000
+//#define HZREADBLOCKSIZE 16000
+#define HZREADBLOCKSIZE 1048576
 
-typedef struct
+typedef struct hz_bitstream_read_s
 {
 	qfile_t *file;
 	int endoffile;
@@ -23,7 +23,7 @@ typedef struct hz_bitstream_readblock_s
 }
 hz_bitstream_readblock_t;
 
-typedef struct
+typedef struct hz_bitstream_readblocks_s
 {
 	hz_bitstream_readblock_t *blocks;
 	hz_bitstream_readblock_t *current;
@@ -33,13 +33,13 @@ typedef struct
 }
 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)))
+	if ((file = FS_OpenVirtualFile(filename, false)))
 	{
-		stream = 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;
@@ -48,26 +48,26 @@ hz_bitstream_read_t *hz_bitstream_read_open(char *filename)
 		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 = 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)
@@ -75,18 +75,18 @@ void hz_bitstream_read_blocks_free(hz_bitstream_readblocks_t *blocks)
 	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;
@@ -97,7 +97,7 @@ int hz_bitstream_read_blocks_read(hz_bitstream_readblocks_t *blocks, hz_bitstrea
 	{
 		if (b == NULL)
 		{
-			b = 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;
@@ -112,7 +112,7 @@ int hz_bitstream_read_blocks_read(hz_bitstream_readblocks_t *blocks, hz_bitstrea
 		else
 			b->size = s;
 		s -= b->size;
-		if (FS_Read(stream->file, b->data, b->size) != b->size)
+		if (FS_Read(stream->file, b->data, b->size) != (fs_offset_t)b->size)
 		{
 			stream->endoffile = 1;
 			break;
@@ -133,7 +133,7 @@ int hz_bitstream_read_blocks_read(hz_bitstream_readblocks_t *blocks, hz_bitstrea
 	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)
 	{
@@ -145,7 +145,7 @@ unsigned int hz_bitstream_read_blocks_getbyte(hz_bitstream_readblocks_t *blocks)
 	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)
 	{
@@ -157,7 +157,7 @@ int hz_bitstream_read_bit(hz_bitstream_readblocks_t *blocks)
 	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
@@ -178,18 +178,18 @@ unsigned int hz_bitstream_read_bits(hz_bitstream_readblocks_t *blocks, int size)
 	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)
@@ -197,10 +197,10 @@ unsigned int hz_bitstream_read_int(hz_bitstream_readblocks_t *blocks)
 	     | (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 = outdata;
+	out = (unsigned char *)outdata;
 	while (size--)
 		*out++ = hz_bitstream_read_byte(blocks);
 }
@@ -230,6 +230,7 @@ typedef struct dpvsimpledecodestream_s
 	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;
@@ -278,7 +279,6 @@ static int dpvsimpledecode_setpixelformat(dpvsimpledecodestream_t *s, unsigned i
 	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);
@@ -332,38 +332,14 @@ static int dpvsimpledecode_setpixelformat(dpvsimpledecodestream_t *s, unsigned i
 
 // 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;
 	if (errorstring != NULL)
 		*errorstring = NULL;
-	s = malloc(sizeof(dpvsimpledecodestream_t));
+	s = (dpvsimpledecodestream_t *)Z_Malloc(sizeof(dpvsimpledecodestream_t));
 	if (s != NULL)
 	{
 		s->bitstream = hz_bitstream_read_open(filename);
@@ -385,28 +361,40 @@ void *dpvsimpledecode_open(char *filename, char **errorstring)
 						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 = malloc(s->info_imagewidth * s->info_imageheight * sizeof(*s->videopixels));
+							s->videopixels = (unsigned int *)Z_Malloc(s->info_imagewidth * s->info_imageheight * sizeof(*s->videopixels));
 							if (s->videopixels != NULL)
 							{
-								wavename = 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)
@@ -428,7 +416,7 @@ void *dpvsimpledecode_open(char *filename, char **errorstring)
 		}
 		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";
@@ -438,18 +426,18 @@ void *dpvsimpledecode_open(char *filename, char **errorstring)
 // closes a stream
 void dpvsimpledecode_close(void *stream)
 {
-	dpvsimpledecodestream_t *s = stream;
+	dpvsimpledecodestream_t *s = (dpvsimpledecodestream_t *)stream;
 	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
@@ -458,9 +446,9 @@ void dpvsimpledecode_close(void *stream)
 // 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 = stream;
+	dpvsimpledecodestream_t *s = (dpvsimpledecodestream_t *)stream;
 	int e;
 	e = s->error;
 	s->error = 0;
@@ -509,27 +497,30 @@ int dpvsimpledecode_error(void *stream, char **errorstring)
 // returns the width of the image data
 unsigned int dpvsimpledecode_getwidth(void *stream)
 {
-	dpvsimpledecodestream_t *s = stream;
+	dpvsimpledecodestream_t *s = (dpvsimpledecodestream_t *)stream;
 	return s->info_imagewidth;
 }
 
 // returns the height of the image data
 unsigned int dpvsimpledecode_getheight(void *stream)
 {
-	dpvsimpledecodestream_t *s = stream;
+	dpvsimpledecodestream_t *s = (dpvsimpledecodestream_t *)stream;
 	return s->info_imageheight;
 }
 
 // returns the framerate of the stream
 double dpvsimpledecode_getframerate(void *stream)
 {
-	dpvsimpledecodestream_t *s = stream;
+	dpvsimpledecodestream_t *s = (dpvsimpledecodestream_t *)stream;
 	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)
 {
@@ -556,7 +547,7 @@ static int dpvsimpledecode_convertpixels(dpvsimpledecodestream_t *s, void *image
 		unsigned int *outrow;
 		for (y = 0;y < height;y++)
 		{
-			outrow = (void *)((unsigned char *)imagedata + y * imagebytesperrow);
+			outrow = (unsigned int *)((unsigned char *)imagedata + y * imagebytesperrow);
 			for (x = 0;x < width;x++)
 			{
 				a = *in++;
@@ -569,7 +560,7 @@ static int dpvsimpledecode_convertpixels(dpvsimpledecodestream_t *s, void *image
 		unsigned short *outrow;
 		for (y = 0;y < height;y++)
 		{
-			outrow = (void *)((unsigned char *)imagedata + y * imagebytesperrow);
+			outrow = (unsigned short *)((unsigned char *)imagedata + y * imagebytesperrow);
 			if (Rloss == 19 && Gloss == 10 && Bloss == 3 && Rshift == 11 && Gshift == 5 && Bshift == 0)
 			{
 				// optimized
@@ -639,7 +630,7 @@ static int dpvsimpledecode_decompressimage(dpvsimpledecodestream_t *s)
 // decodes a video frame to the supplied output pixels
 int dpvsimpledecode_video(void *stream, void *imagedata, unsigned int Rmask, unsigned int Gmask, unsigned int Bmask, unsigned int bytesperpixel, int imagebytesperrow)
 {
-	dpvsimpledecodestream_t *s = stream;
+	dpvsimpledecodestream_t *s = (dpvsimpledecodestream_t *)stream;
 	unsigned int framedatasize;
 	char t[4];
 	s->error = DPVSIMPLEDECODEERROR_NONE;