Chiebot-Mirror
/
FFmpeg
mirror of https://github.com/FFmpeg/FFmpeg.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

msrle: convert MS RLE decoding function to bytestream2.

Browse Source 
Signed-off-by: Justin Ruggles <justin.ruggles@gmail.com>
pull/5/head
Ronald Bultje 13 years ago committed by Justin Ruggles
parent 729f90e268
commit 992f71e95d
6 changed files with 85 additions and 80 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 12
      libavcodec/aasc.c
  2. 4
      libavcodec/bmp.c
  3. 4
      libavcodec/msrle.c
  4. 129
      libavcodec/msrledec.c
  5. 8
      libavcodec/msrledec.h
  6. 8
      libavcodec/tscc.c

12
libavcodec/aasc.c
Unescape View File

@ -34,17 +34,10 @@
typedef struct AascContext { typedef struct AascContext {
AVCodecContext *avctx; AVCodecContext *avctx;
GetByteContext gb;
AVFrame frame; AVFrame frame;
} AascContext; } AascContext;
#define FETCH_NEXT_STREAM_BYTE() \
if (stream_ptr >= buf_size) \
{ \
av_log(s->avctx, AV_LOG_ERROR, " AASC: stream ptr just went out of bounds (fetch)\n"); \
break; \
} \
stream_byte = buf[stream_ptr++];
static av_cold int aasc_decode_init(AVCodecContext *avctx) static av_cold int aasc_decode_init(AVCodecContext *avctx)
{ {
AascContext *s = avctx->priv_data; AascContext *s = avctx->priv_data;
@ -84,7 +77,8 @@ static int aasc_decode_frame(AVCodecContext *avctx,
} }
break; break;
case 1: case 1:
ff_msrle_decode(avctx, (AVPicture*)&s->frame, 8, buf - 4, buf_size + 4); bytestream2_init(&s->gb, buf - 4, buf_size + 4);
ff_msrle_decode(avctx, (AVPicture*)&s->frame, 8, &s->gb);
break; break;
default: default:
av_log(avctx, AV_LOG_ERROR, "Unknown compression type %d\n", compr); av_log(avctx, AV_LOG_ERROR, "Unknown compression type %d\n", compr);

4
libavcodec/bmp.c
Unescape View File

@ -52,6 +52,7 @@ static int bmp_decode_frame(AVCodecContext *avctx,
uint8_t *ptr; uint8_t *ptr;
int dsize; int dsize;
const uint8_t *buf0 = buf; const uint8_t *buf0 = buf;
GetByteContext gb;
if(buf_size < 14){ if(buf_size < 14){
av_log(avctx, AV_LOG_ERROR, "buf size too small (%d)\n", buf_size); av_log(avctx, AV_LOG_ERROR, "buf size too small (%d)\n", buf_size);
@ -265,7 +266,8 @@ static int bmp_decode_frame(AVCodecContext *avctx,
p->data[0] += p->linesize[0] * (avctx->height - 1); p->data[0] += p->linesize[0] * (avctx->height - 1);
p->linesize[0] = -p->linesize[0]; p->linesize[0] = -p->linesize[0];
} }
ff_msrle_decode(avctx, (AVPicture*)p, depth, buf, dsize); bytestream2_init(&gb, buf, dsize);
ff_msrle_decode(avctx, (AVPicture*)p, depth, &gb);
if(height < 0){ if(height < 0){
p->data[0] += p->linesize[0] * (avctx->height - 1); p->data[0] += p->linesize[0] * (avctx->height - 1);
p->linesize[0] = -p->linesize[0]; p->linesize[0] = -p->linesize[0];

4
libavcodec/msrle.c
Unescape View File

@ -40,6 +40,7 @@ typedef struct MsrleContext {
AVCodecContext *avctx; AVCodecContext *avctx;
AVFrame frame; AVFrame frame;
GetByteContext gb;
const unsigned char *buf; const unsigned char *buf;
int size; int size;
@ -123,7 +124,8 @@ static int msrle_decode_frame(AVCodecContext *avctx,
ptr += s->frame.linesize[0]; ptr += s->frame.linesize[0];
} }
} else { } else {
ff_msrle_decode(avctx, (AVPicture*)&s->frame, avctx->bits_per_coded_sample, buf, buf_size); bytestream2_init(&s->gb, buf, buf_size);
ff_msrle_decode(avctx, (AVPicture*)&s->frame, avctx->bits_per_coded_sample, &s->gb);
} }
*data_size = sizeof(AVFrame); *data_size = sizeof(AVFrame);

129
libavcodec/msrledec.c
Unescape View File

@ -30,18 +30,9 @@
#include "avcodec.h" #include "avcodec.h"
#include "msrledec.h" #include "msrledec.h"
#define FETCH_NEXT_STREAM_BYTE() \
if (stream_ptr >= data_size) \
{ \
av_log(avctx, AV_LOG_ERROR, " MS RLE: stream ptr just went out of bounds (1)\n"); \
return -1; \
} \
stream_byte = data[stream_ptr++];
static int msrle_decode_pal4(AVCodecContext *avctx, AVPicture *pic, static int msrle_decode_pal4(AVCodecContext *avctx, AVPicture *pic,
const uint8_t *data, int data_size) GetByteContext *gb)
{ {
int stream_ptr = 0;
unsigned char rle_code; unsigned char rle_code;
unsigned char extra_byte, odd_pixel; unsigned char extra_byte, odd_pixel;
unsigned char stream_byte; unsigned char stream_byte;
@ -52,11 +43,16 @@ static int msrle_decode_pal4(AVCodecContext *avctx, AVPicture *pic,
int i; int i;
while (row_ptr >= 0) { while (row_ptr >= 0) {
FETCH_NEXT_STREAM_BYTE(); if (bytestream2_get_bytes_left(gb) <= 0) {
rle_code = stream_byte; av_log(avctx, AV_LOG_ERROR,
"MS RLE: bytestream overrun, %d rows left\n",
row_ptr);
return AVERROR_INVALIDDATA;
}
rle_code = stream_byte = bytestream2_get_byteu(gb);
if (rle_code == 0) { if (rle_code == 0) {
/* fetch the next byte to see how to handle escape code */ /* fetch the next byte to see how to handle escape code */
FETCH_NEXT_STREAM_BYTE(); stream_byte = bytestream2_get_byte(gb);
if (stream_byte == 0) { if (stream_byte == 0) {
/* line is done, goto the next one */ /* line is done, goto the next one */
row_ptr -= row_dec; row_ptr -= row_dec;
@ -66,24 +62,26 @@ static int msrle_decode_pal4(AVCodecContext *avctx, AVPicture *pic,
return 0; return 0;
} else if (stream_byte == 2) { } else if (stream_byte == 2) {
/* reposition frame decode coordinates */ /* reposition frame decode coordinates */
FETCH_NEXT_STREAM_BYTE(); stream_byte = bytestream2_get_byte(gb);
pixel_ptr += stream_byte; pixel_ptr += stream_byte;
FETCH_NEXT_STREAM_BYTE(); stream_byte = bytestream2_get_byte(gb);
row_ptr -= stream_byte * row_dec; row_ptr -= stream_byte * row_dec;
} else { } else {
// copy pixels from encoded stream // copy pixels from encoded stream
odd_pixel = stream_byte & 1; odd_pixel = stream_byte & 1;
rle_code = (stream_byte + 1) / 2; rle_code = (stream_byte + 1) / 2;
extra_byte = rle_code & 0x01; extra_byte = rle_code & 0x01;
if (row_ptr + pixel_ptr + stream_byte > frame_size) { if (row_ptr + pixel_ptr + stream_byte > frame_size ||
av_log(avctx, AV_LOG_ERROR, " MS RLE: frame ptr just went out of bounds (1)\n"); bytestream2_get_bytes_left(gb) < rle_code) {
return -1; av_log(avctx, AV_LOG_ERROR,
"MS RLE: frame/stream ptr just went out of bounds (copy)\n");
return AVERROR_INVALIDDATA;
} }
for (i = 0; i < rle_code; i++) { for (i = 0; i < rle_code; i++) {
if (pixel_ptr >= avctx->width) if (pixel_ptr >= avctx->width)
break; break;
FETCH_NEXT_STREAM_BYTE(); stream_byte = bytestream2_get_byteu(gb);
pic->data[0][row_ptr + pixel_ptr] = stream_byte >> 4; pic->data[0][row_ptr + pixel_ptr] = stream_byte >> 4;
pixel_ptr++; pixel_ptr++;
if (i + 1 == rle_code && odd_pixel) if (i + 1 == rle_code && odd_pixel)
@ -96,15 +94,16 @@ static int msrle_decode_pal4(AVCodecContext *avctx, AVPicture *pic,
// if the RLE code is odd, skip a byte in the stream // if the RLE code is odd, skip a byte in the stream
if (extra_byte) if (extra_byte)
stream_ptr++; bytestream2_skip(gb, 1);
} }
} else { } else {
// decode a run of data // decode a run of data
if (row_ptr + pixel_ptr + stream_byte > frame_size) { if (row_ptr + pixel_ptr + stream_byte > frame_size) {
av_log(avctx, AV_LOG_ERROR, " MS RLE: frame ptr just went out of bounds (1)\n"); av_log(avctx, AV_LOG_ERROR,
return -1; "MS RLE: frame ptr just went out of bounds (run)\n");
return AVERROR_INVALIDDATA;
} }
FETCH_NEXT_STREAM_BYTE(); stream_byte = bytestream2_get_byte(gb);
for (i = 0; i < rle_code; i++) { for (i = 0; i < rle_code; i++) {
if (pixel_ptr >= avctx->width) if (pixel_ptr >= avctx->width)
break; break;
@ -118,21 +117,21 @@ static int msrle_decode_pal4(AVCodecContext *avctx, AVPicture *pic,
} }
/* one last sanity check on the way out */ /* one last sanity check on the way out */
if (stream_ptr < data_size) { if (bytestream2_get_bytes_left(gb)) {
av_log(avctx, AV_LOG_ERROR, " MS RLE: ended frame decode with bytes left over (%d < %d)\n", av_log(avctx, AV_LOG_ERROR,
stream_ptr, data_size); "MS RLE: ended frame decode with %d bytes left over\n",
return -1; bytestream2_get_bytes_left(gb));
return AVERROR_INVALIDDATA;
} }
return 0; return 0;
} }
static int msrle_decode_8_16_24_32(AVCodecContext *avctx, AVPicture *pic, int depth, static int msrle_decode_8_16_24_32(AVCodecContext *avctx, AVPicture *pic,
const uint8_t *data, int srcsize) int depth, GetByteContext *gb)
{ {
uint8_t *output, *output_end; uint8_t *output, *output_end;
const uint8_t* src = data;
int p1, p2, line=avctx->height - 1, pos=0, i; int p1, p2, line=avctx->height - 1, pos=0, i;
uint16_t pix16; uint16_t pix16;
uint32_t pix32; uint32_t pix32;
@ -140,23 +139,29 @@ static int msrle_decode_8_16_24_32(AVCodecContext *avctx, AVPicture *pic, int de
output = pic->data[0] + (avctx->height - 1) * pic->linesize[0]; output = pic->data[0] + (avctx->height - 1) * pic->linesize[0];
output_end = pic->data[0] + avctx->height * pic->linesize[0]; output_end = pic->data[0] + avctx->height * pic->linesize[0];
while(src < data + srcsize) { while (bytestream2_get_bytes_left(gb) > 0) {
p1 = *src++; p1 = bytestream2_get_byteu(gb);
if(p1 == 0) { //Escape code if(p1 == 0) { //Escape code
p2 = *src++; p2 = bytestream2_get_byte(gb);
if(p2 == 0) { //End-of-line if(p2 == 0) { //End-of-line
output = pic->data[0] + (--line) * pic->linesize[0]; output = pic->data[0] + (--line) * pic->linesize[0];
if (line < 0 && !(src+1 < data + srcsize && AV_RB16(src) == 1)) { if (line < 0) {
av_log(avctx, AV_LOG_ERROR, "Next line is beyond picture bounds\n"); if (bytestream2_get_be16(gb) == 1) { // end-of-picture
return -1; return 0;
} else {
av_log(avctx, AV_LOG_ERROR,
"Next line is beyond picture bounds (%d bytes left)\n",
bytestream2_get_bytes_left(gb));
return AVERROR_INVALIDDATA;
}
} }
pos = 0; pos = 0;
continue; continue;
} else if(p2 == 1) { //End-of-picture } else if(p2 == 1) { //End-of-picture
return 0; return 0;
} else if(p2 == 2) { //Skip } else if(p2 == 2) { //Skip
p1 = *src++; p1 = bytestream2_get_byte(gb);
p2 = *src++; p2 = bytestream2_get_byte(gb);
line -= p2; line -= p2;
pos += p1; pos += p1;
if (line < 0 || pos >= width){ if (line < 0 || pos >= width){
@ -167,31 +172,31 @@ static int msrle_decode_8_16_24_32(AVCodecContext *avctx, AVPicture *pic, int de
continue; continue;
} }
// Copy data // Copy data
if ((pic->linesize[0] > 0 && output + p2 * (depth >> 3) > output_end) if ((pic->linesize[0] > 0 && output + p2 * (depth >> 3) > output_end) ||
||(pic->linesize[0] < 0 && output + p2 * (depth >> 3) < output_end)) { (pic->linesize[0] < 0 && output + p2 * (depth >> 3) < output_end)) {
src += p2 * (depth >> 3); bytestream2_skip(gb, 2 * (depth >> 3));
continue; continue;
} else if (bytestream2_get_bytes_left(gb) < p2 * (depth >> 3)) {
av_log(avctx, AV_LOG_ERROR, "bytestream overrun\n");
return AVERROR_INVALIDDATA;
} }
if ((depth == 8) || (depth == 24)) { if ((depth == 8) || (depth == 24)) {
for(i = 0; i < p2 * (depth >> 3); i++) { for(i = 0; i < p2 * (depth >> 3); i++) {
*output++ = *src++; *output++ = bytestream2_get_byteu(gb);
} }
// RLE8 copy is actually padded - and runs are not! // RLE8 copy is actually padded - and runs are not!
if(depth == 8 && (p2 & 1)) { if(depth == 8 && (p2 & 1)) {
src++; bytestream2_skip(gb, 1);
} }
} else if (depth == 16) { } else if (depth == 16) {
for(i = 0; i < p2; i++) { for(i = 0; i < p2; i++) {
pix16 = AV_RL16(src); *(uint16_t*)output = bytestream2_get_le16u(gb);
src += 2;
*(uint16_t*)output = pix16;
output += 2; output += 2;
} }
} else if (depth == 32) { } else if (depth == 32) {
for(i = 0; i < p2; i++) { for(i = 0; i < p2; i++) {
pix32 = AV_RL32(src); *(uint32_t*)output = bytestream2_get_le32u(gb);
src += 4;
*(uint32_t*)output = pix32;
output += 4; output += 4;
} }
} }
@ -199,21 +204,19 @@ static int msrle_decode_8_16_24_32(AVCodecContext *avctx, AVPicture *pic, int de
} else { //run of pixels } else { //run of pixels
uint8_t pix[3]; //original pixel uint8_t pix[3]; //original pixel
switch(depth){ switch(depth){
case 8: pix[0] = *src++; case 8: pix[0] = bytestream2_get_byte(gb);
break; break;
case 16: pix16 = AV_RL16(src); case 16: pix16 = bytestream2_get_le16(gb);
src += 2;
break; break;
case 24: pix[0] = *src++; case 24: pix[0] = bytestream2_get_byte(gb);
pix[1] = *src++; pix[1] = bytestream2_get_byte(gb);
pix[2] = *src++; pix[2] = bytestream2_get_byte(gb);
break; break;
case 32: pix32 = AV_RL32(src); case 32: pix32 = bytestream2_get_le32(gb);
src += 4;
break; break;
} }
if ((pic->linesize[0] > 0 && output + p1 * (depth >> 3) > output_end) if ((pic->linesize[0] > 0 && output + p1 * (depth >> 3) > output_end) ||
||(pic->linesize[0] < 0 && output + p1 * (depth >> 3) < output_end)) (pic->linesize[0] < 0 && output + p1 * (depth >> 3) < output_end))
continue; continue;
for(i = 0; i < p1; i++) { for(i = 0; i < p1; i++) {
switch(depth){ switch(depth){
@ -240,17 +243,17 @@ static int msrle_decode_8_16_24_32(AVCodecContext *avctx, AVPicture *pic, int de
} }
int ff_msrle_decode(AVCodecContext *avctx, AVPicture *pic, int depth, int ff_msrle_decode(AVCodecContext *avctx, AVPicture *pic,
const uint8_t* data, int data_size) int depth, GetByteContext *gb)
{ {
switch(depth){ switch(depth){
case 4: case 4:
return msrle_decode_pal4(avctx, pic, data, data_size); return msrle_decode_pal4(avctx, pic, gb);
case 8: case 8:
case 16: case 16:
case 24: case 24:
case 32: case 32:
return msrle_decode_8_16_24_32(avctx, pic, depth, data, data_size); return msrle_decode_8_16_24_32(avctx, pic, depth, gb);
default: default:
av_log(avctx, AV_LOG_ERROR, "Unknown depth %d\n", depth); av_log(avctx, AV_LOG_ERROR, "Unknown depth %d\n", depth);
return -1; return -1;

8
libavcodec/msrledec.h
Unescape View File

@ -23,6 +23,7 @@
#define AVCODEC_MSRLEDEC_H #define AVCODEC_MSRLEDEC_H
#include "avcodec.h" #include "avcodec.h"
#include "bytestream.h"
/** /**
* Decode stream in MS RLE format into frame. * Decode stream in MS RLE format into frame.
@ -30,10 +31,9 @@
* @param avctx codec context * @param avctx codec context
* @param pic destination frame * @param pic destination frame
* @param depth bit depth * @param depth bit depth
* @param data input stream * @param gb input bytestream context
* @param data_size input size
*/ */
int ff_msrle_decode(AVCodecContext *avctx, AVPicture *pic, int depth, int ff_msrle_decode(AVCodecContext *avctx, AVPicture *pic,
const uint8_t* data, int data_size); int depth, GetByteContext *gb);
#endif /* AVCODEC_MSRLEDEC_H */ #endif /* AVCODEC_MSRLEDEC_H */

8
libavcodec/tscc.c
Unescape View File

@ -58,6 +58,7 @@ typedef struct TsccContext {
unsigned int decomp_size; unsigned int decomp_size;
// Decompression buffer // Decompression buffer
unsigned char* decomp_buf; unsigned char* decomp_buf;
GetByteContext gb;
int height; int height;
z_stream zstream; z_stream zstream;
@ -105,8 +106,11 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPac
} }
if(zret != Z_DATA_ERROR) if (zret != Z_DATA_ERROR) {
ff_msrle_decode(avctx, (AVPicture*)&c->pic, c->bpp, c->decomp_buf, c->decomp_size - c->zstream.avail_out); bytestream2_init(&c->gb, c->decomp_buf,
c->decomp_size - c->zstream.avail_out);
ff_msrle_decode(avctx, (AVPicture*)&c->pic, c->bpp, &c->gb);
}
/* make the palette available on the way out */ /* make the palette available on the way out */
if (c->avctx->pix_fmt == PIX_FMT_PAL8) { if (c->avctx->pix_fmt == PIX_FMT_PAL8) {

Write Preview
Loading…
Cancel
Save