From 54974c62982ae827becdbdb9b620b7ba75d079a0 Mon Sep 17 00:00:00 2001 From: Anton Khirnov Date: Sat, 2 Feb 2013 20:42:07 +0100 Subject: [PATCH] error_resilience: decouple ER from MpegEncContext --- libavcodec/error_resilience.c | 407 +++++++++++++++++------------------------- libavcodec/error_resilience.h | 74 ++++++++ libavcodec/h261dec.c | 2 +- libavcodec/h263dec.c | 20 +-- libavcodec/h264.c | 65 +++++-- libavcodec/intrax8.c | 2 +- libavcodec/mpeg12.c | 20 +-- libavcodec/mpeg4videodec.c | 10 +- libavcodec/mpegvideo.c | 95 ++++++++-- libavcodec/mpegvideo.h | 23 +-- libavcodec/mpegvideo_enc.c | 2 +- libavcodec/mss2.c | 4 +- libavcodec/rv10.c | 8 +- libavcodec/rv34.c | 12 +- libavcodec/vc1dec.c | 22 +-- 15 files changed, 431 insertions(+), 335 deletions(-) create mode 100644 libavcodec/error_resilience.h diff --git a/libavcodec/error_resilience.c b/libavcodec/error_resilience.c index 67552dfd82..ff25c91455 100644 --- a/libavcodec/error_resilience.c +++ b/libavcodec/error_resilience.c @@ -29,58 +29,21 @@ #include "avcodec.h" #include "dsputil.h" +#include "error_resilience.h" #include "mpegvideo.h" -#include "h264.h" #include "rectangle.h" #include "thread.h" -/* - * H264 redefines mb_intra so it is not mistakely used (its uninitialized in h264) - * but error concealment must support both h264 and h263 thus we must undo this - */ -#undef mb_intra - -static void decode_mb(MpegEncContext *s, int ref) -{ - s->dest[0] = s->current_picture.f.data[0] + (s->mb_y * 16 * s->linesize) + s->mb_x * 16; - s->dest[1] = s->current_picture.f.data[1] + (s->mb_y * (16 >> s->chroma_y_shift) * s->uvlinesize) + s->mb_x * (16 >> s->chroma_x_shift); - s->dest[2] = s->current_picture.f.data[2] + (s->mb_y * (16 >> s->chroma_y_shift) * s->uvlinesize) + s->mb_x * (16 >> s->chroma_x_shift); - - if (CONFIG_H264_DECODER && s->codec_id == AV_CODEC_ID_H264) { - H264Context *h = (void*)s; - h->mb_xy = s->mb_x + s->mb_y * s->mb_stride; - memset(h->non_zero_count_cache, 0, sizeof(h->non_zero_count_cache)); - assert(ref >= 0); - /* FIXME: It is possible albeit uncommon that slice references - * differ between slices. We take the easy approach and ignore - * it for now. If this turns out to have any relevance in - * practice then correct remapping should be added. */ - if (ref >= h->ref_count[0]) - ref = 0; - fill_rectangle(&s->current_picture.f.ref_index[0][4 * h->mb_xy], - 2, 2, 2, ref, 1); - fill_rectangle(&h->ref_cache[0][scan8[0]], 4, 4, 8, ref, 1); - fill_rectangle(h->mv_cache[0][scan8[0]], 4, 4, 8, - pack16to32(s->mv[0][0][0], s->mv[0][0][1]), 4); - assert(!FRAME_MBAFF); - ff_h264_hl_decode_mb(h); - } else { - assert(ref == 0); - ff_MPV_decode_mb(s, s->block); - } -} - /** * @param stride the number of MVs to get to the next row * @param mv_step the number of MVs per row or column in a macroblock */ -static void set_mv_strides(MpegEncContext *s, int *mv_step, int *stride) +static void set_mv_strides(ERContext *s, int *mv_step, int *stride) { - if (s->codec_id == AV_CODEC_ID_H264) { - H264Context *h = (void*)s; + if (s->avctx->codec_id == AV_CODEC_ID_H264) { assert(s->quarter_sample); *mv_step = 4; - *stride = h->b_stride; + *stride = s->mb_width * 4; } else { *mv_step = 2; *stride = s->b8_stride; @@ -90,9 +53,10 @@ static void set_mv_strides(MpegEncContext *s, int *mv_step, int *stride) /** * Replace the current MB with a flat dc-only version. */ -static void put_dc(MpegEncContext *s, uint8_t *dest_y, uint8_t *dest_cb, +static void put_dc(ERContext *s, uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, int mb_x, int mb_y) { + int *linesize = s->cur_pic->f.linesize; int dc, dcu, dcv, y, i; for (i = 0; i < 4; i++) { dc = s->dc_val[0][mb_x * 2 + (i & 1) + (mb_y * 2 + (i >> 1)) * s->b8_stride]; @@ -103,7 +67,7 @@ static void put_dc(MpegEncContext *s, uint8_t *dest_y, uint8_t *dest_cb, for (y = 0; y < 8; y++) { int x; for (x = 0; x < 8; x++) - dest_y[x + (i & 1) * 8 + (y + (i >> 1) * 8) * s->linesize] = dc / 8; + dest_y[x + (i & 1) * 8 + (y + (i >> 1) * 8) * linesize[0]] = dc / 8; } } dcu = s->dc_val[1][mb_x + mb_y * s->mb_stride]; @@ -119,8 +83,8 @@ static void put_dc(MpegEncContext *s, uint8_t *dest_y, uint8_t *dest_cb, for (y = 0; y < 8; y++) { int x; for (x = 0; x < 8; x++) { - dest_cb[x + y * s->uvlinesize] = dcu / 8; - dest_cr[x + y * s->uvlinesize] = dcv / 8; + dest_cb[x + y * linesize[1]] = dcu / 8; + dest_cr[x + y * linesize[2]] = dcv / 8; } } } @@ -166,7 +130,7 @@ static void filter181(int16_t *data, int width, int height, int stride) * @param w width in 8 pixel blocks * @param h height in 8 pixel blocks */ -static void guess_dc(MpegEncContext *s, int16_t *dc, int w, +static void guess_dc(ERContext *s, int16_t *dc, int w, int h, int stride, int is_luma) { int b_x, b_y; @@ -180,7 +144,7 @@ static void guess_dc(MpegEncContext *s, int16_t *dc, int w, mb_index = (b_x >> is_luma) + (b_y >> is_luma) * s->mb_stride; error = s->error_status_table[mb_index]; - if (IS_INTER(s->current_picture.f.mb_type[mb_index])) + if (IS_INTER(s->cur_pic->f.mb_type[mb_index])) continue; // inter if (!(error & ER_DC_ERROR)) continue; // dc-ok @@ -189,7 +153,7 @@ static void guess_dc(MpegEncContext *s, int16_t *dc, int w, for (j = b_x + 1; j < w; j++) { int mb_index_j = (j >> is_luma) + (b_y >> is_luma) * s->mb_stride; int error_j = s->error_status_table[mb_index_j]; - int intra_j = IS_INTRA(s->current_picture.f.mb_type[mb_index_j]); + int intra_j = IS_INTRA(s->cur_pic->f.mb_type[mb_index_j]); if (intra_j == 0 || !(error_j & ER_DC_ERROR)) { color[0] = dc[j + b_y * stride]; distance[0] = j - b_x; @@ -201,7 +165,7 @@ static void guess_dc(MpegEncContext *s, int16_t *dc, int w, for (j = b_x - 1; j >= 0; j--) { int mb_index_j = (j >> is_luma) + (b_y >> is_luma) * s->mb_stride; int error_j = s->error_status_table[mb_index_j]; - int intra_j = IS_INTRA(s->current_picture.f.mb_type[mb_index_j]); + int intra_j = IS_INTRA(s->cur_pic->f.mb_type[mb_index_j]); if (intra_j == 0 || !(error_j & ER_DC_ERROR)) { color[1] = dc[j + b_y * stride]; distance[1] = b_x - j; @@ -213,7 +177,7 @@ static void guess_dc(MpegEncContext *s, int16_t *dc, int w, for (j = b_y + 1; j < h; j++) { int mb_index_j = (b_x >> is_luma) + (j >> is_luma) * s->mb_stride; int error_j = s->error_status_table[mb_index_j]; - int intra_j = IS_INTRA(s->current_picture.f.mb_type[mb_index_j]); + int intra_j = IS_INTRA(s->cur_pic->f.mb_type[mb_index_j]); if (intra_j == 0 || !(error_j & ER_DC_ERROR)) { color[2] = dc[b_x + j * stride]; @@ -226,7 +190,7 @@ static void guess_dc(MpegEncContext *s, int16_t *dc, int w, for (j = b_y - 1; j >= 0; j--) { int mb_index_j = (b_x >> is_luma) + (j >> is_luma) * s->mb_stride; int error_j = s->error_status_table[mb_index_j]; - int intra_j = IS_INTRA(s->current_picture.f.mb_type[mb_index_j]); + int intra_j = IS_INTRA(s->cur_pic->f.mb_type[mb_index_j]); if (intra_j == 0 || !(error_j & ER_DC_ERROR)) { color[3] = dc[b_x + j * stride]; distance[3] = b_y - j; @@ -252,7 +216,7 @@ static void guess_dc(MpegEncContext *s, int16_t *dc, int w, * @param w width in 8 pixel blocks * @param h height in 8 pixel blocks */ -static void h_block_filter(MpegEncContext *s, uint8_t *dst, int w, +static void h_block_filter(ERContext *s, uint8_t *dst, int w, int h, int stride, int is_luma) { int b_x, b_y, mvx_stride, mvy_stride; @@ -266,13 +230,13 @@ static void h_block_filter(MpegEncContext *s, uint8_t *dst, int w, int y; int left_status = s->error_status_table[( b_x >> is_luma) + (b_y >> is_luma) * s->mb_stride]; int right_status = s->error_status_table[((b_x + 1) >> is_luma) + (b_y >> is_luma) * s->mb_stride]; - int left_intra = IS_INTRA(s->current_picture.f.mb_type[( b_x >> is_luma) + (b_y >> is_luma) * s->mb_stride]); - int right_intra = IS_INTRA(s->current_picture.f.mb_type[((b_x + 1) >> is_luma) + (b_y >> is_luma) * s->mb_stride]); + int left_intra = IS_INTRA(s->cur_pic->f.mb_type[( b_x >> is_luma) + (b_y >> is_luma) * s->mb_stride]); + int right_intra = IS_INTRA(s->cur_pic->f.mb_type[((b_x + 1) >> is_luma) + (b_y >> is_luma) * s->mb_stride]); int left_damage = left_status & ER_MB_ERROR; int right_damage = right_status & ER_MB_ERROR; int offset = b_x * 8 + b_y * stride * 8; - int16_t *left_mv = s->current_picture.f.motion_val[0][mvy_stride * b_y + mvx_stride * b_x]; - int16_t *right_mv = s->current_picture.f.motion_val[0][mvy_stride * b_y + mvx_stride * (b_x + 1)]; + int16_t *left_mv = s->cur_pic->f.motion_val[0][mvy_stride * b_y + mvx_stride * b_x]; + int16_t *right_mv = s->cur_pic->f.motion_val[0][mvy_stride * b_y + mvx_stride * (b_x + 1)]; if (!(left_damage || right_damage)) continue; // both undamaged if ((!left_intra) && (!right_intra) && @@ -320,7 +284,7 @@ static void h_block_filter(MpegEncContext *s, uint8_t *dst, int w, * @param w width in 8 pixel blocks * @param h height in 8 pixel blocks */ -static void v_block_filter(MpegEncContext *s, uint8_t *dst, int w, int h, +static void v_block_filter(ERContext *s, uint8_t *dst, int w, int h, int stride, int is_luma) { int b_x, b_y, mvx_stride, mvy_stride; @@ -334,14 +298,14 @@ static void v_block_filter(MpegEncContext *s, uint8_t *dst, int w, int h, int x; int top_status = s->error_status_table[(b_x >> is_luma) + (b_y >> is_luma) * s->mb_stride]; int bottom_status = s->error_status_table[(b_x >> is_luma) + ((b_y + 1) >> is_luma) * s->mb_stride]; - int top_intra = IS_INTRA(s->current_picture.f.mb_type[(b_x >> is_luma) + ( b_y >> is_luma) * s->mb_stride]); - int bottom_intra = IS_INTRA(s->current_picture.f.mb_type[(b_x >> is_luma) + ((b_y + 1) >> is_luma) * s->mb_stride]); + int top_intra = IS_INTRA(s->cur_pic->f.mb_type[(b_x >> is_luma) + ( b_y >> is_luma) * s->mb_stride]); + int bottom_intra = IS_INTRA(s->cur_pic->f.mb_type[(b_x >> is_luma) + ((b_y + 1) >> is_luma) * s->mb_stride]); int top_damage = top_status & ER_MB_ERROR; int bottom_damage = bottom_status & ER_MB_ERROR; int offset = b_x * 8 + b_y * stride * 8; - int16_t *top_mv = s->current_picture.f.motion_val[0][mvy_stride * b_y + mvx_stride * b_x]; - int16_t *bottom_mv = s->current_picture.f.motion_val[0][mvy_stride * (b_y + 1) + mvx_stride * b_x]; + int16_t *top_mv = s->cur_pic->f.motion_val[0][mvy_stride * b_y + mvx_stride * b_x]; + int16_t *bottom_mv = s->cur_pic->f.motion_val[0][mvy_stride * (b_y + 1) + mvx_stride * b_x]; if (!(top_damage || bottom_damage)) continue; // both undamaged @@ -386,7 +350,7 @@ static void v_block_filter(MpegEncContext *s, uint8_t *dst, int w, int h, } } -static void guess_mv(MpegEncContext *s) +static void guess_mv(ERContext *s) { uint8_t *fixed = s->er_temp_buffer; #define MV_FROZEN 3 @@ -406,7 +370,7 @@ static void guess_mv(MpegEncContext *s) int f = 0; int error = s->error_status_table[mb_xy]; - if (IS_INTRA(s->current_picture.f.mb_type[mb_xy])) + if (IS_INTRA(s->cur_pic->f.mb_type[mb_xy])) f = MV_FROZEN; // intra // FIXME check if (!(error & ER_MV_ERROR)) f = MV_FROZEN; // inter with undamaged MV @@ -419,32 +383,19 @@ static void guess_mv(MpegEncContext *s) if ((!(s->avctx->error_concealment&FF_EC_GUESS_MVS)) || num_avail <= mb_width / 2) { for (mb_y = 0; mb_y < s->mb_height; mb_y++) { - s->mb_x = 0; - s->mb_y = mb_y; - ff_init_block_index(s); for (mb_x = 0; mb_x < s->mb_width; mb_x++) { const int mb_xy = mb_x + mb_y * s->mb_stride; + int mv_dir = (s->last_pic && s->last_pic->f.data[0]) ? MV_DIR_FORWARD : MV_DIR_BACKWARD; - ff_update_block_index(s); - - if (IS_INTRA(s->current_picture.f.mb_type[mb_xy])) + if (IS_INTRA(s->cur_pic->f.mb_type[mb_xy])) continue; if (!(s->error_status_table[mb_xy] & ER_MV_ERROR)) continue; - s->mv_dir = s->last_picture.f.data[0] ? MV_DIR_FORWARD - : MV_DIR_BACKWARD; - s->mb_intra = 0; - s->mv_type = MV_TYPE_16X16; - s->mb_skipped = 0; - - s->dsp.clear_blocks(s->block[0]); - - s->mb_x = mb_x; - s->mb_y = mb_y; s->mv[0][0][0] = 0; s->mv[0][0][1] = 0; - decode_mb(s, 0); + s->decode_mb(s->opaque, 0, mv_dir, MV_TYPE_16X16, &s->mv, + mb_x, mb_y, 0, 0); } } return; @@ -461,9 +412,6 @@ static void guess_mv(MpegEncContext *s) changed = 0; for (mb_y = 0; mb_y < s->mb_height; mb_y++) { - s->mb_x = 0; - s->mb_y = mb_y; - ff_init_block_index(s); for (mb_x = 0; mb_x < s->mb_width; mb_x++) { const int mb_xy = mb_x + mb_y * s->mb_stride; int mv_predictor[8][2] = { { 0 } }; @@ -475,15 +423,13 @@ static void guess_mv(MpegEncContext *s) const int mot_index = (mb_x + mb_y * mot_stride) * mot_step; int prev_x, prev_y, prev_ref; - ff_update_block_index(s); - if ((mb_x ^ mb_y ^ pass) & 1) continue; if (fixed[mb_xy] == MV_FROZEN) continue; - assert(!IS_INTRA(s->current_picture.f.mb_type[mb_xy])); - assert(s->last_picture_ptr && s->last_picture_ptr->f.data[0]); + assert(!IS_INTRA(s->cur_pic->f.mb_type[mb_xy])); + assert(s->last_pic && s->last_pic->f.data[0]); j = 0; if (mb_x > 0 && fixed[mb_xy - 1] == MV_FROZEN) @@ -513,38 +459,38 @@ static void guess_mv(MpegEncContext *s) if (mb_x > 0 && fixed[mb_xy - 1]) { mv_predictor[pred_count][0] = - s->current_picture.f.motion_val[0][mot_index - mot_step][0]; + s->cur_pic->f.motion_val[0][mot_index - mot_step][0]; mv_predictor[pred_count][1] = - s->current_picture.f.motion_val[0][mot_index - mot_step][1]; + s->cur_pic->f.motion_val[0][mot_index - mot_step][1]; ref[pred_count] = - s->current_picture.f.ref_index[0][4 * (mb_xy - 1)]; + s->cur_pic->f.ref_index[0][4 * (mb_xy - 1)]; pred_count++; } if (mb_x + 1 < mb_width && fixed[mb_xy + 1]) { mv_predictor[pred_count][0] = - s->current_picture.f.motion_val[0][mot_index + mot_step][0]; + s->cur_pic->f.motion_val[0][mot_index + mot_step][0]; mv_predictor[pred_count][1] = - s->current_picture.f.motion_val[0][mot_index + mot_step][1]; + s->cur_pic->f.motion_val[0][mot_index + mot_step][1]; ref[pred_count] = - s->current_picture.f.ref_index[0][4 * (mb_xy + 1)]; + s->cur_pic->f.ref_index[0][4 * (mb_xy + 1)]; pred_count++; } if (mb_y > 0 && fixed[mb_xy - mb_stride]) { mv_predictor[pred_count][0] = - s->current_picture.f.motion_val[0][mot_index - mot_stride * mot_step][0]; + s->cur_pic->f.motion_val[0][mot_index - mot_stride * mot_step][0]; mv_predictor[pred_count][1] = - s->current_picture.f.motion_val[0][mot_index - mot_stride * mot_step][1]; + s->cur_pic->f.motion_val[0][mot_index - mot_stride * mot_step][1]; ref[pred_count] = - s->current_picture.f.ref_index[0][4 * (mb_xy - s->mb_stride)]; + s->cur_pic->f.ref_index[0][4 * (mb_xy - s->mb_stride)]; pred_count++; } if (mb_y + 1current_picture.f.motion_val[0][mot_index + mot_stride * mot_step][0]; + s->cur_pic->f.motion_val[0][mot_index + mot_stride * mot_step][0]; mv_predictor[pred_count][1] = - s->current_picture.f.motion_val[0][mot_index + mot_stride * mot_step][1]; + s->cur_pic->f.motion_val[0][mot_index + mot_stride * mot_step][1]; ref[pred_count] = - s->current_picture.f.ref_index[0][4 * (mb_xy + s->mb_stride)]; + s->cur_pic->f.ref_index[0][4 * (mb_xy + s->mb_stride)]; pred_count++; } if (pred_count == 0) @@ -602,19 +548,19 @@ skip_mean_and_median: if (s->avctx->codec_id == AV_CODEC_ID_H264) { // FIXME } else { - ff_thread_await_progress(&s->last_picture_ptr->f, + ff_thread_await_progress(&s->last_pic->f, mb_y, 0); } - if (!s->last_picture.f.motion_val[0] || - !s->last_picture.f.ref_index[0]) + if (!s->last_pic->f.motion_val[0] || + !s->last_pic->f.ref_index[0]) goto skip_last_mv; - prev_x = s->last_picture.f.motion_val[0][mot_index][0]; - prev_y = s->last_picture.f.motion_val[0][mot_index][1]; - prev_ref = s->last_picture.f.ref_index[0][4 * mb_xy]; + prev_x = s->last_pic->f.motion_val[0][mot_index][0]; + prev_y = s->last_pic->f.motion_val[0][mot_index][1]; + prev_ref = s->last_pic->f.ref_index[0][4 * mb_xy]; } else { - prev_x = s->current_picture.f.motion_val[0][mot_index][0]; - prev_y = s->current_picture.f.motion_val[0][mot_index][1]; - prev_ref = s->current_picture.f.ref_index[0][4 * mb_xy]; + prev_x = s->cur_pic->f.motion_val[0][mot_index][0]; + prev_y = s->cur_pic->f.motion_val[0][mot_index][1]; + prev_ref = s->cur_pic->f.ref_index[0][4 * mb_xy]; } /* last MV */ @@ -624,54 +570,47 @@ skip_mean_and_median: pred_count++; skip_last_mv: - s->mv_dir = MV_DIR_FORWARD; - s->mb_intra = 0; - s->mv_type = MV_TYPE_16X16; - s->mb_skipped = 0; - - s->dsp.clear_blocks(s->block[0]); - - s->mb_x = mb_x; - s->mb_y = mb_y; for (j = 0; j < pred_count; j++) { + int *linesize = s->cur_pic->f.linesize; int score = 0; - uint8_t *src = s->current_picture.f.data[0] + - mb_x * 16 + mb_y * 16 * s->linesize; + uint8_t *src = s->cur_pic->f.data[0] + + mb_x * 16 + mb_y * 16 * linesize[0]; - s->current_picture.f.motion_val[0][mot_index][0] = + s->cur_pic->f.motion_val[0][mot_index][0] = s->mv[0][0][0] = mv_predictor[j][0]; - s->current_picture.f.motion_val[0][mot_index][1] = + s->cur_pic->f.motion_val[0][mot_index][1] = s->mv[0][0][1] = mv_predictor[j][1]; // predictor intra or otherwise not available if (ref[j] < 0) continue; - decode_mb(s, ref[j]); + s->decode_mb(s->opaque, ref[j], MV_DIR_FORWARD, + MV_TYPE_16X16, &s->mv, mb_x, mb_y, 0, 0); if (mb_x > 0 && fixed[mb_xy - 1]) { int k; for (k = 0; k < 16; k++) - score += FFABS(src[k * s->linesize - 1] - - src[k * s->linesize]); + score += FFABS(src[k * linesize[0] - 1] - + src[k * linesize[0]]); } if (mb_x + 1 < mb_width && fixed[mb_xy + 1]) { int k; for (k = 0; k < 16; k++) - score += FFABS(src[k * s->linesize + 15] - - src[k * s->linesize + 16]); + score += FFABS(src[k * linesize[0] + 15] - + src[k * linesize[0] + 16]); } if (mb_y > 0 && fixed[mb_xy - mb_stride]) { int k; for (k = 0; k < 16; k++) - score += FFABS(src[k - s->linesize] - src[k]); + score += FFABS(src[k - linesize[0]] - src[k]); } if (mb_y + 1 < mb_height && fixed[mb_xy + mb_stride]) { int k; for (k = 0; k < 16; k++) - score += FFABS(src[k + s->linesize * 15] - - src[k + s->linesize * 16]); + score += FFABS(src[k + linesize[0] * 15] - + src[k + linesize[0] * 16]); } if (score <= best_score) { // <= will favor the last MV @@ -685,11 +624,12 @@ skip_last_mv: for (i = 0; i < mot_step; i++) for (j = 0; j < mot_step; j++) { - s->current_picture.f.motion_val[0][mot_index + i + j * mot_stride][0] = s->mv[0][0][0]; - s->current_picture.f.motion_val[0][mot_index + i + j * mot_stride][1] = s->mv[0][0][1]; + s->cur_pic->f.motion_val[0][mot_index + i + j * mot_stride][0] = s->mv[0][0][0]; + s->cur_pic->f.motion_val[0][mot_index + i + j * mot_stride][1] = s->mv[0][0][1]; } - decode_mb(s, ref[best_pred]); + s->decode_mb(s->opaque, ref[best_pred], MV_DIR_FORWARD, + MV_TYPE_16X16, &s->mv, mb_x, mb_y, 0, 0); if (s->mv[0][0][0] != prev_x || s->mv[0][0][1] != prev_y) { @@ -712,11 +652,11 @@ skip_last_mv: } } -static int is_intra_more_likely(MpegEncContext *s) +static int is_intra_more_likely(ERContext *s) { int is_intra_likely, i, j, undamaged_count, skip_amount, mb_x, mb_y; - if (!s->last_picture_ptr || !s->last_picture_ptr->f.data[0]) + if (!s->last_pic || !s->last_pic->f.data[0]) return 1; // no previous frame available -> use spatial prediction undamaged_count = 0; @@ -727,12 +667,8 @@ static int is_intra_more_likely(MpegEncContext *s) undamaged_count++; } - if (s->codec_id == AV_CODEC_ID_H264) { - H264Context *h = (void*) s; - if (h->list_count <= 0 || h->ref_count[0] <= 0 || - !h->ref_list[0][0].f.data[0]) - return 1; - } + if (s->avctx->codec_id == AV_CODEC_ID_H264 && s->ref_count <= 0) + return 1; if (undamaged_count < 5) return 0; // almost all MBs damaged -> use temporal prediction @@ -740,7 +676,7 @@ static int is_intra_more_likely(MpegEncContext *s) // prevent dsp.sad() check, that requires access to the image if (CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration && - s->pict_type == AV_PICTURE_TYPE_I) + s->cur_pic->f.pict_type == AV_PICTURE_TYPE_I) return 1; skip_amount = FFMAX(undamaged_count / 50, 1); // check only up to 50 MBs @@ -761,25 +697,25 @@ static int is_intra_more_likely(MpegEncContext *s) if ((j % skip_amount) != 0) continue; - if (s->pict_type == AV_PICTURE_TYPE_I) { - uint8_t *mb_ptr = s->current_picture.f.data[0] + - mb_x * 16 + mb_y * 16 * s->linesize; - uint8_t *last_mb_ptr = s->last_picture.f.data[0] + - mb_x * 16 + mb_y * 16 * s->linesize; + if (s->cur_pic->f.pict_type == AV_PICTURE_TYPE_I) { + int *linesize = s->cur_pic->f.linesize; + uint8_t *mb_ptr = s->cur_pic->f.data[0] + + mb_x * 16 + mb_y * 16 * linesize[0]; + uint8_t *last_mb_ptr = s->last_pic->f.data[0] + + mb_x * 16 + mb_y * 16 * linesize[0]; if (s->avctx->codec_id == AV_CODEC_ID_H264) { // FIXME } else { - ff_thread_await_progress(&s->last_picture_ptr->f, - mb_y, 0); + ff_thread_await_progress(&s->last_pic->f, mb_y, 0); } - is_intra_likely += s->dsp.sad[0](NULL, last_mb_ptr, mb_ptr, - s->linesize, 16); - is_intra_likely -= s->dsp.sad[0](NULL, last_mb_ptr, - last_mb_ptr + s->linesize * 16, - s->linesize, 16); + is_intra_likely += s->dsp->sad[0](NULL, last_mb_ptr, mb_ptr, + linesize[0], 16); + is_intra_likely -= s->dsp->sad[0](NULL, last_mb_ptr, + last_mb_ptr + linesize[0] * 16, + linesize[0], 16); } else { - if (IS_INTRA(s->current_picture.f.mb_type[mb_xy])) + if (IS_INTRA(s->cur_pic->f.mb_type[mb_xy])) is_intra_likely++; else is_intra_likely--; @@ -789,9 +725,9 @@ static int is_intra_more_likely(MpegEncContext *s) return is_intra_likely > 0; } -void ff_er_frame_start(MpegEncContext *s) +void ff_er_frame_start(ERContext *s) { - if (!s->err_recognition) + if (!s->avctx->err_recognition) return; memset(s->error_status_table, ER_MB_ERROR | VP_START | ER_MB_END, @@ -807,7 +743,7 @@ void ff_er_frame_start(MpegEncContext *s) * @param status the status at the end (ER_MV_END, ER_AC_ERROR, ...), it is * assumed that no earlier end or error of the same type occurred */ -void ff_er_add_slice(MpegEncContext *s, int startx, int starty, +void ff_er_add_slice(ERContext *s, int startx, int starty, int endx, int endy, int status) { const int start_i = av_clip(startx + starty * s->mb_width, 0, s->mb_num - 1); @@ -825,7 +761,7 @@ void ff_er_add_slice(MpegEncContext *s, int startx, int starty, return; } - if (!s->err_recognition) + if (!s->avctx->err_recognition) return; mask &= ~VP_START; @@ -875,37 +811,36 @@ void ff_er_add_slice(MpegEncContext *s, int startx, int starty, } } -void ff_er_frame_end(MpegEncContext *s) +void ff_er_frame_end(ERContext *s) { + int *linesize = s->cur_pic->f.linesize; int i, mb_x, mb_y, error, error_type, dc_error, mv_error, ac_error; int distance; int threshold_part[4] = { 100, 100, 100 }; int threshold = 50; int is_intra_likely; int size = s->b8_stride * 2 * s->mb_height; - Picture *pic = s->current_picture_ptr; /* We do not support ER of field pictures yet, * though it should not crash if enabled. */ - if (!s->err_recognition || s->error_count == 0 || + if (!s->avctx->err_recognition || s->error_count == 0 || s->avctx->hwaccel || s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU || - s->picture_structure != PICT_FRAME || + !s->cur_pic || s->cur_pic->field_picture || s->error_count == 3 * s->mb_width * (s->avctx->skip_top + s->avctx->skip_bottom)) { return; }; - if (s->current_picture.f.motion_val[0] == NULL) { + if (s->cur_pic->f.motion_val[0] == NULL) { av_log(s->avctx, AV_LOG_ERROR, "Warning MVs not available\n"); for (i = 0; i < 2; i++) { - pic->f.ref_index[i] = av_mallocz(s->mb_stride * s->mb_height * 4 * sizeof(uint8_t)); - pic->motion_val_base[i] = av_mallocz((size + 4) * 2 * sizeof(uint16_t)); - pic->f.motion_val[i] = pic->motion_val_base[i] + 4; + s->cur_pic->f.ref_index[i] = av_mallocz(s->mb_stride * s->mb_height * 4 * sizeof(uint8_t)); + s->cur_pic->motion_val_base[i] = av_mallocz((size + 4) * 2 * sizeof(uint16_t)); + s->cur_pic->f.motion_val[i] = s->cur_pic->motion_val_base[i] + 4; } - pic->f.motion_subsample_log2 = 3; - s->current_picture = *s->current_picture_ptr; + s->cur_pic->f.motion_subsample_log2 = 3; } if (s->avctx->debug & FF_DEBUG_ER) { @@ -964,7 +899,7 @@ void ff_er_frame_end(MpegEncContext *s) } /* handle missing slices */ - if (s->err_recognition & AV_EF_EXPLODE) { + if (s->avctx->err_recognition & AV_EF_EXPLODE) { int end_ok = 1; // FIXME + 100 hack @@ -1063,30 +998,28 @@ void ff_er_frame_end(MpegEncContext *s) continue; if (is_intra_likely) - s->current_picture.f.mb_type[mb_xy] = MB_TYPE_INTRA4x4; + s->cur_pic->f.mb_type[mb_xy] = MB_TYPE_INTRA4x4; else - s->current_picture.f.mb_type[mb_xy] = MB_TYPE_16x16 | MB_TYPE_L0; + s->cur_pic->f.mb_type[mb_xy] = MB_TYPE_16x16 | MB_TYPE_L0; } // change inter to intra blocks if no reference frames are available - if (!s->last_picture.f.data[0] && !s->next_picture.f.data[0]) + if (!(s->last_pic && s->last_pic->f.data[0]) && + !(s->next_pic && s->next_pic->f.data[0])) for (i = 0; i < s->mb_num; i++) { const int mb_xy = s->mb_index2xy[i]; - if (!IS_INTRA(s->current_picture.f.mb_type[mb_xy])) - s->current_picture.f.mb_type[mb_xy] = MB_TYPE_INTRA4x4; + if (!IS_INTRA(s->cur_pic->f.mb_type[mb_xy])) + s->cur_pic->f.mb_type[mb_xy] = MB_TYPE_INTRA4x4; } /* handle inter blocks with damaged AC */ for (mb_y = 0; mb_y < s->mb_height; mb_y++) { - s->mb_x = 0; - s->mb_y = mb_y; - ff_init_block_index(s); for (mb_x = 0; mb_x < s->mb_width; mb_x++) { const int mb_xy = mb_x + mb_y * s->mb_stride; - const int mb_type = s->current_picture.f.mb_type[mb_xy]; - int dir = !s->last_picture.f.data[0]; - - ff_update_block_index(s); + const int mb_type = s->cur_pic->f.mb_type[mb_xy]; + const int dir = !(s->last_pic && s->last_pic->f.data[0]); + const int mv_dir = dir ? MV_DIR_BACKWARD : MV_DIR_FORWARD; + int mv_type; error = s->error_status_table[mb_xy]; @@ -1097,43 +1030,33 @@ void ff_er_frame_end(MpegEncContext *s) if (!(error & ER_AC_ERROR)) continue; // undamaged inter - s->mv_dir = dir ? MV_DIR_BACKWARD : MV_DIR_FORWARD; - s->mb_intra = 0; - s->mb_skipped = 0; if (IS_8X8(mb_type)) { int mb_index = mb_x * 2 + mb_y * 2 * s->b8_stride; int j; - s->mv_type = MV_TYPE_8X8; + mv_type = MV_TYPE_8X8; for (j = 0; j < 4; j++) { - s->mv[0][j][0] = s->current_picture.f.motion_val[dir][mb_index + (j & 1) + (j >> 1) * s->b8_stride][0]; - s->mv[0][j][1] = s->current_picture.f.motion_val[dir][mb_index + (j & 1) + (j >> 1) * s->b8_stride][1]; + s->mv[0][j][0] = s->cur_pic->f.motion_val[dir][mb_index + (j & 1) + (j >> 1) * s->b8_stride][0]; + s->mv[0][j][1] = s->cur_pic->f.motion_val[dir][mb_index + (j & 1) + (j >> 1) * s->b8_stride][1]; } } else { - s->mv_type = MV_TYPE_16X16; - s->mv[0][0][0] = s->current_picture.f.motion_val[dir][mb_x * 2 + mb_y * 2 * s->b8_stride][0]; - s->mv[0][0][1] = s->current_picture.f.motion_val[dir][mb_x * 2 + mb_y * 2 * s->b8_stride][1]; + mv_type = MV_TYPE_16X16; + s->mv[0][0][0] = s->cur_pic->f.motion_val[dir][mb_x * 2 + mb_y * 2 * s->b8_stride][0]; + s->mv[0][0][1] = s->cur_pic->f.motion_val[dir][mb_x * 2 + mb_y * 2 * s->b8_stride][1]; } - s->dsp.clear_blocks(s->block[0]); - - s->mb_x = mb_x; - s->mb_y = mb_y; - decode_mb(s, 0 /* FIXME h264 partitioned slices need this set */); + s->decode_mb(s->opaque, 0 /* FIXME h264 partitioned slices need this set */, + mv_dir, mv_type, &s->mv, mb_x, mb_y, 0, 0); } } /* guess MVs */ - if (s->pict_type == AV_PICTURE_TYPE_B) { + if (s->cur_pic->f.pict_type == AV_PICTURE_TYPE_B) { for (mb_y = 0; mb_y < s->mb_height; mb_y++) { - s->mb_x = 0; - s->mb_y = mb_y; - ff_init_block_index(s); for (mb_x = 0; mb_x < s->mb_width; mb_x++) { int xy = mb_x * 2 + mb_y * 2 * s->b8_stride; const int mb_xy = mb_x + mb_y * s->mb_stride; - const int mb_type = s->current_picture.f.mb_type[mb_xy]; - - ff_update_block_index(s); + const int mb_type = s->cur_pic->f.mb_type[mb_xy]; + int mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD; error = s->error_status_table[mb_xy]; @@ -1144,24 +1067,21 @@ void ff_er_frame_end(MpegEncContext *s) if (!(error & ER_AC_ERROR)) continue; // undamaged inter - s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD; - if (!s->last_picture.f.data[0]) - s->mv_dir &= ~MV_DIR_FORWARD; - if (!s->next_picture.f.data[0]) - s->mv_dir &= ~MV_DIR_BACKWARD; - s->mb_intra = 0; - s->mv_type = MV_TYPE_16X16; - s->mb_skipped = 0; + if (!(s->last_pic && s->last_pic->f.data[0])) + mv_dir &= ~MV_DIR_FORWARD; + if (!(s->next_pic && s->next_pic->f.data[0])) + mv_dir &= ~MV_DIR_BACKWARD; if (s->pp_time) { int time_pp = s->pp_time; int time_pb = s->pb_time; - ff_thread_await_progress(&s->next_picture_ptr->f, mb_y, 0); - s->mv[0][0][0] = s->next_picture.f.motion_val[0][xy][0] * time_pb / time_pp; - s->mv[0][0][1] = s->next_picture.f.motion_val[0][xy][1] * time_pb / time_pp; - s->mv[1][0][0] = s->next_picture.f.motion_val[0][xy][0] * (time_pb - time_pp) / time_pp; - s->mv[1][0][1] = s->next_picture.f.motion_val[0][xy][1] * (time_pb - time_pp) / time_pp; + ff_thread_await_progress(&s->next_pic->f, mb_y, 0); + + s->mv[0][0][0] = s->next_pic->f.motion_val[0][xy][0] * time_pb / time_pp; + s->mv[0][0][1] = s->next_pic->f.motion_val[0][xy][1] * time_pb / time_pp; + s->mv[1][0][0] = s->next_pic->f.motion_val[0][xy][0] * (time_pb - time_pp) / time_pp; + s->mv[1][0][1] = s->next_pic->f.motion_val[0][xy][1] * (time_pb - time_pp) / time_pp; } else { s->mv[0][0][0] = 0; s->mv[0][0][1] = 0; @@ -1169,10 +1089,8 @@ void ff_er_frame_end(MpegEncContext *s) s->mv[1][0][1] = 0; } - s->dsp.clear_blocks(s->block[0]); - s->mb_x = mb_x; - s->mb_y = mb_y; - decode_mb(s, 0); + s->decode_mb(s->opaque, 0, mv_dir, MV_TYPE_16X16, &s->mv, + mb_x, mb_y, 0, 0); } } } else @@ -1188,7 +1106,7 @@ void ff_er_frame_end(MpegEncContext *s) int16_t *dc_ptr; uint8_t *dest_y, *dest_cb, *dest_cr; const int mb_xy = mb_x + mb_y * s->mb_stride; - const int mb_type = s->current_picture.f.mb_type[mb_xy]; + const int mb_type = s->cur_pic->f.mb_type[mb_xy]; error = s->error_status_table[mb_xy]; @@ -1197,9 +1115,9 @@ void ff_er_frame_end(MpegEncContext *s) // if (error & ER_MV_ERROR) // continue; // inter data damaged FIXME is this good? - dest_y = s->current_picture.f.data[0] + mb_x * 16 + mb_y * 16 * s->linesize; - dest_cb = s->current_picture.f.data[1] + mb_x * 8 + mb_y * 8 * s->uvlinesize; - dest_cr = s->current_picture.f.data[2] + mb_x * 8 + mb_y * 8 * s->uvlinesize; + dest_y = s->cur_pic->f.data[0] + mb_x * 16 + mb_y * 16 * linesize[0]; + dest_cb = s->cur_pic->f.data[1] + mb_x * 8 + mb_y * 8 * linesize[1]; + dest_cr = s->cur_pic->f.data[2] + mb_x * 8 + mb_y * 8 * linesize[2]; dc_ptr = &s->dc_val[0][mb_x * 2 + mb_y * 2 * s->b8_stride]; for (n = 0; n < 4; n++) { @@ -1208,7 +1126,7 @@ void ff_er_frame_end(MpegEncContext *s) int x; for (x = 0; x < 8; x++) dc += dest_y[x + (n & 1) * 8 + - (y + (n >> 1) * 8) * s->linesize]; + (y + (n >> 1) * 8) * linesize[0]]; } dc_ptr[(n & 1) + (n >> 1) * s->b8_stride] = (dc + 4) >> 3; } @@ -1217,8 +1135,8 @@ void ff_er_frame_end(MpegEncContext *s) for (y = 0; y < 8; y++) { int x; for (x = 0; x < 8; x++) { - dcu += dest_cb[x + y * s->uvlinesize]; - dcv += dest_cr[x + y * s->uvlinesize]; + dcu += dest_cb[x + y * linesize[1]]; + dcv += dest_cr[x + y * linesize[2]]; } } s->dc_val[1][mb_x + mb_y * s->mb_stride] = (dcu + 4) >> 3; @@ -1239,7 +1157,7 @@ void ff_er_frame_end(MpegEncContext *s) for (mb_x = 0; mb_x < s->mb_width; mb_x++) { uint8_t *dest_y, *dest_cb, *dest_cr; const int mb_xy = mb_x + mb_y * s->mb_stride; - const int mb_type = s->current_picture.f.mb_type[mb_xy]; + const int mb_type = s->cur_pic->f.mb_type[mb_xy]; error = s->error_status_table[mb_xy]; @@ -1248,9 +1166,9 @@ void ff_er_frame_end(MpegEncContext *s) if (!(error & ER_AC_ERROR)) continue; // undamaged - dest_y = s->current_picture.f.data[0] + mb_x * 16 + mb_y * 16 * s->linesize; - dest_cb = s->current_picture.f.data[1] + mb_x * 8 + mb_y * 8 * s->uvlinesize; - dest_cr = s->current_picture.f.data[2] + mb_x * 8 + mb_y * 8 * s->uvlinesize; + dest_y = s->cur_pic->f.data[0] + mb_x * 16 + mb_y * 16 * linesize[0]; + dest_cb = s->cur_pic->f.data[1] + mb_x * 8 + mb_y * 8 * linesize[1]; + dest_cr = s->cur_pic->f.data[2] + mb_x * 8 + mb_y * 8 * linesize[2]; put_dc(s, dest_y, dest_cb, dest_cr, mb_x, mb_y); } @@ -1258,20 +1176,20 @@ void ff_er_frame_end(MpegEncContext *s) if (s->avctx->error_concealment & FF_EC_DEBLOCK) { /* filter horizontal block boundaries */ - h_block_filter(s, s->current_picture.f.data[0], s->mb_width * 2, - s->mb_height * 2, s->linesize, 1); - h_block_filter(s, s->current_picture.f.data[1], s->mb_width, - s->mb_height , s->uvlinesize, 0); - h_block_filter(s, s->current_picture.f.data[2], s->mb_width, - s->mb_height , s->uvlinesize, 0); + h_block_filter(s, s->cur_pic->f.data[0], s->mb_width * 2, + s->mb_height * 2, linesize[0], 1); + h_block_filter(s, s->cur_pic->f.data[1], s->mb_width, + s->mb_height, linesize[1], 0); + h_block_filter(s, s->cur_pic->f.data[2], s->mb_width, + s->mb_height, linesize[2], 0); /* filter vertical block boundaries */ - v_block_filter(s, s->current_picture.f.data[0], s->mb_width * 2, - s->mb_height * 2, s->linesize, 1); - v_block_filter(s, s->current_picture.f.data[1], s->mb_width, - s->mb_height , s->uvlinesize, 0); - v_block_filter(s, s->current_picture.f.data[2], s->mb_width, - s->mb_height , s->uvlinesize, 0); + v_block_filter(s, s->cur_pic->f.data[0], s->mb_width * 2, + s->mb_height * 2, linesize[0], 1); + v_block_filter(s, s->cur_pic->f.data[1], s->mb_width, + s->mb_height, linesize[1], 0); + v_block_filter(s, s->cur_pic->f.data[2], s->mb_width, + s->mb_height, linesize[2], 0); } ec_clean: @@ -1280,10 +1198,13 @@ ec_clean: const int mb_xy = s->mb_index2xy[i]; int error = s->error_status_table[mb_xy]; - if (s->pict_type != AV_PICTURE_TYPE_B && + if (s->cur_pic->f.pict_type != AV_PICTURE_TYPE_B && (error & (ER_DC_ERROR | ER_MV_ERROR | ER_AC_ERROR))) { s->mbskip_table[mb_xy] = 0; } s->mbintra_table[mb_xy] = 1; } + s->cur_pic = NULL; + s->next_pic = NULL; + s->last_pic = NULL; } diff --git a/libavcodec/error_resilience.h b/libavcodec/error_resilience.h new file mode 100644 index 0000000000..949c58f245 --- /dev/null +++ b/libavcodec/error_resilience.h @@ -0,0 +1,74 @@ +/* + * + * This file is part of Libav. + * + * Libav is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * Libav is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with Libav; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef AVCODEC_ERROR_RESILIENCE_H +#define AVCODEC_ERROR_RESILIENCE_H + +///< current MB is the first after a resync marker +#define VP_START 1 +#define ER_AC_ERROR 2 +#define ER_DC_ERROR 4 +#define ER_MV_ERROR 8 +#define ER_AC_END 16 +#define ER_DC_END 32 +#define ER_MV_END 64 + +#define ER_MB_ERROR (ER_AC_ERROR|ER_DC_ERROR|ER_MV_ERROR) +#define ER_MB_END (ER_AC_END|ER_DC_END|ER_MV_END) + +typedef struct ERContext { + AVCodecContext *avctx; + DSPContext *dsp; + + int *mb_index2xy; + int mb_num; + int mb_width, mb_height; + int mb_stride; + int b8_stride; + + int error_count, error_occurred; + uint8_t *error_status_table; + uint8_t *er_temp_buffer; + int16_t *dc_val[3]; + uint8_t *mbskip_table; + uint8_t *mbintra_table; + int mv[2][4][2]; + + struct Picture *cur_pic; + struct Picture *last_pic; + struct Picture *next_pic; + + uint16_t pp_time; + uint16_t pb_time; + int quarter_sample; + int partitioned_frame; + int ref_count; + + void (*decode_mb)(void *opaque, int ref, int mv_dir, int mv_type, + int (*mv)[2][4][2], + int mb_x, int mb_y, int mb_intra, int mb_skipped); + void *opaque; +} ERContext; + +void ff_er_frame_start(ERContext *s); +void ff_er_frame_end(ERContext *s); +void ff_er_add_slice(ERContext *s, int startx, int starty, int endx, int endy, + int status); + +#endif /* AVCODEC_ERROR_RESILIENCE_H */ diff --git a/libavcodec/h261dec.c b/libavcodec/h261dec.c index 500f7953aa..9935897266 100644 --- a/libavcodec/h261dec.c +++ b/libavcodec/h261dec.c @@ -609,7 +609,7 @@ retry: if(ff_MPV_frame_start(s, avctx) < 0) return -1; - ff_er_frame_start(s); + ff_mpeg_er_frame_start(s); /* decode each macroblock */ s->mb_x=0; diff --git a/libavcodec/h263dec.c b/libavcodec/h263dec.c index 0eaf4d7f61..b1a32b2f37 100644 --- a/libavcodec/h263dec.c +++ b/libavcodec/h263dec.c @@ -188,7 +188,7 @@ static int decode_slice(MpegEncContext *s){ /* per-row end of slice checks */ if(s->msmpeg4_version){ if(s->resync_mb_y + s->slice_height == s->mb_y){ - ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, ER_MB_END); + ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, ER_MB_END); return 0; } @@ -229,7 +229,7 @@ static int decode_slice(MpegEncContext *s){ if(s->loop_filter) ff_h263_loop_filter(s); - ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, ER_MB_END&part_mask); + ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, ER_MB_END&part_mask); s->padding_bug_score--; @@ -242,11 +242,11 @@ static int decode_slice(MpegEncContext *s){ return 0; }else if(ret==SLICE_NOEND){ av_log(s->avctx, AV_LOG_ERROR, "Slice mismatch at MB: %d\n", xy); - ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x+1, s->mb_y, ER_MB_END&part_mask); + ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y, s->mb_x+1, s->mb_y, ER_MB_END&part_mask); return -1; } av_log(s->avctx, AV_LOG_ERROR, "Error at MB: %d\n", xy); - ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR&part_mask); + ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR&part_mask); return -1; } @@ -325,7 +325,7 @@ static int decode_slice(MpegEncContext *s){ else if(left<0){ av_log(s->avctx, AV_LOG_ERROR, "overreading %d bits\n", -left); }else - ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, ER_MB_END); + ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, ER_MB_END); return 0; } @@ -334,7 +334,7 @@ static int decode_slice(MpegEncContext *s){ get_bits_left(&s->gb), show_bits(&s->gb, 24), s->padding_bug_score); - ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, ER_MB_END&part_mask); + ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, ER_MB_END&part_mask); return -1; } @@ -638,7 +638,7 @@ retry: return -1; } - ff_er_frame_start(s); + ff_mpeg_er_frame_start(s); //the second part of the wmv2 header contains the MB skip bits which are stored in current_picture->mb_type //which is not available before ff_MPV_frame_start() @@ -662,7 +662,7 @@ retry: if(ff_h263_resync(s)<0) break; if (prev_y * s->mb_width + prev_x < s->mb_y * s->mb_width + s->mb_x) - s->error_occurred = 1; + s->er.error_occurred = 1; } if(s->msmpeg4_version<4 && s->h263_pred) @@ -673,7 +673,7 @@ retry: if (s->msmpeg4_version && s->msmpeg4_version<4 && s->pict_type==AV_PICTURE_TYPE_I) if(!CONFIG_MSMPEG4_DECODER || ff_msmpeg4_decode_ext_header(s, buf_size) < 0){ - s->error_status_table[s->mb_num-1]= ER_MB_ERROR; + s->er.error_status_table[s->mb_num - 1] = ER_MB_ERROR; } assert(s->bitstream_buffer_size==0); @@ -710,7 +710,7 @@ frame_end: } intrax8_decoded: - ff_er_frame_end(s); + ff_er_frame_end(&s->er); if (avctx->hwaccel) { if (avctx->hwaccel->end_frame(avctx) < 0) diff --git a/libavcodec/h264.c b/libavcodec/h264.c index 7a2fd69126..4410f59cb0 100644 --- a/libavcodec/h264.c +++ b/libavcodec/h264.c @@ -78,6 +78,33 @@ static const enum AVPixelFormat hwaccel_pixfmt_list_h264_jpeg_420[] = { AV_PIX_FMT_NONE }; +static void h264_er_decode_mb(void *opaque, int ref, int mv_dir, int mv_type, + int (*mv)[2][4][2], + int mb_x, int mb_y, int mb_intra, int mb_skipped) +{ + H264Context *h = opaque; + MpegEncContext *s = &h->s; + + s->mb_x = mb_x; + s->mb_y = mb_y; + h->mb_xy = s->mb_x + s->mb_y * s->mb_stride; + memset(h->non_zero_count_cache, 0, sizeof(h->non_zero_count_cache)); + assert(ref >= 0); + /* FIXME: It is possible albeit uncommon that slice references + * differ between slices. We take the easy approach and ignore + * it for now. If this turns out to have any relevance in + * practice then correct remapping should be added. */ + if (ref >= h->ref_count[0]) + ref = 0; + fill_rectangle(&s->current_picture.f.ref_index[0][4 * h->mb_xy], + 2, 2, 2, ref, 1); + fill_rectangle(&h->ref_cache[0][scan8[0]], 4, 4, 8, ref, 1); + fill_rectangle(h->mv_cache[0][scan8[0]], 4, 4, 8, + pack16to32(s->mv[0][0][0], s->mv[0][0][1]), 4); + assert(!FRAME_MBAFF); + ff_h264_hl_decode_mb(h); +} + /** * Check if the top & left blocks are available if needed and * change the dc mode so it only uses the available blocks. @@ -960,6 +987,9 @@ static int context_init(H264Context *h) h->ref_cache[1][scan8[7] + 1] = h->ref_cache[1][scan8[13] + 1] = PART_NOT_AVAILABLE; + h->s.er.decode_mb = h264_er_decode_mb; + h->s.er.opaque = h; + return 0; fail: @@ -1299,7 +1329,7 @@ int ff_h264_frame_start(H264Context *h) if (ff_MPV_frame_start(s, s->avctx) < 0) return -1; - ff_er_frame_start(s); + ff_mpeg_er_frame_start(s); /* * ff_MPV_frame_start uses pict_type to derive key_frame. * This is incorrect for H.264; IDR markings must be used. @@ -2340,7 +2370,7 @@ static int field_end(H264Context *h, int in_setup) * causes problems for the first MB line, too. */ if (!FIELD_PICTURE) - ff_er_frame_end(s); + ff_er_frame_end(&s->er); ff_MPV_frame_end(s); @@ -3068,11 +3098,13 @@ static int decode_slice_header(H264Context *h, H264Context *h0) if (h->slice_type_nos != AV_PICTURE_TYPE_I) { s->last_picture_ptr = &h->ref_list[0][0]; s->last_picture_ptr->owner2 = s; + s->er.last_pic = s->last_picture_ptr; ff_copy_picture(&s->last_picture, s->last_picture_ptr); } if (h->slice_type_nos == AV_PICTURE_TYPE_B) { s->next_picture_ptr = &h->ref_list[1][0]; s->next_picture_ptr->owner2 = s; + s->er.next_pic = s->next_picture_ptr; ff_copy_picture(&s->next_picture, s->next_picture_ptr); } @@ -3639,6 +3671,15 @@ static void decode_finish_row(H264Context *h) s->picture_structure == PICT_BOTTOM_FIELD); } +static void er_add_slice(H264Context *h, int startx, int starty, + int endx, int endy, int status) +{ + ERContext *er = &h->s.er; + + er->ref_count = h->ref_count[0]; + ff_er_add_slice(er, startx, starty, endx, endy, status); +} + static int decode_slice(struct AVCodecContext *avctx, void *arg) { H264Context *h = *(void **)arg; @@ -3686,7 +3727,7 @@ static int decode_slice(struct AVCodecContext *avctx, void *arg) if ((s->workaround_bugs & FF_BUG_TRUNCATED) && h->cabac.bytestream > h->cabac.bytestream_end + 2) { - ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x - 1, + er_add_slice(h, s->resync_mb_x, s->resync_mb_y, s->mb_x - 1, s->mb_y, ER_MB_END); if (s->mb_x >= lf_x_start) loop_filter(h, lf_x_start, s->mb_x + 1); @@ -3697,7 +3738,7 @@ static int decode_slice(struct AVCodecContext *avctx, void *arg) "error while decoding MB %d %d, bytestream (%td)\n", s->mb_x, s->mb_y, h->cabac.bytestream_end - h->cabac.bytestream); - ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, + er_add_slice(h, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR); return -1; } @@ -3717,7 +3758,7 @@ static int decode_slice(struct AVCodecContext *avctx, void *arg) if (eos || s->mb_y >= s->mb_height) { tprintf(s->avctx, "slice end %d %d\n", get_bits_count(&s->gb), s->gb.size_in_bits); - ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x - 1, + er_add_slice(h, s->resync_mb_x, s->resync_mb_y, s->mb_x - 1, s->mb_y, ER_MB_END); if (s->mb_x > lf_x_start) loop_filter(h, lf_x_start, s->mb_x); @@ -3744,7 +3785,7 @@ static int decode_slice(struct AVCodecContext *avctx, void *arg) if (ret < 0) { av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding MB %d %d\n", s->mb_x, s->mb_y); - ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, + er_add_slice(h, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR); return -1; } @@ -3764,13 +3805,13 @@ static int decode_slice(struct AVCodecContext *avctx, void *arg) get_bits_count(&s->gb), s->gb.size_in_bits); if (get_bits_left(&s->gb) == 0) { - ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, + er_add_slice(h, s->resync_mb_x, s->resync_mb_y, s->mb_x - 1, s->mb_y, ER_MB_END); return 0; } else { - ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, + er_add_slice(h, s->resync_mb_x, s->resync_mb_y, s->mb_x - 1, s->mb_y, ER_MB_END); @@ -3783,7 +3824,7 @@ static int decode_slice(struct AVCodecContext *avctx, void *arg) tprintf(s->avctx, "slice end %d %d\n", get_bits_count(&s->gb), s->gb.size_in_bits); if (get_bits_left(&s->gb) == 0) { - ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, + er_add_slice(h, s->resync_mb_x, s->resync_mb_y, s->mb_x - 1, s->mb_y, ER_MB_END); if (s->mb_x > lf_x_start) @@ -3791,7 +3832,7 @@ static int decode_slice(struct AVCodecContext *avctx, void *arg) return 0; } else { - ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, + er_add_slice(h, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR); return -1; @@ -3823,7 +3864,7 @@ static int execute_decode_slices(H264Context *h, int context_count) for (i = 1; i < context_count; i++) { hx = h->thread_context[i]; hx->s.err_recognition = avctx->err_recognition; - hx->s.error_count = 0; + hx->s.er.error_count = 0; } avctx->execute(avctx, decode_slice, h->thread_context, @@ -3836,7 +3877,7 @@ static int execute_decode_slices(H264Context *h, int context_count) s->droppable = hx->s.droppable; s->picture_structure = hx->s.picture_structure; for (i = 1; i < context_count; i++) - h->s.error_count += h->thread_context[i]->s.error_count; + h->s.er.error_count += h->thread_context[i]->s.er.error_count; } return 0; diff --git a/libavcodec/intrax8.c b/libavcodec/intrax8.c index fad7ffec05..d2457f8ba4 100644 --- a/libavcodec/intrax8.c +++ b/libavcodec/intrax8.c @@ -784,7 +784,7 @@ int ff_intrax8_decode_picture(IntraX8Context * const w, int dquant, int quant_of } error: - ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, + ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y, (s->mb_x>>1)-1, (s->mb_y>>1)-1, ER_MB_END ); return 0; diff --git a/libavcodec/mpeg12.c b/libavcodec/mpeg12.c index 1b9a48b3b1..5a53383450 100644 --- a/libavcodec/mpeg12.c +++ b/libavcodec/mpeg12.c @@ -1565,7 +1565,7 @@ static int mpeg_field_start(MpegEncContext *s, const uint8_t *buf, int buf_size) if (ff_MPV_frame_start(s, avctx) < 0) return -1; - ff_er_frame_start(s); + ff_mpeg_er_frame_start(s); /* first check if we must repeat the frame */ s->current_picture_ptr->f.repeat_pict = 0; @@ -1856,7 +1856,7 @@ static int slice_decode_thread(AVCodecContext *c, void *arg) int mb_y = s->start_mb_y; const int field_pic = s->picture_structure != PICT_FRAME; - s->error_count = (3 * (s->end_mb_y - s->start_mb_y) * s->mb_width) >> field_pic; + s->er.error_count = (3 * (s->end_mb_y - s->start_mb_y) * s->mb_width) >> field_pic; for (;;) { uint32_t start_code; @@ -1866,14 +1866,14 @@ static int slice_decode_thread(AVCodecContext *c, void *arg) emms_c(); av_dlog(c, "ret:%d resync:%d/%d mb:%d/%d ts:%d/%d ec:%d\n", ret, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, - s->start_mb_y, s->end_mb_y, s->error_count); + s->start_mb_y, s->end_mb_y, s->er.error_count); if (ret < 0) { if (c->err_recognition & AV_EF_EXPLODE) return ret; if (s->resync_mb_x >= 0 && s->resync_mb_y >= 0) - ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, ER_AC_ERROR | ER_DC_ERROR | ER_MV_ERROR); + ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, ER_AC_ERROR | ER_DC_ERROR | ER_MV_ERROR); } else { - ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, ER_AC_END | ER_DC_END | ER_MV_END); + ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, ER_AC_END | ER_DC_END | ER_MV_END); } if (s->mb_y == s->end_mb_y) @@ -1915,7 +1915,7 @@ static int slice_end(AVCodecContext *avctx, AVFrame *pict) s->current_picture_ptr->f.qscale_type = FF_QSCALE_TYPE_MPEG2; - ff_er_frame_end(s); + ff_er_frame_end(&s->er); ff_MPV_frame_end(s); @@ -2210,7 +2210,7 @@ static int decode_chunks(AVCodecContext *avctx, avctx->execute(avctx, slice_decode_thread, &s2->thread_context[0], NULL, s->slice_count, sizeof(void*)); for (i = 0; i < s->slice_count; i++) - s2->error_count += s2->thread_context[i]->error_count; + s2->er.error_count += s2->thread_context[i]->er.error_count; } if (CONFIG_MPEG_VDPAU_DECODER && avctx->codec->capabilities & CODEC_CAP_HWACCEL_VDPAU) @@ -2252,7 +2252,7 @@ static int decode_chunks(AVCodecContext *avctx, s2->thread_context, NULL, s->slice_count, sizeof(void*)); for (i = 0; i < s->slice_count; i++) - s2->error_count += s2->thread_context[i]->error_count; + s2->er.error_count += s2->thread_context[i]->er.error_count; s->slice_count = 0; } if (last_code == 0 || last_code == SLICE_MIN_START_CODE) { @@ -2411,9 +2411,9 @@ static int decode_chunks(AVCodecContext *avctx, if (avctx->err_recognition & AV_EF_EXPLODE) return ret; if (s2->resync_mb_x >= 0 && s2->resync_mb_y >= 0) - ff_er_add_slice(s2, s2->resync_mb_x, s2->resync_mb_y, s2->mb_x, s2->mb_y, ER_AC_ERROR | ER_DC_ERROR | ER_MV_ERROR); + ff_er_add_slice(&s2->er, s2->resync_mb_x, s2->resync_mb_y, s2->mb_x, s2->mb_y, ER_AC_ERROR | ER_DC_ERROR | ER_MV_ERROR); } else { - ff_er_add_slice(s2, s2->resync_mb_x, s2->resync_mb_y, s2->mb_x-1, s2->mb_y, ER_AC_END | ER_DC_END | ER_MV_END); + ff_er_add_slice(&s2->er, s2->resync_mb_x, s2->resync_mb_y, s2->mb_x-1, s2->mb_y, ER_AC_END | ER_DC_END | ER_MV_END); } } } diff --git a/libavcodec/mpeg4videodec.c b/libavcodec/mpeg4videodec.c index cab58823c8..ebc74a74b6 100644 --- a/libavcodec/mpeg4videodec.c +++ b/libavcodec/mpeg4videodec.c @@ -796,13 +796,13 @@ int ff_mpeg4_decode_partitions(MpegEncContext *s) mb_num= mpeg4_decode_partition_a(s); if(mb_num<0){ - ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error); + ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error); return -1; } if(s->resync_mb_x + s->resync_mb_y*s->mb_width + mb_num > s->mb_num){ av_log(s->avctx, AV_LOG_ERROR, "slice below monitor ...\n"); - ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error); + ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error); return -1; } @@ -823,15 +823,15 @@ int ff_mpeg4_decode_partitions(MpegEncContext *s) return -1; } } - ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, part_a_end); + ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, part_a_end); if( mpeg4_decode_partition_b(s, mb_num) < 0){ if(s->pict_type==AV_PICTURE_TYPE_P) - ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, ER_DC_ERROR); + ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, ER_DC_ERROR); return -1; }else{ if(s->pict_type==AV_PICTURE_TYPE_P) - ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, ER_DC_END); + ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, ER_DC_END); } return 0; diff --git a/libavcodec/mpegvideo.c b/libavcodec/mpegvideo.c index 4b68fd56a0..4396ec2df9 100644 --- a/libavcodec/mpegvideo.c +++ b/libavcodec/mpegvideo.c @@ -147,6 +147,33 @@ const enum AVPixelFormat ff_hwaccel_pixfmt_list_420[] = { AV_PIX_FMT_NONE }; +static void mpeg_er_decode_mb(void *opaque, int ref, int mv_dir, int mv_type, + int (*mv)[2][4][2], + int mb_x, int mb_y, int mb_intra, int mb_skipped) +{ + MpegEncContext *s = opaque; + + s->mv_dir = mv_dir; + s->mv_type = mv_type; + s->mb_intra = mb_intra; + s->mb_skipped = mb_skipped; + s->mb_x = mb_x; + s->mb_y = mb_y; + memcpy(s->mv, mv, sizeof(*mv)); + + ff_init_block_index(s); + ff_update_block_index(s); + + s->dsp.clear_blocks(s->block[0]); + + s->dest[0] = s->current_picture.f.data[0] + (s->mb_y * 16 * s->linesize) + s->mb_x * 16; + s->dest[1] = s->current_picture.f.data[1] + (s->mb_y * (16 >> s->chroma_y_shift) * s->uvlinesize) + s->mb_x * (16 >> s->chroma_x_shift); + s->dest[2] = s->current_picture.f.data[2] + (s->mb_y * (16 >> s->chroma_y_shift) * s->uvlinesize) + s->mb_x * (16 >> s->chroma_x_shift); + + assert(ref == 0); + ff_MPV_decode_mb(s, s->block); +} + const uint8_t *avpriv_mpv_find_start_code(const uint8_t *restrict p, const uint8_t *end, uint32_t * restrict state) @@ -723,6 +750,43 @@ void ff_MPV_decode_defaults(MpegEncContext *s) ff_MPV_common_defaults(s); } +static int init_er(MpegEncContext *s) +{ + ERContext *er = &s->er; + int mb_array_size = s->mb_height * s->mb_stride; + int i; + + er->avctx = s->avctx; + er->dsp = &s->dsp; + + er->mb_index2xy = s->mb_index2xy; + er->mb_num = s->mb_num; + er->mb_width = s->mb_width; + er->mb_height = s->mb_height; + er->mb_stride = s->mb_stride; + er->b8_stride = s->b8_stride; + + er->er_temp_buffer = av_malloc(s->mb_height * s->mb_stride); + er->error_status_table = av_mallocz(mb_array_size); + if (!er->er_temp_buffer || !er->error_status_table) + goto fail; + + er->mbskip_table = s->mbskip_table; + er->mbintra_table = s->mbintra_table; + + for (i = 0; i < FF_ARRAY_ELEMS(s->dc_val); i++) + er->dc_val[i] = s->dc_val[i]; + + er->decode_mb = mpeg_er_decode_mb; + er->opaque = s; + + return 0; +fail: + av_freep(&er->er_temp_buffer); + av_freep(&er->error_status_table); + return AVERROR(ENOMEM); +} + /** * Initialize and allocates MpegEncContext fields dependent on the resolution. */ @@ -801,11 +865,6 @@ static int init_context_frame(MpegEncContext *s) } - FF_ALLOC_OR_GOTO(s->avctx, s->er_temp_buffer, - mb_array_size * sizeof(uint8_t), fail); - FF_ALLOCZ_OR_GOTO(s->avctx, s->error_status_table, - mb_array_size * sizeof(uint8_t), fail); - if (s->codec_id == AV_CODEC_ID_MPEG4 || (s->flags & CODEC_FLAG_INTERLACED_ME)) { /* interlaced direct mode decoding tables */ @@ -873,7 +932,7 @@ static int init_context_frame(MpegEncContext *s) 2 * EDGE_WIDTH) * s->mb_height * 16 + 2 * EDGE_WIDTH); } - return 0; + return init_er(s); fail: return AVERROR(ENOMEM); } @@ -1054,8 +1113,8 @@ static int free_context_frame(MpegEncContext *s) av_freep(&s->mbskip_table); - av_freep(&s->error_status_table); - av_freep(&s->er_temp_buffer); + av_freep(&s->er.error_status_table); + av_freep(&s->er.er_temp_buffer); av_freep(&s->mb_index2xy); av_freep(&s->lambda_table); av_freep(&s->cplx_tab); @@ -1589,7 +1648,7 @@ void ff_MPV_frame_end(MpegEncContext *s) // just to make sure that all data is rendered. if (CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration) { ff_xvmc_field_end(s); - } else if ((s->error_count || s->encoding) && + } else if ((s->er.error_count || s->encoding) && !s->avctx->hwaccel && !(s->avctx->codec->capabilities & CODEC_CAP_HWACCEL_VDPAU) && s->unrestricted_mv && @@ -2792,6 +2851,22 @@ void ff_set_qscale(MpegEncContext * s, int qscale) void ff_MPV_report_decode_progress(MpegEncContext *s) { - if (s->pict_type != AV_PICTURE_TYPE_B && !s->partitioned_frame && !s->error_occurred) + if (s->pict_type != AV_PICTURE_TYPE_B && !s->partitioned_frame && !s->er.error_occurred) ff_thread_report_progress(&s->current_picture_ptr->f, s->mb_y, 0); } + +void ff_mpeg_er_frame_start(MpegEncContext *s) +{ + ERContext *er = &s->er; + + er->cur_pic = s->current_picture_ptr; + er->last_pic = s->last_picture_ptr; + er->next_pic = s->next_picture_ptr; + + er->pp_time = s->pp_time; + er->pb_time = s->pb_time; + er->quarter_sample = s->quarter_sample; + er->partitioned_frame = s->partitioned_frame; + + ff_er_frame_start(er); +} diff --git a/libavcodec/mpegvideo.h b/libavcodec/mpegvideo.h index f3f982742b..87e9d1b246 100644 --- a/libavcodec/mpegvideo.h +++ b/libavcodec/mpegvideo.h @@ -30,6 +30,7 @@ #include "avcodec.h" #include "dsputil.h" +#include "error_resilience.h" #include "get_bits.h" #include "put_bits.h" #include "ratecontrol.h" @@ -484,19 +485,6 @@ typedef struct MpegEncContext { int last_bits; ///< temp var used for calculating the above vars /* error concealment / resync */ - int error_count, error_occurred; - uint8_t *error_status_table; ///< table of the error status of each MB -#define VP_START 1 ///< current MB is the first after a resync marker -#define ER_AC_ERROR 2 -#define ER_DC_ERROR 4 -#define ER_MV_ERROR 8 -#define ER_AC_END 16 -#define ER_DC_END 32 -#define ER_MV_END 64 - -#define ER_MB_ERROR (ER_AC_ERROR|ER_DC_ERROR|ER_MV_ERROR) -#define ER_MB_END (ER_AC_END|ER_DC_END|ER_MV_END) - int resync_mb_x; ///< x position of last resync marker int resync_mb_y; ///< y position of last resync marker GetBitContext last_resync_gb; ///< used to search for the next resync marker @@ -701,15 +689,14 @@ typedef struct MpegEncContext { int mpv_flags; ///< flags set by private options int quantizer_noise_shaping; - /* error resilience stuff */ - uint8_t *er_temp_buffer; - /* temp buffers for rate control */ float *cplx_tab, *bits_tab; /* flag to indicate a reinitialization is required, e.g. after * a frame size change */ int context_reinit; + + ERContext er; } MpegEncContext; #define REBASE_PICTURE(pic, new_ctx, old_ctx) \ @@ -787,9 +774,7 @@ int ff_mpeg_update_thread_context(AVCodecContext *dst, const AVCodecContext *src const uint8_t *avpriv_mpv_find_start_code(const uint8_t *p, const uint8_t *end, uint32_t *state); void ff_set_qscale(MpegEncContext * s, int qscale); -void ff_er_frame_start(MpegEncContext *s); -void ff_er_frame_end(MpegEncContext *s); -void ff_er_add_slice(MpegEncContext *s, int startx, int starty, int endx, int endy, int status); +void ff_mpeg_er_frame_start(MpegEncContext *s); int ff_dct_common_init(MpegEncContext *s); void ff_convert_matrix(DSPContext *dsp, int (*qmat)[64], uint16_t (*qmat16)[2][64], diff --git a/libavcodec/mpegvideo_enc.c b/libavcodec/mpegvideo_enc.c index a99c8deaa6..3ba6f81618 100644 --- a/libavcodec/mpegvideo_enc.c +++ b/libavcodec/mpegvideo_enc.c @@ -3037,7 +3037,7 @@ static void merge_context_after_encode(MpegEncContext *dst, MpegEncContext *src) MERGE(b_count); MERGE(skip_count); MERGE(misc_bits); - MERGE(error_count); + MERGE(er.error_count); MERGE(padding_bug_score); MERGE(current_picture.f.error[0]); MERGE(current_picture.f.error[1]); diff --git a/libavcodec/mss2.c b/libavcodec/mss2.c index 9936272443..006432b17b 100644 --- a/libavcodec/mss2.c +++ b/libavcodec/mss2.c @@ -406,7 +406,7 @@ static int decode_wmv9(AVCodecContext *avctx, const uint8_t *buf, int buf_size, return ret; } - ff_er_frame_start(s); + ff_mpeg_er_frame_start(s); v->bits = buf_size * 8; @@ -419,7 +419,7 @@ static int decode_wmv9(AVCodecContext *avctx, const uint8_t *buf, int buf_size, ff_vc1_decode_blocks(v); - ff_er_frame_end(s); + ff_er_frame_end(&s->er); ff_MPV_frame_end(s); diff --git a/libavcodec/rv10.c b/libavcodec/rv10.c index 38abf7841a..9a9da919d8 100644 --- a/libavcodec/rv10.c +++ b/libavcodec/rv10.c @@ -528,13 +528,13 @@ static int rv10_decode_packet(AVCodecContext *avctx, if ((s->mb_x == 0 && s->mb_y == 0) || s->current_picture_ptr==NULL) { if(s->current_picture_ptr){ //FIXME write parser so we always have complete frames? - ff_er_frame_end(s); + ff_er_frame_end(&s->er); ff_MPV_frame_end(s); s->mb_x= s->mb_y = s->resync_mb_x = s->resync_mb_y= 0; } if(ff_MPV_frame_start(s, avctx) < 0) return -1; - ff_er_frame_start(s); + ff_mpeg_er_frame_start(s); } else { if (s->current_picture_ptr->f.pict_type != s->pict_type) { av_log(s->avctx, AV_LOG_ERROR, "Slice type mismatch\n"); @@ -626,7 +626,7 @@ static int rv10_decode_packet(AVCodecContext *avctx, if(ret == SLICE_END) break; } - ff_er_add_slice(s, start_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, ER_MB_END); + ff_er_add_slice(&s->er, start_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, ER_MB_END); return active_bits_size; } @@ -697,7 +697,7 @@ static int rv10_decode_frame(AVCodecContext *avctx, } if(s->current_picture_ptr != NULL && s->mb_y>=s->mb_height){ - ff_er_frame_end(s); + ff_er_frame_end(&s->er); ff_MPV_frame_end(s); if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) { diff --git a/libavcodec/rv34.c b/libavcodec/rv34.c index a131c105eb..34eeb504b2 100644 --- a/libavcodec/rv34.c +++ b/libavcodec/rv34.c @@ -1428,7 +1428,7 @@ static int rv34_decode_slice(RV34DecContext *r, int end, const uint8_t* buf, int else res = rv34_decode_intra_macroblock(r, r->intra_types + s->mb_x * 4 + 4); if(res < 0){ - ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, ER_MB_ERROR); + ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, ER_MB_ERROR); return -1; } if (++s->mb_x == s->mb_width) { @@ -1451,7 +1451,7 @@ static int rv34_decode_slice(RV34DecContext *r, int end, const uint8_t* buf, int s->first_slice_line=0; s->mb_num_left--; } - ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, ER_MB_END); + ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, ER_MB_END); return s->mb_y == s->mb_height; } @@ -1564,7 +1564,7 @@ static int finish_frame(AVCodecContext *avctx, AVFrame *pict) MpegEncContext *s = &r->s; int got_picture = 0; - ff_er_frame_end(s); + ff_er_frame_end(&s->er); ff_MPV_frame_end(s); s->mb_num_left = 0; @@ -1646,7 +1646,7 @@ int ff_rv34_decode_frame(AVCodecContext *avctx, if (s->mb_num_left > 0) { av_log(avctx, AV_LOG_ERROR, "New frame but still %d MB left.", s->mb_num_left); - ff_er_frame_end(s); + ff_er_frame_end(&s->er); ff_MPV_frame_end(s); } @@ -1667,7 +1667,7 @@ int ff_rv34_decode_frame(AVCodecContext *avctx, s->pict_type = si.type ? si.type : AV_PICTURE_TYPE_I; if (ff_MPV_frame_start(s, s->avctx) < 0) return -1; - ff_er_frame_start(s); + ff_mpeg_er_frame_start(s); if (!r->tmp_b_block_base) { int i; @@ -1766,7 +1766,7 @@ int ff_rv34_decode_frame(AVCodecContext *avctx, av_log(avctx, AV_LOG_INFO, "marking unfished frame as finished\n"); /* always mark the current frame as finished, frame-mt supports * only complete frames */ - ff_er_frame_end(s); + ff_er_frame_end(&s->er); ff_MPV_frame_end(s); s->mb_num_left = 0; ff_thread_report_progress(&s->current_picture_ptr->f, INT_MAX, 0); diff --git a/libavcodec/vc1dec.c b/libavcodec/vc1dec.c index 38b82163a5..73c221e29c 100644 --- a/libavcodec/vc1dec.c +++ b/libavcodec/vc1dec.c @@ -4434,7 +4434,7 @@ static void vc1_decode_i_blocks(VC1Context *v) if (v->s.loop_filter) vc1_loop_filter_iblk(v, v->pq); if (get_bits_count(&s->gb) > v->bits) { - ff_er_add_slice(s, 0, 0, s->mb_x, s->mb_y, ER_MB_ERROR); + ff_er_add_slice(&s->er, 0, 0, s->mb_x, s->mb_y, ER_MB_ERROR); av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i\n", get_bits_count(&s->gb), v->bits); return; @@ -4452,7 +4452,7 @@ static void vc1_decode_i_blocks(VC1Context *v) /* This is intentionally mb_height and not end_mb_y - unlike in advanced * profile, these only differ are when decoding MSS2 rectangles. */ - ff_er_add_slice(s, 0, 0, s->mb_width - 1, s->mb_height - 1, ER_MB_END); + ff_er_add_slice(&s->er, 0, 0, s->mb_width - 1, s->mb_height - 1, ER_MB_END); } /** Decode blocks of I-frame for advanced profile @@ -4562,7 +4562,7 @@ static void vc1_decode_i_blocks_adv(VC1Context *v) if (get_bits_count(&s->gb) > v->bits) { // TODO: may need modification to handle slice coding - ff_er_add_slice(s, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR); + ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR); av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i\n", get_bits_count(&s->gb), v->bits); return; @@ -4586,7 +4586,7 @@ static void vc1_decode_i_blocks_adv(VC1Context *v) } if (v->s.loop_filter) ff_draw_horiz_band(s, (s->end_mb_y-1)*16, 16); - ff_er_add_slice(s, 0, s->start_mb_y << v->field_mode, s->mb_width - 1, + ff_er_add_slice(&s->er, 0, s->start_mb_y << v->field_mode, s->mb_width - 1, (s->end_mb_y << v->field_mode) - 1, ER_MB_END); } @@ -4638,7 +4638,7 @@ static void vc1_decode_p_blocks(VC1Context *v) vc1_apply_p_loop_filter(v); if (get_bits_count(&s->gb) > v->bits || get_bits_count(&s->gb) < 0) { // TODO: may need modification to handle slice coding - ff_er_add_slice(s, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR); + ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR); av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i at %ix%i\n", get_bits_count(&s->gb), v->bits, s->mb_x, s->mb_y); return; @@ -4661,7 +4661,7 @@ static void vc1_decode_p_blocks(VC1Context *v) } if (s->end_mb_y >= s->start_mb_y) ff_draw_horiz_band(s, (s->end_mb_y - 1) * 16, 16); - ff_er_add_slice(s, 0, s->start_mb_y << v->field_mode, s->mb_width - 1, + ff_er_add_slice(&s->er, 0, s->start_mb_y << v->field_mode, s->mb_width - 1, (s->end_mb_y << v->field_mode) - 1, ER_MB_END); } @@ -4707,7 +4707,7 @@ static void vc1_decode_b_blocks(VC1Context *v) vc1_decode_b_mb(v); if (get_bits_count(&s->gb) > v->bits || get_bits_count(&s->gb) < 0) { // TODO: may need modification to handle slice coding - ff_er_add_slice(s, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR); + ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR); av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i at %ix%i\n", get_bits_count(&s->gb), v->bits, s->mb_x, s->mb_y); return; @@ -4722,7 +4722,7 @@ static void vc1_decode_b_blocks(VC1Context *v) } if (v->s.loop_filter) ff_draw_horiz_band(s, (s->end_mb_y - 1) * 16, 16); - ff_er_add_slice(s, 0, s->start_mb_y << v->field_mode, s->mb_width - 1, + ff_er_add_slice(&s->er, 0, s->start_mb_y << v->field_mode, s->mb_width - 1, (s->end_mb_y << v->field_mode) - 1, ER_MB_END); } @@ -4730,7 +4730,7 @@ static void vc1_decode_skip_blocks(VC1Context *v) { MpegEncContext *s = &v->s; - ff_er_add_slice(s, 0, s->start_mb_y, s->mb_width - 1, s->end_mb_y - 1, ER_MB_END); + ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_width - 1, s->end_mb_y - 1, ER_MB_END); s->first_slice_line = 1; for (s->mb_y = s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) { s->mb_x = 0; @@ -5558,7 +5558,7 @@ static int vc1_decode_frame(AVCodecContext *avctx, void *data, if (avctx->hwaccel->end_frame(avctx) < 0) goto err; } else { - ff_er_frame_start(s); + ff_mpeg_er_frame_start(s); v->bits = buf_size * 8; v->end_mb_x = s->mb_width; @@ -5635,7 +5635,7 @@ static int vc1_decode_frame(AVCodecContext *avctx, void *data, get_bits_count(&s->gb), s->gb.size_in_bits); // if (get_bits_count(&s->gb) > buf_size * 8) // return -1; - ff_er_frame_end(s); + ff_er_frame_end(&s->er); } ff_MPV_frame_end(s); -- 2.11.0