winamp/Src/bmp/avi_tscc_decoder.cpp
2024-09-24 14:54:57 +02:00

258 lines
5.9 KiB
C++

#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