falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
Browse Source

mjpegdec: more meaningful return values

tags/n1.0
Luca Barbato 13 years ago
parent
20bcce507a
commit
0f64cd1e81
1 changed files with 77 additions and 66 deletions
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +77
    -66
      libavcodec/mjpegdec.c

+ 77
- 66
libavcodec/mjpegdec.c View File

@@ -101,12 +101,13 @@ av_cold int ff_mjpeg_decode_init(AVCodecContext *avctx)
build_basic_mjpeg_vlc(s); build_basic_mjpeg_vlc(s);


if (s->extern_huff) { if (s->extern_huff) {
int ret;
av_log(avctx, AV_LOG_INFO, "mjpeg: using external huffman table\n"); av_log(avctx, AV_LOG_INFO, "mjpeg: using external huffman table\n");
init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size * 8); init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size * 8);
if (ff_mjpeg_decode_dht(s)) {
if ((ret = ff_mjpeg_decode_dht(s))) {
av_log(avctx, AV_LOG_ERROR, av_log(avctx, AV_LOG_ERROR,
"mjpeg: error using external huffman table\n"); "mjpeg: error using external huffman table\n");
return AVERROR_INVALIDDATA;
return ret;
} }
} }
if (avctx->field_order == AV_FIELD_BB) { /* quicktime icefloe 019 */ if (avctx->field_order == AV_FIELD_BB) { /* quicktime icefloe 019 */
@@ -159,18 +160,19 @@ int ff_mjpeg_decode_dht(MJpegDecodeContext *s)
int len, index, i, class, n, v, code_max; int len, index, i, class, n, v, code_max;
uint8_t bits_table[17]; uint8_t bits_table[17];
uint8_t val_table[256]; uint8_t val_table[256];
int ret = 0;


len = get_bits(&s->gb, 16) - 2; len = get_bits(&s->gb, 16) - 2;


while (len > 0) { while (len > 0) {
if (len < 17) if (len < 17)
return -1;
return AVERROR_INVALIDDATA;
class = get_bits(&s->gb, 4); class = get_bits(&s->gb, 4);
if (class >= 2) if (class >= 2)
return -1;
return AVERROR_INVALIDDATA;
index = get_bits(&s->gb, 4); index = get_bits(&s->gb, 4);
if (index >= 4) if (index >= 4)
return -1;
return AVERROR_INVALIDDATA;
n = 0; n = 0;
for (i = 1; i <= 16; i++) { for (i = 1; i <= 16; i++) {
bits_table[i] = get_bits(&s->gb, 8); bits_table[i] = get_bits(&s->gb, 8);
@@ -178,7 +180,7 @@ int ff_mjpeg_decode_dht(MJpegDecodeContext *s)
} }
len -= 17; len -= 17;
if (len < n || n > 256) if (len < n || n > 256)
return -1;
return AVERROR_INVALIDDATA;


code_max = 0; code_max = 0;
for (i = 0; i < n; i++) { for (i = 0; i < n; i++) {
@@ -193,15 +195,15 @@ int ff_mjpeg_decode_dht(MJpegDecodeContext *s)
ff_free_vlc(&s->vlcs[class][index]); ff_free_vlc(&s->vlcs[class][index]);
av_log(s->avctx, AV_LOG_DEBUG, "class=%d index=%d nb_codes=%d\n", av_log(s->avctx, AV_LOG_DEBUG, "class=%d index=%d nb_codes=%d\n",
class, index, code_max + 1); class, index, code_max + 1);
if (build_vlc(&s->vlcs[class][index], bits_table, val_table,
code_max + 1, 0, class > 0) < 0)
return -1;
if ((ret = build_vlc(&s->vlcs[class][index], bits_table, val_table,
code_max + 1, 0, class > 0)) < 0)
return ret;


if (class > 0) { if (class > 0) {
ff_free_vlc(&s->vlcs[2][index]); ff_free_vlc(&s->vlcs[2][index]);
if (build_vlc(&s->vlcs[2][index], bits_table, val_table,
code_max + 1, 0, 0) < 0)
return -1;
if ((ret = build_vlc(&s->vlcs[2][index], bits_table, val_table,
code_max + 1, 0, 0)) < 0)
return ret;
} }
} }
return 0; return 0;
@@ -234,16 +236,17 @@ int ff_mjpeg_decode_sof(MJpegDecodeContext *s)


av_log(s->avctx, AV_LOG_DEBUG, "sof0: picture: %dx%d\n", width, height); av_log(s->avctx, AV_LOG_DEBUG, "sof0: picture: %dx%d\n", width, height);
if (av_image_check_size(width, height, 0, s->avctx)) if (av_image_check_size(width, height, 0, s->avctx))
return -1;
return AVERROR_INVALIDDATA;


nb_components = get_bits(&s->gb, 8); nb_components = get_bits(&s->gb, 8);
if (nb_components <= 0 || if (nb_components <= 0 ||
nb_components > MAX_COMPONENTS) nb_components > MAX_COMPONENTS)
return -1; return -1;
if (s->ls && !(s->bits <= 8 || nb_components == 1)) { if (s->ls && !(s->bits <= 8 || nb_components == 1)) {
av_log(s->avctx, AV_LOG_ERROR,
"only <= 8 bits/component or 16-bit gray accepted for JPEG-LS\n");
return -1;
av_log_missing_feature(s->avctx,
"only <= 8 bits/component or "
"16-bit gray accepted for JPEG-LS\n", 0);
return AVERROR_PATCHWELCOME;
} }
s->nb_components = nb_components; s->nb_components = nb_components;
s->h_max = 1; s->h_max = 1;
@@ -260,16 +263,16 @@ int ff_mjpeg_decode_sof(MJpegDecodeContext *s)
s->v_max = s->v_count[i]; s->v_max = s->v_count[i];
s->quant_index[i] = get_bits(&s->gb, 8); s->quant_index[i] = get_bits(&s->gb, 8);
if (s->quant_index[i] >= 4) if (s->quant_index[i] >= 4)
return -1;
return AVERROR_INVALIDDATA;
av_log(s->avctx, AV_LOG_DEBUG, "component %d %d:%d id: %d quant:%d\n", av_log(s->avctx, AV_LOG_DEBUG, "component %d %d:%d id: %d quant:%d\n",
i, s->h_count[i], s->v_count[i], i, s->h_count[i], s->v_count[i],
s->component_id[i], s->quant_index[i]); s->component_id[i], s->quant_index[i]);
} }


if (s->ls && (s->h_max > 1 || s->v_max > 1)) { if (s->ls && (s->h_max > 1 || s->v_max > 1)) {
av_log(s->avctx, AV_LOG_ERROR,
"Subsampling in JPEG-LS is not supported.\n");
return -1;
av_log_missing_feature(s->avctx,
"Subsampling in JPEG-LS is not supported.\n", 0);
return AVERROR_PATCHWELCOME;
} }


if (s->v_max == 1 && s->h_max == 1 && s->lossless == 1) if (s->v_max == 1 && s->h_max == 1 && s->lossless == 1)
@@ -337,7 +340,7 @@ int ff_mjpeg_decode_sof(MJpegDecodeContext *s)
break; break;
default: default:
av_log(s->avctx, AV_LOG_ERROR, "Unhandled pixel format 0x%x\n", pix_fmt_id); av_log(s->avctx, AV_LOG_ERROR, "Unhandled pixel format 0x%x\n", pix_fmt_id);
return -1;
return AVERROR_PATCHWELCOME;
} }
if (s->ls) { if (s->ls) {
if (s->nb_components > 1) if (s->nb_components > 1)
@@ -414,7 +417,7 @@ static int decode_block(MJpegDecodeContext *s, DCTELEM *block, int component,
val = mjpeg_decode_dc(s, dc_index); val = mjpeg_decode_dc(s, dc_index);
if (val == 0xffff) { if (val == 0xffff) {
av_log(s->avctx, AV_LOG_ERROR, "error dc\n"); av_log(s->avctx, AV_LOG_ERROR, "error dc\n");
return -1;
return AVERROR_INVALIDDATA;
} }
val = val * quant_matrix[0] + s->last_dc[component]; val = val * quant_matrix[0] + s->last_dc[component];
s->last_dc[component] = val; s->last_dc[component] = val;
@@ -442,7 +445,7 @@ static int decode_block(MJpegDecodeContext *s, DCTELEM *block, int component,


if (i > 63) { if (i > 63) {
av_log(s->avctx, AV_LOG_ERROR, "error count: %d\n", i); av_log(s->avctx, AV_LOG_ERROR, "error count: %d\n", i);
return -1;
return AVERROR_INVALIDDATA;
} }
j = s->scantable.permutated[i]; j = s->scantable.permutated[i];
block[j] = level * quant_matrix[j]; block[j] = level * quant_matrix[j];
@@ -462,7 +465,7 @@ static int decode_dc_progressive(MJpegDecodeContext *s, DCTELEM *block,
val = mjpeg_decode_dc(s, dc_index); val = mjpeg_decode_dc(s, dc_index);
if (val == 0xffff) { if (val == 0xffff) {
av_log(s->avctx, AV_LOG_ERROR, "error dc\n"); av_log(s->avctx, AV_LOG_ERROR, "error dc\n");
return -1;
return AVERROR_INVALIDDATA;
} }
val = (val * quant_matrix[0] << Al) + s->last_dc[component]; val = (val * quant_matrix[0] << Al) + s->last_dc[component];
s->last_dc[component] = val; s->last_dc[component] = val;
@@ -511,7 +514,7 @@ static int decode_block_progressive(MJpegDecodeContext *s, DCTELEM *block,
break; break;
} }
av_log(s->avctx, AV_LOG_ERROR, "error count: %d\n", i); av_log(s->avctx, AV_LOG_ERROR, "error count: %d\n", i);
return -1;
return AVERROR_INVALIDDATA;
} }
j = s->scantable.permutated[i]; j = s->scantable.permutated[i];
block[j] = level * quant_matrix[j] << Al; block[j] = level * quant_matrix[j] << Al;
@@ -520,7 +523,7 @@ static int decode_block_progressive(MJpegDecodeContext *s, DCTELEM *block,
i += 15; i += 15;
if (i >= se) { if (i >= se) {
av_log(s->avctx, AV_LOG_ERROR, "ZRL overflow: %d\n", i); av_log(s->avctx, AV_LOG_ERROR, "ZRL overflow: %d\n", i);
return -1;
return AVERROR_INVALIDDATA;
} }
} else { } else {
val = (1 << run); val = (1 << run);
@@ -840,7 +843,7 @@ static int mjpeg_decode_scan(MJpegDecodeContext *s, int nb_components, int Ah,
if (get_bits_left(&s->gb) < 0) { if (get_bits_left(&s->gb) < 0) {
av_log(s->avctx, AV_LOG_ERROR, "overread %d\n", av_log(s->avctx, AV_LOG_ERROR, "overread %d\n",
-get_bits_left(&s->gb)); -get_bits_left(&s->gb));
return -1;
return AVERROR_INVALIDDATA;
} }
for (i = 0; i < nb_components; i++) { for (i = 0; i < nb_components; i++) {
uint8_t *ptr; uint8_t *ptr;
@@ -870,7 +873,7 @@ static int mjpeg_decode_scan(MJpegDecodeContext *s, int nb_components, int Ah,
s->quant_matrixes[s->quant_index[c]]) < 0) { s->quant_matrixes[s->quant_index[c]]) < 0) {
av_log(s->avctx, AV_LOG_ERROR, av_log(s->avctx, AV_LOG_ERROR,
"error y=%d x=%d\n", mb_y, mb_x); "error y=%d x=%d\n", mb_y, mb_x);
return -1;
return AVERROR_INVALIDDATA;
} }
s->dsp.idct_put(ptr, linesize[c], s->block); s->dsp.idct_put(ptr, linesize[c], s->block);
} }
@@ -886,7 +889,7 @@ static int mjpeg_decode_scan(MJpegDecodeContext *s, int nb_components, int Ah,
Al) < 0) { Al) < 0) {
av_log(s->avctx, AV_LOG_ERROR, av_log(s->avctx, AV_LOG_ERROR,
"error y=%d x=%d\n", mb_y, mb_x); "error y=%d x=%d\n", mb_y, mb_x);
return -1;
return AVERROR_INVALIDDATA;
} }
} }
// av_log(s->avctx, AV_LOG_DEBUG, "mb: %d %d processed\n", // av_log(s->avctx, AV_LOG_DEBUG, "mb: %d %d processed\n",
@@ -971,7 +974,7 @@ static int mjpeg_decode_scan_progressive_ac(MJpegDecodeContext *s, int ss,
if (ret < 0) { if (ret < 0) {
av_log(s->avctx, AV_LOG_ERROR, av_log(s->avctx, AV_LOG_ERROR,
"error y=%d x=%d\n", mb_y, mb_x); "error y=%d x=%d\n", mb_y, mb_x);
return -1;
return AVERROR_INVALIDDATA;
} }
} }


