Initial community commit

1 files changed, 257 insertions, 0 deletions

diff --git a/Src/bmp/avi_tscc_decoder.cpp b/Src/bmp/avi_tscc_decoder.cpp
new file mode 100644
index 00000000..5649cf2c
--- /dev/null
+++ b/Src/bmp/avi_tscc_decoder.cpp
@@ -0,0 +1,257 @@
+#include "avi_tscc_decoder.h"
+#include "avi_rle_decoder.h"
+#include "avi_yuv_decoder.h"
+#include "../Winamp/wa_ipc.h"
+#include "rle.h"
+#include <limits.h>
+#include <intsafe.h>
+
+AVITSCC *AVITSCC::CreateDecoder(nsavi::video_format *stream_format)
+{
+	size_t bytes_per_pixel = stream_format->bits_per_pixel / 8U;
+	if (bytes_per_pixel > 4)
+		return 0;
+
+	size_t image_size=0;
+	size_t pixel_size=0;
+	size_t data_len=0;
+
+	/* set an upper bound on width so we don't overflow when we multiply uint8_t * 4 * width */
+	if (stream_format->width > (1 << 20))
+		return 0;
+
+	if (SizeTMult(stream_format->width, stream_format->height, &pixel_size) != S_OK || SizeTMult(pixel_size, bytes_per_pixel, &image_size) != S_OK)
+		return 0;
+
+	// calculate worst-case data length (3 * pixel_size / 255 + image_size)
+	if (SizeTMult(pixel_size, 3, &data_len) != S_OK)
+		return 0;
+	pixel_size /= 255;
+	if (SizeTAdd(pixel_size, data_len, &data_len) != S_OK)
+		return 0;
+
+	void *video_frame = (uint8_t *)malloc(image_size);
+	if (!video_frame)
+		return 0;
+
+	// upper bound for decompressed data size
+	
+	void *data = malloc(data_len);
+	if (!data)
+	{
+		free(video_frame);
+		return 0;
+	}
+
+	AVITSCC *decoder = new AVITSCC(video_frame, image_size, data, data_len, stream_format);
+	if (!decoder)
+	{
+		free(video_frame);
+		free(data);
+		return 0;	
+	}
+	
+	return decoder;
+}
+
+AVITSCC::AVITSCC(void *video_frame, size_t video_frame_size, void *data, size_t data_len, nsavi::video_format *stream_format) : stream_format(stream_format), video_frame_size(video_frame_size), video_frame((uint8_t *)video_frame), data((uint8_t *)data), data_len(data_len)
+{
+	video_outputted=false;
+
+	zlib_stream.next_in = Z_NULL;
+	zlib_stream.avail_in = Z_NULL;
+	zlib_stream.next_out = Z_NULL;
+	zlib_stream.avail_out = Z_NULL;
+	zlib_stream.zalloc = (alloc_func)0;
+	zlib_stream.zfree = (free_func)0;
+	zlib_stream.opaque = 0;
+	inflateInit(&zlib_stream);
+}
+
+int AVITSCC::GetOutputProperties(int *x, int *y, int *color_format, double *aspect_ratio, int *flip)
+{
+	if (stream_format)
+	{
+		*x = stream_format->width;
+		*y = stream_format->height;
+		*flip = 1;
+		switch(stream_format->bits_per_pixel)
+		{
+		case 8:
+			*color_format = '8BGR';
+			break;
+		case 16:
+			*color_format = '555R';
+			break;
+		case 24:
+			*color_format = '42GR';
+			break;
+		case 32:
+			*color_format = '23GR';
+			break;
+		default:
+		return AVI_FAILURE;
+		}
+		return AVI_SUCCESS;
+	}
+		
+	return AVI_FAILURE;
+}
+
+
+static bool BoundsCheckX(uint8_t delta_x, size_t bytes_per_pixel, size_t video_frame_size, size_t output_pointer)
+{
+	if ((size_t)delta_x*bytes_per_pixel >= (video_frame_size - output_pointer))
+			return false;
+	return true;
+}
+
+static bool BoundsCheckY(uint8_t delta_y, size_t bytes_per_pixel, size_t width, size_t video_frame_size, size_t output_pointer)
+{
+	if ((size_t)delta_y*bytes_per_pixel*width >= (video_frame_size - output_pointer))
+			return false;
+	return true;
+}
+
+int AVITSCC::DecodeChunk(uint16_t type, const void *inputBuffer, size_t inputBufferBytes)
+{
+	if (stream_format)
+	{
+		if (inflateReset(&zlib_stream) != Z_OK)
+			return AVI_FAILURE;
+
+		size_t bytes_per_pixel = stream_format->bits_per_pixel / 8U;
+
+		zlib_stream.next_in = (Bytef *)inputBuffer;
+    zlib_stream.avail_in = (uInt)inputBufferBytes;
+    zlib_stream.next_out = data;
+    zlib_stream.avail_out = (uInt)data_len;
+
+		int ret = inflate(&zlib_stream, Z_FINISH);
+
+		if (ret == Z_OK || ret == Z_STREAM_END)
+		{
+			if (bytes_per_pixel == 2)
+			{
+				 RLE16(data, data_len, (uint16_t *)video_frame, video_frame_size, stream_format->width);
+			}
+			else if (bytes_per_pixel == 1)
+			{
+				RLE8(data, data_len, (uint8_t *)video_frame, video_frame_size, stream_format->width);
+			}
+			else
+			{
+			const uint8_t * const rle = data;
+			int input = 0;
+			size_t output = 0;
+			int next_line = (int)output + (int)bytes_per_pixel*stream_format->width;
+			for (;;)
+			{
+				uint8_t b0 = rle[input++];
+				if (b0)
+				{
+					uint8_t pixel[4] = {0};
+					memcpy(pixel, &rle[input], bytes_per_pixel);
+					input += (int)bytes_per_pixel;
+
+					if (!BoundsCheckX(b0, bytes_per_pixel, video_frame_size, output))
+						return AVI_FAILURE;
+
+					while (b0--)
+					{
+						memcpy(&video_frame[output], &pixel, bytes_per_pixel);
+						output+=bytes_per_pixel;
+					}
+				}
+				else
+				{
+					uint8_t b1 = rle[input++];
+					if (b1 == 0)
+					{
+						if (next_line > (int)video_frame_size)
+							return AVI_FAILURE;
+
+						output = next_line;
+						next_line = (int)output + (int)bytes_per_pixel*stream_format->width;
+					}
+					else if (b1 == 1)
+					{
+						break;
+					}
+					else if (b1 == 2)
+					{
+						uint8_t p1 = rle[input++];
+						uint8_t p2 = rle[input++];
+						if (!BoundsCheckX(p1, bytes_per_pixel, video_frame_size, output))
+							return AVI_FAILURE;
+
+						output += bytes_per_pixel*p1;
+
+						if (!BoundsCheckY(p2, bytes_per_pixel, stream_format->width, video_frame_size, output))
+							return AVI_FAILURE;
+
+						output += bytes_per_pixel*p2*stream_format->width;
+						next_line += (int)bytes_per_pixel*p2*stream_format->width;
+					}
+					else
+					{
+						if (!BoundsCheckX(b1, bytes_per_pixel, video_frame_size, output))
+							return AVI_FAILURE;
+
+						memcpy(&video_frame[output], &rle[input], b1*bytes_per_pixel);
+						input += b1* (int)bytes_per_pixel;
+						output += b1*bytes_per_pixel;
+						if (bytes_per_pixel == 1 && (b1 & 1))
+							input++;
+					}
+				}
+			}
+			}
+		}
+		else if (ret != Z_DATA_ERROR)
+		{
+			return AVI_FAILURE;
+		}
+
+		video_outputted=false;
+		return AVI_SUCCESS;
+	}
+
+	return AVI_FAILURE;
+}
+
+void AVITSCC::Flush()
+{
+
+}
+
+int AVITSCC::GetPicture(void **data, void **decoder_data)
+{
+	if (!video_outputted && video_frame)
+	{
+		*data = video_frame;
+		*decoder_data=0;
+		video_outputted=true;
+		return AVI_SUCCESS;
+	}
+	
+	return AVI_FAILURE;
+}
+
+void AVITSCC::Close()
+{
+	free(video_frame);
+	free(data);
+	inflateEnd(&zlib_stream);
+	delete this;
+}
+
+#define CBCLASS AVITSCC
+START_DISPATCH;
+CB(GET_OUTPUT_PROPERTIES, GetOutputProperties)
+CB(DECODE_CHUNK, DecodeChunk)
+VCB(FLUSH, Flush)
+VCB(CLOSE, Close)
+CB(GET_PICTURE, GetPicture)
+END_DISPATCH;
+#undef CBCLASS