@@ -993,7 +996,7 @@ int ff_mjpeg_decode_sos(MJpegDecodeContext *s, const uint8_t *mb_bitmask,
const AVFrame *reference) const AVFrame *reference)
{ {
int len, nb_components, i, h, v, predictor, point_transform; int len, nb_components, i, h, v, predictor, point_transform;
int index, id;
int index, id, ret;
const int block_size = s->lossless ? 1 : 8; const int block_size = s->lossless ? 1 : 8;
int ilv, prev_shift; int ilv, prev_shift;


@@ -1003,11 +1006,11 @@ int ff_mjpeg_decode_sos(MJpegDecodeContext *s, const uint8_t *mb_bitmask,
if (nb_components == 0 || nb_components > MAX_COMPONENTS) { if (nb_components == 0 || nb_components > MAX_COMPONENTS) {
av_log(s->avctx, AV_LOG_ERROR, av_log(s->avctx, AV_LOG_ERROR,
"decode_sos: nb_components (%d) unsupported\n", nb_components); "decode_sos: nb_components (%d) unsupported\n", nb_components);
return -1;
return AVERROR_PATCHWELCOME;
} }
if (len != 6 + 2 * nb_components) { if (len != 6 + 2 * nb_components) {
av_log(s->avctx, AV_LOG_ERROR, "decode_sos: invalid len (%d)\n", len); av_log(s->avctx, AV_LOG_ERROR, "decode_sos: invalid len (%d)\n", len);
return -1;
return AVERROR_INVALIDDATA;
} }
for (i = 0; i < nb_components; i++) { for (i = 0; i < nb_components; i++) {
id = get_bits(&s->gb, 8) - 1; id = get_bits(&s->gb, 8) - 1;
@@ -1019,7 +1022,7 @@ int ff_mjpeg_decode_sos(MJpegDecodeContext *s, const uint8_t *mb_bitmask,
if (index == s->nb_components) { if (index == s->nb_components) {
av_log(s->avctx, AV_LOG_ERROR, av_log(s->avctx, AV_LOG_ERROR,
"decode_sos: index(%d) out of components\n", index); "decode_sos: index(%d) out of components\n", index);
return -1;
return AVERROR_INVALIDDATA;
} }
/* Metasoft MJPEG codec has Cb and Cr swapped */ /* Metasoft MJPEG codec has Cb and Cr swapped */
if (s->avctx->codec_tag == MKTAG('M', 'T', 'S', 'J') if (s->avctx->codec_tag == MKTAG('M', 'T', 'S', 'J')
@@ -1081,40 +1084,46 @@ int ff_mjpeg_decode_sos(MJpegDecodeContext *s, const uint8_t *mb_bitmask,
// for () { // for () {
// reset_ls_coding_parameters(s, 0); // reset_ls_coding_parameters(s, 0);


if (ff_jpegls_decode_picture(s, predictor, point_transform, ilv) < 0)
return -1;
if ((ret = ff_jpegls_decode_picture(s, predictor,
point_transform, ilv)) < 0)
return ret;
} else { } else {
if (s->rgb) { if (s->rgb) {
if (ljpeg_decode_rgb_scan(s, predictor, point_transform) < 0)
return -1;
if ((ret = ljpeg_decode_rgb_scan(s, predictor,
point_transform)) < 0)
return ret;
} else { } else {
if (ljpeg_decode_yuv_scan(s, predictor, point_transform) < 0)
return -1;
if ((ret = ljpeg_decode_yuv_scan(s, predictor,
point_transform)) < 0)
return ret;
} }
} }
} else { } else {
if (s->progressive && predictor) { if (s->progressive && predictor) {
if (mjpeg_decode_scan_progressive_ac(s, predictor, ilv, prev_shift,
point_transform,
mb_bitmask, reference) < 0)
return -1;
if ((ret = mjpeg_decode_scan_progressive_ac(s, predictor,
ilv, prev_shift,
point_transform,
mb_bitmask,
reference)) < 0)
return ret;
} else { } else {
if (mjpeg_decode_scan(s, nb_components, prev_shift, point_transform,
mb_bitmask, reference) < 0)
return -1;
if ((ret = mjpeg_decode_scan(s, nb_components,
prev_shift, point_transform,
mb_bitmask, reference)) < 0)
return ret;
} }
} }
emms_c(); emms_c();
return 0; return 0;
out_of_range: out_of_range:
av_log(s->avctx, AV_LOG_ERROR, "decode_sos: ac/dc index out of range\n"); av_log(s->avctx, AV_LOG_ERROR, "decode_sos: ac/dc index out of range\n");
return -1;
return AVERROR_INVALIDDATA;
} }


static int mjpeg_decode_dri(MJpegDecodeContext *s) static int mjpeg_decode_dri(MJpegDecodeContext *s)
{ {
if (get_bits(&s->gb, 16) != 4) if (get_bits(&s->gb, 16) != 4)
return -1;
return AVERROR_INVALIDDATA;
s->restart_interval = get_bits(&s->gb, 16); s->restart_interval = get_bits(&s->gb, 16);
s->restart_count = 0; s->restart_count = 0;
av_log(s->avctx, AV_LOG_DEBUG, "restart interval: %d\n", av_log(s->avctx, AV_LOG_DEBUG, "restart interval: %d\n",
@@ -1129,9 +1138,9 @@ static int mjpeg_decode_app(MJpegDecodeContext *s)


len = get_bits(&s->gb, 16); len = get_bits(&s->gb, 16);
if (len < 5) if (len < 5)
return -1;
return AVERROR_INVALIDDATA;
if (8 * len > get_bits_left(&s->gb)) if (8 * len > get_bits_left(&s->gb))
return -1;
return AVERROR_INVALIDDATA;


id = get_bits_long(&s->gb, 32); id = get_bits_long(&s->gb, 32);
id = av_be2ne32(id); id = av_be2ne32(id);
@@ -1427,6 +1436,7 @@ int ff_mjpeg_decode_frame(AVCodecContext *avctx, void *data, int *data_size,
const uint8_t *unescaped_buf_ptr; const uint8_t *unescaped_buf_ptr;
int unescaped_buf_size; int unescaped_buf_size;
int start_code; int start_code;
int ret = 0;
AVFrame *picture = data; AVFrame *picture = data;


s->got_picture = 0; // picture from previous image can not be reused s->got_picture = 0; // picture from previous image can not be reused
@@ -1475,9 +1485,9 @@ int ff_mjpeg_decode_frame(AVCodecContext *avctx, void *data, int *data_size,
ff_mjpeg_decode_dqt(s); ff_mjpeg_decode_dqt(s);
break; break;
case DHT: case DHT:
if (ff_mjpeg_decode_dht(s) < 0) {
if ((ret = ff_mjpeg_decode_dht(s)) < 0) {
av_log(avctx, AV_LOG_ERROR, "huffman table decode error\n"); av_log(avctx, AV_LOG_ERROR, "huffman table decode error\n");
return -1;
return ret;
} }
break; break;
case SOF0: case SOF0:
@@ -1485,33 +1495,34 @@ int ff_mjpeg_decode_frame(AVCodecContext *avctx, void *data, int *data_size,
s->lossless = 0; s->lossless = 0;
s->ls = 0; s->ls = 0;
s->progressive = 0; s->progressive = 0;
if (ff_mjpeg_decode_sof(s) < 0)
return -1;
if ((ret = ff_mjpeg_decode_sof(s)) < 0)
return ret;
break; break;
case SOF2: case SOF2:
s->lossless = 0; s->lossless = 0;
s->ls = 0; s->ls = 0;
s->progressive = 1; s->progressive = 1;
if (ff_mjpeg_decode_sof(s) < 0)
return -1;
if ((ret = ff_mjpeg_decode_sof(s)) < 0)
return ret;
break; break;
case SOF3: case SOF3:
s->lossless = 1; s->lossless = 1;
s->ls = 0; s->ls = 0;
s->progressive = 0; s->progressive = 0;
if (ff_mjpeg_decode_sof(s) < 0)
return -1;
if ((ret = ff_mjpeg_decode_sof(s)) < 0)
return ret;
break; break;
case SOF48: case SOF48:
s->lossless = 1; s->lossless = 1;
s->ls = 1; s->ls = 1;
s->progressive = 0; s->progressive = 0;
if (ff_mjpeg_decode_sof(s) < 0)
return -1;
if ((ret = ff_mjpeg_decode_sof(s)) < 0)
return ret;
break; break;
case LSE: case LSE:
if (!CONFIG_JPEGLS_DECODER || ff_jpegls_decode_lse(s) < 0)
return -1;
if (!CONFIG_JPEGLS_DECODER ||
(ret = ff_jpegls_decode_lse(s)) < 0)
return ret;
break; break;
case EOI: case EOI:
s->cur_scan = 0; s->cur_scan = 0;
@@ -1553,9 +1564,9 @@ eoi_parser:
"Can not process SOS before SOF, skipping\n"); "Can not process SOS before SOF, skipping\n");
break; break;
} }
if (ff_mjpeg_decode_sos(s, NULL, NULL) < 0 &&
if ((ret = ff_mjpeg_decode_sos(s, NULL, NULL)) < 0 &&
(avctx->err_recognition & AV_EF_EXPLODE)) (avctx->err_recognition & AV_EF_EXPLODE))
return AVERROR_INVALIDDATA;
return ret;
/* buggy avid puts EOI every 10-20th frame */ /* buggy avid puts EOI every 10-20th frame */
/* if restart period is over process EOI */ /* if restart period is over process EOI */
if ((s->buggy_avid && !s->interlaced) || s->restart_interval) if ((s->buggy_avid && !s->interlaced) || s->restart_interval)
@@ -1595,7 +1606,7 @@ not_the_end:
goto eoi_parser; goto eoi_parser;
} }
av_log(avctx, AV_LOG_FATAL, "No JPEG data found in image\n"); av_log(avctx, AV_LOG_FATAL, "No JPEG data found in image\n");
return -1;
return AVERROR_INVALIDDATA;
the_end: the_end:
av_log(avctx, AV_LOG_DEBUG, "mjpeg decode frame unused %td bytes\n", av_log(avctx, AV_LOG_DEBUG, "mjpeg decode frame unused %td bytes\n",
buf_end - buf_ptr); buf_end - buf_ptr);


Write Preview
Loading…
Cancel
Save