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

Merge commit '54974c62982ae827becdbdb9b620b7ba75d079a0'

Browse Source 
* commit '54974c62982ae827becdbdb9b620b7ba75d079a0':
  error_resilience: decouple ER from MpegEncContext

Conflicts:
	libavcodec/error_resilience.c
	libavcodec/h263dec.c
	libavcodec/h264.c
	libavcodec/mpegvideo.c
	libavcodec/vc1dec.c

Merged-by: Michael Niedermayer <michaelni@gmx.at>
pull/8/merge
Michael Niedermayer 12 years ago
parent 2bac1535db 54974c6298
commit 1fad547cef
15 changed files with 450 additions and 339 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. 415
      libavcodec/error_resilience.c
  2. 74
      libavcodec/error_resilience.h
  3. 2
      libavcodec/h261dec.c
  4. 20
      libavcodec/h263dec.c
  5. 75
      libavcodec/h264.c
  6. 2
      libavcodec/intrax8.c
  7. 20
      libavcodec/mpeg12.c
  8. 10
      libavcodec/mpeg4videodec.c
  9. 98
      libavcodec/mpegvideo.c
  10. 23
      libavcodec/mpegvideo.h
  11. 2
      libavcodec/mpegvideo_enc.c
  12. 4
      libavcodec/mss2.c
  13. 8
      libavcodec/rv10.c
  14. 12
      libavcodec/rv34.c
  15. 24
      libavcodec/vc1dec.c

415
libavcodec/error_resilience.c
Unescape View File

@ -29,72 +29,21 @@
#include "avcodec.h" #include "avcodec.h"
#include "dsputil.h" #include "dsputil.h"
#include "error_resilience.h"
#include "mpegvideo.h" #include "mpegvideo.h"
#include "h264.h"
#include "rectangle.h" #include "rectangle.h"
#include "thread.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);
ff_init_block_index(s);
ff_update_block_index(s);
s->dest[1] += (16 >> s->chroma_x_shift) - 8;
s->dest[2] += (16 >> s->chroma_x_shift) - 8;
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));
av_assert1(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;
if (!h->ref_list[0][ref].f.data[0]) {
av_log(s->avctx, AV_LOG_DEBUG, "Reference not available for error concealing\n");
ref = 0;
}
if ((h->ref_list[0][ref].f.reference&3) != 3) {
av_log(s->avctx, AV_LOG_DEBUG, "Reference invalid\n");
return;
}
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);
h->mb_mbaff =
h->mb_field_decoding_flag = 0;
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 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 * @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) { if (s->avctx->codec_id == AV_CODEC_ID_H264) {
H264Context *h = (void*)s;
av_assert0(s->quarter_sample); av_assert0(s->quarter_sample);
*mv_step = 4; *mv_step = 4;
*stride = h->b_stride; *stride = s->mb_width * 4;
} else { } else {
*mv_step = 2; *mv_step = 2;
*stride = s->b8_stride; *stride = s->b8_stride;
@ -104,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. * 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) uint8_t *dest_cr, int mb_x, int mb_y)
{ {
int *linesize = s->cur_pic->f.linesize;
int dc, dcu, dcv, y, i; int dc, dcu, dcv, y, i;
for (i = 0; i < 4; 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]; dc = s->dc_val[0][mb_x * 2 + (i & 1) + (mb_y * 2 + (i >> 1)) * s->b8_stride];
@ -117,7 +67,7 @@ static void put_dc(MpegEncContext *s, uint8_t *dest_y, uint8_t *dest_cb,
for (y = 0; y < 8; y++) { for (y = 0; y < 8; y++) {
int x; int x;
for (x = 0; x < 8; 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]; dcu = s->dc_val[1][mb_x + mb_y * s->mb_stride];
@ -133,8 +83,8 @@ static void put_dc(MpegEncContext *s, uint8_t *dest_y, uint8_t *dest_cb,
for (y = 0; y < 8; y++) { for (y = 0; y < 8; y++) {
int x; int x;
for (x = 0; x < 8; x++) { for (x = 0; x < 8; x++) {
dest_cb[x + y * s->uvlinesize] = dcu / 8; dest_cb[x + y * linesize[1]] = dcu / 8;
dest_cr[x + y * s->uvlinesize] = dcv / 8; dest_cr[x + y * linesize[2]] = dcv / 8;
} }
} }
} }
@ -180,7 +130,7 @@ static void filter181(int16_t *data, int width, int height, int stride)
* @param w width in 8 pixel blocks * @param w width in 8 pixel blocks
* @param h height 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 h, int stride, int is_luma)
{ {
int b_x, b_y; int b_x, b_y;
@ -198,7 +148,7 @@ static void guess_dc(MpegEncContext *s, int16_t *dc, int w,
for(b_x=0; b_x<w; b_x++){ for(b_x=0; b_x<w; b_x++){
int mb_index_j= (b_x>>is_luma) + (b_y>>is_luma)*s->mb_stride; int mb_index_j= (b_x>>is_luma) + (b_y>>is_luma)*s->mb_stride;
int error_j= s->error_status_table[mb_index_j]; 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)){ if(intra_j==0 || !(error_j&ER_DC_ERROR)){
color= dc[b_x + b_y*stride]; color= dc[b_x + b_y*stride];
distance= b_x; distance= b_x;
@ -211,7 +161,7 @@ static void guess_dc(MpegEncContext *s, int16_t *dc, int w,
for(b_x=w-1; b_x>=0; b_x--){ for(b_x=w-1; b_x>=0; b_x--){
int mb_index_j= (b_x>>is_luma) + (b_y>>is_luma)*s->mb_stride; int mb_index_j= (b_x>>is_luma) + (b_y>>is_luma)*s->mb_stride;
int error_j= s->error_status_table[mb_index_j]; 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)){ if(intra_j==0 || !(error_j&ER_DC_ERROR)){
color= dc[b_x + b_y*stride]; color= dc[b_x + b_y*stride];
distance= b_x; distance= b_x;
@ -226,7 +176,7 @@ static void guess_dc(MpegEncContext *s, int16_t *dc, int w,
for(b_y=0; b_y<h; b_y++){ for(b_y=0; b_y<h; b_y++){
int mb_index_j= (b_x>>is_luma) + (b_y>>is_luma)*s->mb_stride; int mb_index_j= (b_x>>is_luma) + (b_y>>is_luma)*s->mb_stride;
int error_j= s->error_status_table[mb_index_j]; 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)){ if(intra_j==0 || !(error_j&ER_DC_ERROR)){
color= dc[b_x + b_y*stride]; color= dc[b_x + b_y*stride];
distance= b_y; distance= b_y;
@ -239,7 +189,7 @@ static void guess_dc(MpegEncContext *s, int16_t *dc, int w,
for(b_y=h-1; b_y>=0; b_y--){ for(b_y=h-1; b_y>=0; b_y--){
int mb_index_j= (b_x>>is_luma) + (b_y>>is_luma)*s->mb_stride; int mb_index_j= (b_x>>is_luma) + (b_y>>is_luma)*s->mb_stride;
int error_j= s->error_status_table[mb_index_j]; 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)){ if(intra_j==0 || !(error_j&ER_DC_ERROR)){
color= dc[b_x + b_y*stride]; color= dc[b_x + b_y*stride];
distance= b_y; distance= b_y;
@ -256,7 +206,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; mb_index = (b_x >> is_luma) + (b_y >> is_luma) * s->mb_stride;
error = s->error_status_table[mb_index]; 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 continue; // inter
if (!(error & ER_DC_ERROR)) if (!(error & ER_DC_ERROR))
continue; // dc-ok continue; // dc-ok
@ -283,7 +233,7 @@ fail:
* @param w width in 8 pixel blocks * @param w width in 8 pixel blocks
* @param h height 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 h, int stride, int is_luma)
{ {
int b_x, b_y, mvx_stride, mvy_stride; int b_x, b_y, mvx_stride, mvy_stride;
@ -297,13 +247,13 @@ static void h_block_filter(MpegEncContext *s, uint8_t *dst, int w,
int y; int y;
int left_status = s->error_status_table[( b_x >> is_luma) + (b_y >> is_luma) * s->mb_stride]; 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 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 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->current_picture.f.mb_type[((b_x + 1) >> 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 left_damage = left_status & ER_MB_ERROR;
int right_damage = right_status & ER_MB_ERROR; int right_damage = right_status & ER_MB_ERROR;
int offset = b_x * 8 + b_y * stride * 8; 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 *left_mv = s->cur_pic->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 *right_mv = s->cur_pic->f.motion_val[0][mvy_stride * b_y + mvx_stride * (b_x + 1)];
if (!(left_damage || right_damage)) if (!(left_damage || right_damage))
continue; // both undamaged continue; // both undamaged
if ((!left_intra) && (!right_intra) && if ((!left_intra) && (!right_intra) &&
@ -351,7 +301,7 @@ static void h_block_filter(MpegEncContext *s, uint8_t *dst, int w,
* @param w width in 8 pixel blocks * @param w width in 8 pixel blocks
* @param h height 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 stride, int is_luma)
{ {
int b_x, b_y, mvx_stride, mvy_stride; int b_x, b_y, mvx_stride, mvy_stride;
@ -365,14 +315,14 @@ static void v_block_filter(MpegEncContext *s, uint8_t *dst, int w, int h,
int x; int x;
int top_status = s->error_status_table[(b_x >> is_luma) + (b_y >> is_luma) * s->mb_stride]; 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 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 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->current_picture.f.mb_type[(b_x >> is_luma) + ((b_y + 1) >> 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 top_damage = top_status & ER_MB_ERROR;
int bottom_damage = bottom_status & ER_MB_ERROR; int bottom_damage = bottom_status & ER_MB_ERROR;
int offset = b_x * 8 + b_y * stride * 8; 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 *top_mv = s->cur_pic->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 *bottom_mv = s->cur_pic->f.motion_val[0][mvy_stride * (b_y + 1) + mvx_stride * b_x];
if (!(top_damage || bottom_damage)) if (!(top_damage || bottom_damage))
continue; // both undamaged continue; // both undamaged
@ -417,7 +367,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; uint8_t *fixed = s->er_temp_buffer;
#define MV_FROZEN 3 #define MV_FROZEN 3
@ -437,7 +387,7 @@ static void guess_mv(MpegEncContext *s)
int f = 0; int f = 0;
int error = s->error_status_table[mb_xy]; 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 f = MV_FROZEN; // intra // FIXME check
if (!(error & ER_MV_ERROR)) if (!(error & ER_MV_ERROR))
f = MV_FROZEN; // inter with undamaged MV f = MV_FROZEN; // inter with undamaged MV
@ -445,13 +395,13 @@ static void guess_mv(MpegEncContext *s)
fixed[mb_xy] = f; fixed[mb_xy] = f;
if (f == MV_FROZEN) if (f == MV_FROZEN)
num_avail++; num_avail++;
else if(s->last_picture.f.data[0] && s->last_picture.f.motion_val[0]){ else if(s->last_pic->f.data[0] && s->last_pic->f.motion_val[0]){
const int mb_y= mb_xy / s->mb_stride; const int mb_y= mb_xy / s->mb_stride;
const int mb_x= mb_xy % s->mb_stride; const int mb_x= mb_xy % s->mb_stride;
const int mot_index= (mb_x + mb_y*mot_stride) * mot_step; const int mot_index= (mb_x + mb_y*mot_stride) * mot_step;
s->current_picture.f.motion_val[0][mot_index][0]= s->last_picture.f.motion_val[0][mot_index][0]; s->cur_pic->f.motion_val[0][mot_index][0]= s->last_pic->f.motion_val[0][mot_index][0];
s->current_picture.f.motion_val[0][mot_index][1]= s->last_picture.f.motion_val[0][mot_index][1]; s->cur_pic->f.motion_val[0][mot_index][1]= s->last_pic->f.motion_val[0][mot_index][1];
s->current_picture.f.ref_index[0][4*mb_xy] = s->last_picture.f.ref_index[0][4*mb_xy]; s->cur_pic->f.ref_index[0][4*mb_xy] = s->last_pic->f.ref_index[0][4*mb_xy];
} }
} }
@ -460,25 +410,17 @@ static void guess_mv(MpegEncContext *s)
for (mb_y = 0; mb_y < s->mb_height; mb_y++) { for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
for (mb_x = 0; mb_x < s->mb_width; mb_x++) { 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_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;
if (IS_INTRA(s->current_picture.f.mb_type[mb_xy])) if (IS_INTRA(s->cur_pic->f.mb_type[mb_xy]))
continue; continue;
if (!(s->error_status_table[mb_xy] & ER_MV_ERROR)) if (!(s->error_status_table[mb_xy] & ER_MV_ERROR))
continue; 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][0] = 0;
s->mv[0][0][1] = 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; return;
@ -511,8 +453,8 @@ static void guess_mv(MpegEncContext *s)
if (fixed[mb_xy] == MV_FROZEN) if (fixed[mb_xy] == MV_FROZEN)
continue; continue;
av_assert1(!IS_INTRA(s->current_picture.f.mb_type[mb_xy])); av_assert1(!IS_INTRA(s->cur_pic->f.mb_type[mb_xy]));
av_assert1(s->last_picture_ptr && s->last_picture_ptr->f.data[0]); av_assert1(s->last_pic && s->last_pic->f.data[0]);
j = 0; j = 0;
if (mb_x > 0 && fixed[mb_xy - 1] == MV_FROZEN) if (mb_x > 0 && fixed[mb_xy - 1] == MV_FROZEN)
@ -542,38 +484,38 @@ static void guess_mv(MpegEncContext *s)
if (mb_x > 0 && fixed[mb_xy - 1]) { if (mb_x > 0 && fixed[mb_xy - 1]) {
mv_predictor[pred_count][0] = 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] = 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] = 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++; pred_count++;
} }
if (mb_x + 1 < mb_width && fixed[mb_xy + 1]) { if (mb_x + 1 < mb_width && fixed[mb_xy + 1]) {
mv_predictor[pred_count][0] = 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] = 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] = 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++; pred_count++;
} }
if (mb_y > 0 && fixed[mb_xy - mb_stride]) { if (mb_y > 0 && fixed[mb_xy - mb_stride]) {
mv_predictor[pred_count][0] = 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] = 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] = 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++; pred_count++;
} }
if (mb_y + 1<mb_height && fixed[mb_xy + mb_stride]) { if (mb_y + 1<mb_height && fixed[mb_xy + mb_stride]) {
mv_predictor[pred_count][0] = 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] = 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] = 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++; pred_count++;
} }
if (pred_count == 0) if (pred_count == 0)
@ -631,19 +573,19 @@ skip_mean_and_median:
if (s->avctx->codec_id == AV_CODEC_ID_H264) { if (s->avctx->codec_id == AV_CODEC_ID_H264) {
// FIXME // FIXME
} else { } else {
ff_thread_await_progress(&s->last_picture_ptr->f, ff_thread_await_progress(&s->last_pic->f,
mb_y, 0); mb_y, 0);
} }
if (!s->last_picture.f.motion_val[0] || if (!s->last_pic->f.motion_val[0] ||
!s->last_picture.f.ref_index[0]) !s->last_pic->f.ref_index[0])
goto skip_last_mv; goto skip_last_mv;
prev_x = s->last_picture.f.motion_val[0][mot_index][0]; prev_x = s->last_pic->f.motion_val[0][mot_index][0];
prev_y = s->last_picture.f.motion_val[0][mot_index][1]; prev_y = s->last_pic->f.motion_val[0][mot_index][1];
prev_ref = s->last_picture.f.ref_index[0][4 * mb_xy]; prev_ref = s->last_pic->f.ref_index[0][4 * mb_xy];
} else { } else {
prev_x = s->current_picture.f.motion_val[0][mot_index][0]; prev_x = s->cur_pic->f.motion_val[0][mot_index][0];
prev_y = s->current_picture.f.motion_val[0][mot_index][1]; prev_y = s->cur_pic->f.motion_val[0][mot_index][1];
prev_ref = s->current_picture.f.ref_index[0][4 * mb_xy]; prev_ref = s->cur_pic->f.ref_index[0][4 * mb_xy];
} }
/* last MV */ /* last MV */
@ -653,54 +595,47 @@ skip_mean_and_median:
pred_count++; pred_count++;
skip_last_mv: 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++) { for (j = 0; j < pred_count; j++) {
int *linesize = s->cur_pic->f.linesize;
int score = 0; int score = 0;
uint8_t *src = s->current_picture.f.data[0] + uint8_t *src = s->cur_pic->f.data[0] +
mb_x * 16 + mb_y * 16 * s->linesize; 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->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]; s->mv[0][0][1] = mv_predictor[j][1];
// predictor intra or otherwise not available // predictor intra or otherwise not available
if (ref[j] < 0) if (ref[j] < 0)
continue; 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]) { if (mb_x > 0 && fixed[mb_xy - 1]) {
int k; int k;
for (k = 0; k < 16; k++) for (k = 0; k < 16; k++)
score += FFABS(src[k * s->linesize - 1] - score += FFABS(src[k * linesize[0] - 1] -
src[k * s->linesize]); src[k * linesize[0]]);
} }
if (mb_x + 1 < mb_width && fixed[mb_xy + 1]) { if (mb_x + 1 < mb_width && fixed[mb_xy + 1]) {
int k; int k;
for (k = 0; k < 16; k++) for (k = 0; k < 16; k++)
score += FFABS(src[k * s->linesize + 15] - score += FFABS(src[k * linesize[0] + 15] -
src[k * s->linesize + 16]); src[k * linesize[0] + 16]);
} }
if (mb_y > 0 && fixed[mb_xy - mb_stride]) { if (mb_y > 0 && fixed[mb_xy - mb_stride]) {
int k; int k;
for (k = 0; k < 16; 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]) { if (mb_y + 1 < mb_height && fixed[mb_xy + mb_stride]) {
int k; int k;
for (k = 0; k < 16; k++) for (k = 0; k < 16; k++)
score += FFABS(src[k + s->linesize * 15] - score += FFABS(src[k + linesize[0] * 15] -
src[k + s->linesize * 16]); src[k + linesize[0] * 16]);
} }
if (score <= best_score) { // <= will favor the last MV if (score <= best_score) { // <= will favor the last MV
@ -714,11 +649,12 @@ skip_last_mv:
for (i = 0; i < mot_step; i++) for (i = 0; i < mot_step; i++)
for (j = 0; j < mot_step; j++) { 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->cur_pic->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][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) { if (s->mv[0][0][0] != prev_x || s->mv[0][0][1] != prev_y) {
@ -741,11 +677,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; 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 return 1; // no previous frame available -> use spatial prediction
undamaged_count = 0; undamaged_count = 0;
@ -756,12 +692,8 @@ static int is_intra_more_likely(MpegEncContext *s)
undamaged_count++; undamaged_count++;
} }
if (s->codec_id == AV_CODEC_ID_H264) { if (s->avctx->codec_id == AV_CODEC_ID_H264 && s->ref_count <= 0)
H264Context *h = (void*) s; return 1;
if (h->list_count <= 0 || h->ref_count[0] <= 0 ||
!h->ref_list[0][0].f.data[0])
return 1;
}
if (undamaged_count < 5) if (undamaged_count < 5)
return 0; // almost all MBs damaged -> use temporal prediction return 0; // almost all MBs damaged -> use temporal prediction
@ -769,7 +701,7 @@ static int is_intra_more_likely(MpegEncContext *s)
// prevent dsp.sad() check, that requires access to the image // prevent dsp.sad() check, that requires access to the image
if (CONFIG_MPEG_XVMC_DECODER && if (CONFIG_MPEG_XVMC_DECODER &&
s->avctx->xvmc_acceleration && s->avctx->xvmc_acceleration &&
s->pict_type == AV_PICTURE_TYPE_I) s->cur_pic->f.pict_type == AV_PICTURE_TYPE_I)
return 1; return 1;
skip_amount = FFMAX(undamaged_count / 50, 1); // check only up to 50 MBs skip_amount = FFMAX(undamaged_count / 50, 1); // check only up to 50 MBs
@ -790,23 +722,26 @@ static int is_intra_more_likely(MpegEncContext *s)
if ((j % skip_amount) != 0) if ((j % skip_amount) != 0)
continue; continue;
if (s->pict_type == AV_PICTURE_TYPE_I) { if (s->cur_pic->f.pict_type == AV_PICTURE_TYPE_I) {
uint8_t *mb_ptr = s->current_picture.f.data[0] + int *linesize = s->cur_pic->f.linesize;
mb_x * 16 + mb_y * 16 * s->linesize; uint8_t *mb_ptr = s->cur_pic->f.data[0] +
uint8_t *last_mb_ptr = s->last_picture.f.data[0] + mb_x * 16 + mb_y * 16 * linesize[0];
mb_x * 16 + mb_y * 16 * s->linesize; 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) { if (s->avctx->codec_id == AV_CODEC_ID_H264) {
// FIXME // FIXME
} else { } else {
ff_thread_await_progress(&s->last_picture_ptr->f, ff_thread_await_progress(&s->last_pic->f, mb_y, 0);
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, mb_ptr,
linesize[0], 16);
// FIXME need await_progress() here // FIXME need await_progress() here
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,
last_mb_ptr + linesize[0] * 16,
linesize[0], 16);
} else { } 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++; is_intra_likely++;
else else
is_intra_likely--; is_intra_likely--;
@ -817,9 +752,9 @@ static int is_intra_more_likely(MpegEncContext *s)
return is_intra_likely > 0; 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; return;
memset(s->error_status_table, ER_MB_ERROR | VP_START | ER_MB_END, memset(s->error_status_table, ER_MB_ERROR | VP_START | ER_MB_END,
@ -835,7 +770,7 @@ void ff_er_frame_start(MpegEncContext *s)
* @param status the status at the end (ER_MV_END, ER_AC_ERROR, ...), it is * @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 * 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) int endx, int endy, int status)
{ {
const int start_i = av_clip(startx + starty * s->mb_width, 0, s->mb_num - 1); const int start_i = av_clip(startx + starty * s->mb_width, 0, s->mb_num - 1);
@ -853,7 +788,7 @@ void ff_er_add_slice(MpegEncContext *s, int startx, int starty,
return; return;
} }
if (!s->err_recognition) if (!s->avctx->err_recognition)
return; return;
mask &= ~VP_START; mask &= ~VP_START;
@ -903,43 +838,37 @@ 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 i, mb_x, mb_y, error, error_type, dc_error, mv_error, ac_error;
int distance; int distance;
int threshold_part[4] = { 100, 100, 100 }; int threshold_part[4] = { 100, 100, 100 };
int threshold = 50; int threshold = 50;
int is_intra_likely; int is_intra_likely;
int size = s->b8_stride * 2 * s->mb_height; int size = s->b8_stride * 2 * s->mb_height;
Picture *pic = s->current_picture_ptr;
/* We do not support ER of field pictures yet, /* We do not support ER of field pictures yet,
* though it should not crash if enabled. */ * though it should not crash if enabled. */
if (!s->err_recognition || s->error_count == 0 || s->avctx->lowres || if (!s->avctx->err_recognition || s->error_count == 0 ||
s->avctx->lowres ||
s->avctx->hwaccel || s->avctx->hwaccel ||
s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU || 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->error_count == 3 * s->mb_width *
(s->avctx->skip_top + s->avctx->skip_bottom)) { (s->avctx->skip_top + s->avctx->skip_bottom)) {
return; return;
};
if ( s->picture_structure == PICT_FRAME
&& s->current_picture.f.linesize[0] != s->current_picture_ptr->f.linesize[0]) {
av_log(s->avctx, AV_LOG_ERROR, "Error concealment not possible, frame not fully initialized\n");
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"); av_log(s->avctx, AV_LOG_ERROR, "Warning MVs not available\n");
for (i = 0; i < 2; i++) { for (i = 0; i < 2; i++) {
pic->f.ref_index[i] = av_mallocz(s->mb_stride * s->mb_height * 4 * sizeof(uint8_t)); s->cur_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)); s->cur_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.motion_val[i] = s->cur_pic->motion_val_base[i] + 4;
} }
pic->f.motion_subsample_log2 = 3; s->cur_pic->f.motion_subsample_log2 = 3;
s->current_picture = *s->current_picture_ptr;
} }
if (s->avctx->debug & FF_DEBUG_ER) { if (s->avctx->debug & FF_DEBUG_ER) {
@ -1000,7 +929,7 @@ void ff_er_frame_end(MpegEncContext *s)
} }
#endif #endif
/* handle missing slices */ /* handle missing slices */
if (s->err_recognition & AV_EF_EXPLODE) { if (s->avctx->err_recognition & AV_EF_EXPLODE) {
int end_ok = 1; int end_ok = 1;
// FIXME + 100 hack // FIXME + 100 hack
@ -1090,7 +1019,7 @@ void ff_er_frame_end(MpegEncContext *s)
mv_error++; mv_error++;
} }
av_log(s->avctx, AV_LOG_INFO, "concealing %d DC, %d AC, %d MV errors in %c frame\n", av_log(s->avctx, AV_LOG_INFO, "concealing %d DC, %d AC, %d MV errors in %c frame\n",
dc_error, ac_error, mv_error, av_get_picture_type_char(s->pict_type)); dc_error, ac_error, mv_error, av_get_picture_type_char(s->cur_pic->f.pict_type));
is_intra_likely = is_intra_more_likely(s); is_intra_likely = is_intra_more_likely(s);
@ -1102,25 +1031,28 @@ void ff_er_frame_end(MpegEncContext *s)
continue; continue;
if (is_intra_likely) 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 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 // 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++) { for (i = 0; i < s->mb_num; i++) {
const int mb_xy = s->mb_index2xy[i]; const int mb_xy = s->mb_index2xy[i];
if (!IS_INTRA(s->current_picture.f.mb_type[mb_xy])) if (!IS_INTRA(s->cur_pic->f.mb_type[mb_xy]))
s->current_picture.f.mb_type[mb_xy] = MB_TYPE_INTRA4x4; s->cur_pic->f.mb_type[mb_xy] = MB_TYPE_INTRA4x4;
} }
/* handle inter blocks with damaged AC */ /* handle inter blocks with damaged AC */
for (mb_y = 0; mb_y < s->mb_height; mb_y++) { for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
for (mb_x = 0; mb_x < s->mb_width; mb_x++) { 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_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];
int dir = !s->last_picture.f.data[0]; 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]; error = s->error_status_table[mb_xy];
@ -1131,38 +1063,33 @@ void ff_er_frame_end(MpegEncContext *s)
if (!(error & ER_AC_ERROR)) if (!(error & ER_AC_ERROR))
continue; // undamaged inter 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)) { if (IS_8X8(mb_type)) {
int mb_index = mb_x * 2 + mb_y * 2 * s->b8_stride; int mb_index = mb_x * 2 + mb_y * 2 * s->b8_stride;
int j; int j;
s->mv_type = MV_TYPE_8X8; mv_type = MV_TYPE_8X8;
for (j = 0; j < 4; j++) { 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][0] = s->cur_pic->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][1] = s->cur_pic->f.motion_val[dir][mb_index + (j & 1) + (j >> 1) * s->b8_stride][1];
} }
} else { } else {
s->mv_type = MV_TYPE_16X16; 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][0] = s->cur_pic->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]; 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->decode_mb(s->opaque, 0 /* FIXME h264 partitioned slices need this set */,
mv_dir, mv_type, &s->mv, mb_x, mb_y, 0, 0);
s->mb_x = mb_x;
s->mb_y = mb_y;
decode_mb(s, 0 /* FIXME h264 partitioned slices need this set */);
} }
} }
/* guess MVs */ /* 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++) { for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
for (mb_x = 0; mb_x < s->mb_width; mb_x++) { for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
int xy = mb_x * 2 + mb_y * 2 * s->b8_stride; 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_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];
int mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
error = s->error_status_table[mb_xy]; error = s->error_status_table[mb_xy];
@ -1173,25 +1100,22 @@ void ff_er_frame_end(MpegEncContext *s)
if (!(error & ER_AC_ERROR)) if (!(error & ER_AC_ERROR))
continue; // undamaged inter continue; // undamaged inter
s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD; if (!(s->last_pic && s->last_pic->f.data[0]))
if (!s->last_picture.f.data[0]) mv_dir &= ~MV_DIR_FORWARD;
s->mv_dir &= ~MV_DIR_FORWARD; if (!(s->next_pic && s->next_pic->f.data[0]))
if (!s->next_picture.f.data[0]) mv_dir &= ~MV_DIR_BACKWARD;
s->mv_dir &= ~MV_DIR_BACKWARD;
s->mb_intra = 0;
s->mv_type = MV_TYPE_16X16;
s->mb_skipped = 0;
if (s->pp_time) { if (s->pp_time) {
int time_pp = s->pp_time; int time_pp = s->pp_time;
int time_pb = s->pb_time; int time_pb = s->pb_time;
av_assert0(s->avctx->codec_id != AV_CODEC_ID_H264); av_assert0(s->avctx->codec_id != AV_CODEC_ID_H264);
ff_thread_await_progress(&s->next_picture_ptr->f, mb_y, 0); ff_thread_await_progress(&s->next_pic->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[0][0][0] = s->next_pic->f.motion_val[0][xy][0] * 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[0][0][1] = s->next_pic->f.motion_val[0][xy][1] * time_pb / time_pp;
s->mv[1][0][1] = s->next_picture.f.motion_val[0][xy][1] * (time_pb - time_pp) / 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 { } else {
s->mv[0][0][0] = 0; s->mv[0][0][0] = 0;
s->mv[0][0][1] = 0; s->mv[0][0][1] = 0;
@ -1199,10 +1123,8 @@ void ff_er_frame_end(MpegEncContext *s)
s->mv[1][0][1] = 0; s->mv[1][0][1] = 0;
} }
s->dsp.clear_blocks(s->block[0]); s->decode_mb(s->opaque, 0, mv_dir, MV_TYPE_16X16, &s->mv,
s->mb_x = mb_x; mb_x, mb_y, 0, 0);
s->mb_y = mb_y;
decode_mb(s, 0);
} }
} }
} else } else
@ -1218,7 +1140,7 @@ void ff_er_frame_end(MpegEncContext *s)
int16_t *dc_ptr; int16_t *dc_ptr;
uint8_t *dest_y, *dest_cb, *dest_cr; uint8_t *dest_y, *dest_cb, *dest_cr;
const int mb_xy = mb_x + mb_y * s->mb_stride; 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]; error = s->error_status_table[mb_xy];
@ -1227,9 +1149,9 @@ void ff_er_frame_end(MpegEncContext *s)
// if (error & ER_MV_ERROR) // if (error & ER_MV_ERROR)
// continue; // inter data damaged FIXME is this good? // 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_y = s->cur_pic->f.data[0] + mb_x * 16 + mb_y * 16 * linesize[0];
dest_cb = s->current_picture.f.data[1] + mb_x * 8 + mb_y * 8 * s->uvlinesize; dest_cb = s->cur_pic->f.data[1] + mb_x * 8 + mb_y * 8 * linesize[1];
dest_cr = s->current_picture.f.data[2] + mb_x * 8 + mb_y * 8 * s->uvlinesize; 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]; dc_ptr = &s->dc_val[0][mb_x * 2 + mb_y * 2 * s->b8_stride];
for (n = 0; n < 4; n++) { for (n = 0; n < 4; n++) {
@ -1238,7 +1160,7 @@ void ff_er_frame_end(MpegEncContext *s)
int x; int x;
for (x = 0; x < 8; x++) for (x = 0; x < 8; x++)
dc += dest_y[x + (n & 1) * 8 + 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; dc_ptr[(n & 1) + (n >> 1) * s->b8_stride] = (dc + 4) >> 3;
} }
@ -1247,8 +1169,8 @@ void ff_er_frame_end(MpegEncContext *s)
for (y = 0; y < 8; y++) { for (y = 0; y < 8; y++) {
int x; int x;
for (x = 0; x < 8; x++) { for (x = 0; x < 8; x++) {
dcu += dest_cb[x + y * s->uvlinesize]; dcu += dest_cb[x + y * linesize[1]];
dcv += dest_cr[x + y * s->uvlinesize]; dcv += dest_cr[x + y * linesize[2]];
} }
} }
s->dc_val[1][mb_x + mb_y * s->mb_stride] = (dcu + 4) >> 3; s->dc_val[1][mb_x + mb_y * s->mb_stride] = (dcu + 4) >> 3;
@ -1271,7 +1193,7 @@ void ff_er_frame_end(MpegEncContext *s)
for (mb_x = 0; mb_x < s->mb_width; mb_x++) { for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
uint8_t *dest_y, *dest_cb, *dest_cr; uint8_t *dest_y, *dest_cb, *dest_cr;
const int mb_xy = mb_x + mb_y * s->mb_stride; 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]; error = s->error_status_table[mb_xy];
@ -1280,9 +1202,9 @@ void ff_er_frame_end(MpegEncContext *s)
if (!(error & ER_AC_ERROR)) if (!(error & ER_AC_ERROR))
continue; // undamaged continue; // undamaged
dest_y = s->current_picture.f.data[0] + mb_x * 16 + mb_y * 16 * s->linesize; dest_y = s->cur_pic->f.data[0] + mb_x * 16 + mb_y * 16 * linesize[0];
dest_cb = s->current_picture.f.data[1] + mb_x * 8 + mb_y * 8 * s->uvlinesize; dest_cb = s->cur_pic->f.data[1] + mb_x * 8 + mb_y * 8 * linesize[1];
dest_cr = s->current_picture.f.data[2] + mb_x * 8 + mb_y * 8 * s->uvlinesize; 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); put_dc(s, dest_y, dest_cb, dest_cr, mb_x, mb_y);
} }
@ -1291,20 +1213,20 @@ void ff_er_frame_end(MpegEncContext *s)
if (s->avctx->error_concealment & FF_EC_DEBLOCK) { if (s->avctx->error_concealment & FF_EC_DEBLOCK) {
/* filter horizontal block boundaries */ /* filter horizontal block boundaries */
h_block_filter(s, s->current_picture.f.data[0], s->mb_width * 2, h_block_filter(s, s->cur_pic->f.data[0], s->mb_width * 2,
s->mb_height * 2, s->linesize, 1); s->mb_height * 2, linesize[0], 1);
h_block_filter(s, s->current_picture.f.data[1], s->mb_width, h_block_filter(s, s->cur_pic->f.data[1], s->mb_width,
s->mb_height , s->uvlinesize, 0); s->mb_height, linesize[1], 0);
h_block_filter(s, s->current_picture.f.data[2], s->mb_width, h_block_filter(s, s->cur_pic->f.data[2], s->mb_width,
s->mb_height , s->uvlinesize, 0); s->mb_height, linesize[2], 0);
/* filter vertical block boundaries */ /* filter vertical block boundaries */
v_block_filter(s, s->current_picture.f.data[0], s->mb_width * 2, v_block_filter(s, s->cur_pic->f.data[0], s->mb_width * 2,
s->mb_height * 2, s->linesize, 1); s->mb_height * 2, linesize[0], 1);
v_block_filter(s, s->current_picture.f.data[1], s->mb_width, v_block_filter(s, s->cur_pic->f.data[1], s->mb_width,
s->mb_height , s->uvlinesize, 0); s->mb_height, linesize[1], 0);
v_block_filter(s, s->current_picture.f.data[2], s->mb_width, v_block_filter(s, s->cur_pic->f.data[2], s->mb_width,
s->mb_height , s->uvlinesize, 0); s->mb_height, linesize[2], 0);
} }
ec_clean: ec_clean:
@ -1313,10 +1235,13 @@ ec_clean:
const int mb_xy = s->mb_index2xy[i]; const int mb_xy = s->mb_index2xy[i];
int error = s->error_status_table[mb_xy]; 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))) { (error & (ER_DC_ERROR | ER_MV_ERROR | ER_AC_ERROR))) {
s->mbskip_table[mb_xy] = 0; s->mbskip_table[mb_xy] = 0;
} }
s->mbintra_table[mb_xy] = 1; s->mbintra_table[mb_xy] = 1;
} }
s->cur_pic = NULL;
s->next_pic = NULL;
s->last_pic = NULL;
} }

74
libavcodec/error_resilience.h
Unescape View File

@ -0,0 +1,74 @@
/*
*
* This file is part of FFmpeg.
*
* FFmpeg 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.
*
* FFmpeg 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 FFmpeg; 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 */

2
libavcodec/h261dec.c
Unescape View File

@ -617,7 +617,7 @@ retry:
if(ff_MPV_frame_start(s, avctx) < 0) if(ff_MPV_frame_start(s, avctx) < 0)
return -1; return -1;
ff_er_frame_start(s); ff_mpeg_er_frame_start(s);
/* decode each macroblock */ /* decode each macroblock */
s->mb_x=0; s->mb_x=0;

20
libavcodec/h263dec.c
Unescape View File

@ -194,7 +194,7 @@ static int decode_slice(MpegEncContext *s){
/* per-row end of slice checks */ /* per-row end of slice checks */
if(s->msmpeg4_version){ if(s->msmpeg4_version){
if(s->resync_mb_y + s->slice_height == s->mb_y){ 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; return 0;
} }
@ -235,7 +235,7 @@ static int decode_slice(MpegEncContext *s){
if(s->loop_filter) if(s->loop_filter)
ff_h263_loop_filter(s); 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--; s->padding_bug_score--;
@ -248,11 +248,11 @@ static int decode_slice(MpegEncContext *s){
return 0; return 0;
}else if(ret==SLICE_NOEND){ }else if(ret==SLICE_NOEND){
av_log(s->avctx, AV_LOG_ERROR, "Slice mismatch at MB: %d\n", xy); 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 AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
av_log(s->avctx, AV_LOG_ERROR, "Error at MB: %d\n", xy); 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 AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
@ -331,7 +331,7 @@ static int decode_slice(MpegEncContext *s){
else if(left<0){ else if(left<0){
av_log(s->avctx, AV_LOG_ERROR, "overreading %d bits\n", -left); av_log(s->avctx, AV_LOG_ERROR, "overreading %d bits\n", -left);
}else }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; return 0;
} }
@ -340,7 +340,7 @@ static int decode_slice(MpegEncContext *s){
get_bits_left(&s->gb), get_bits_left(&s->gb),
show_bits(&s->gb, 24), s->padding_bug_score); 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 AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
@ -666,7 +666,7 @@ retry:
return ret; return ret;
} }
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 //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() //which is not available before ff_MPV_frame_start()
@ -690,7 +690,7 @@ retry:
if(ff_h263_resync(s)<0) if(ff_h263_resync(s)<0)
break; break;
if (prev_y * s->mb_width + prev_x < s->mb_y * s->mb_width + s->mb_x) 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) if(s->msmpeg4_version<4 && s->h263_pred)
@ -701,7 +701,7 @@ retry:
if (s->msmpeg4_version && s->msmpeg4_version<4 && s->pict_type==AV_PICTURE_TYPE_I) 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){ 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;
} }
av_assert1(s->bitstream_buffer_size==0); av_assert1(s->bitstream_buffer_size==0);
@ -734,7 +734,7 @@ frame_end:
} }
intrax8_decoded: intrax8_decoded:
ff_er_frame_end(s); ff_er_frame_end(&s->er);
if (avctx->hwaccel) { if (avctx->hwaccel) {
if ((ret = avctx->hwaccel->end_frame(avctx)) < 0) if ((ret = avctx->hwaccel->end_frame(avctx)) < 0)

75
libavcodec/h264.c
Unescape View File

@ -91,6 +91,42 @@ int avpriv_h264_has_num_reorder_frames(AVCodecContext *avctx)
return h ? h->sps.num_reorder_frames : 0; return h ? h->sps.num_reorder_frames : 0;
} }
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));
av_assert1(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;
if (!h->ref_list[0][ref].f.data[0]) {
av_log(s->avctx, AV_LOG_DEBUG, "Reference not available for error concealing\n");
ref = 0;
}
if ((h->ref_list[0][ref].f.reference&3) != 3) {
av_log(s->avctx, AV_LOG_DEBUG, "Reference invalid\n");
return;
}
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((*mv)[0][0][0], (*mv)[0][0][1]), 4);
h->mb_mbaff =
h->mb_field_decoding_flag = 0;
ff_h264_hl_decode_mb(h);
}
/** /**
* Check if the top & left blocks are available if needed and * Check if the top & left blocks are available if needed and
* change the dc mode so it only uses the available blocks. * change the dc mode so it only uses the available blocks.
@ -977,6 +1013,9 @@ static int context_init(H264Context *h)
h->ref_cache[1][scan8[7] + 1] = h->ref_cache[1][scan8[7] + 1] =
h->ref_cache[1][scan8[13] + 1] = PART_NOT_AVAILABLE; 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; return 0;
fail: fail:
@ -1355,7 +1394,8 @@ int ff_h264_frame_start(H264Context *h)
return -1; return -1;
if(!h->sync) if(!h->sync)
avpriv_color_frame(&h->s.current_picture_ptr->f, c); avpriv_color_frame(&h->s.current_picture_ptr->f, c);
ff_er_frame_start(s);
ff_mpeg_er_frame_start(s);
/* /*
* ff_MPV_frame_start uses pict_type to derive key_frame. * ff_MPV_frame_start uses pict_type to derive key_frame.
* This is incorrect for H.264; IDR markings must be used. * This is incorrect for H.264; IDR markings must be used.
@ -2378,7 +2418,7 @@ static int field_end(H264Context *h, int in_setup)
* causes problems for the first MB line, too. * causes problems for the first MB line, too.
*/ */
if (!FIELD_PICTURE && h->current_slice && !h->sps.new) if (!FIELD_PICTURE && h->current_slice && !h->sps.new)
ff_er_frame_end(s); ff_er_frame_end(&s->er);
ff_MPV_frame_end(s); ff_MPV_frame_end(s);
@ -3158,11 +3198,13 @@ static int decode_slice_header(H264Context *h, H264Context *h0)
if (h->slice_type_nos != AV_PICTURE_TYPE_I) { if (h->slice_type_nos != AV_PICTURE_TYPE_I) {
s->last_picture_ptr = &h->ref_list[0][0]; s->last_picture_ptr = &h->ref_list[0][0];
s->last_picture_ptr->owner2 = s; s->last_picture_ptr->owner2 = s;
s->er.last_pic = s->last_picture_ptr;
ff_copy_picture(&s->last_picture, s->last_picture_ptr); ff_copy_picture(&s->last_picture, s->last_picture_ptr);
} }
if (h->slice_type_nos == AV_PICTURE_TYPE_B) { if (h->slice_type_nos == AV_PICTURE_TYPE_B) {
s->next_picture_ptr = &h->ref_list[1][0]; s->next_picture_ptr = &h->ref_list[1][0];
s->next_picture_ptr->owner2 = s; s->next_picture_ptr->owner2 = s;
s->er.next_pic = s->next_picture_ptr;
ff_copy_picture(&s->next_picture, s->next_picture_ptr); ff_copy_picture(&s->next_picture, s->next_picture_ptr);
} }
@ -3734,6 +3776,15 @@ static void decode_finish_row(H264Context *h)
s->picture_structure == PICT_BOTTOM_FIELD); 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) static int decode_slice(struct AVCodecContext *avctx, void *arg)
{ {
H264Context *h = *(void **)arg; H264Context *h = *(void **)arg;
@ -3782,7 +3833,7 @@ static int decode_slice(struct AVCodecContext *avctx, void *arg)
if ((s->workaround_bugs & FF_BUG_TRUNCATED) && if ((s->workaround_bugs & FF_BUG_TRUNCATED) &&
h->cabac.bytestream > h->cabac.bytestream_end + 2) { 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); s->mb_y, ER_MB_END);
if (s->mb_x >= lf_x_start) if (s->mb_x >= lf_x_start)
loop_filter(h, lf_x_start, s->mb_x + 1); loop_filter(h, lf_x_start, s->mb_x + 1);
@ -3795,7 +3846,7 @@ static int decode_slice(struct AVCodecContext *avctx, void *arg)
"error while decoding MB %d %d, bytestream (%td)\n", "error while decoding MB %d %d, bytestream (%td)\n",
s->mb_x, s->mb_y, s->mb_x, s->mb_y,
h->cabac.bytestream_end - h->cabac.bytestream); 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); s->mb_y, ER_MB_ERROR);
return -1; return -1;
} }
@ -3815,7 +3866,7 @@ static int decode_slice(struct AVCodecContext *avctx, void *arg)
if (eos || s->mb_y >= s->mb_height) { if (eos || s->mb_y >= s->mb_height) {
tprintf(s->avctx, "slice end %d %d\n", tprintf(s->avctx, "slice end %d %d\n",
get_bits_count(&s->gb), s->gb.size_in_bits); 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); s->mb_y, ER_MB_END);
if (s->mb_x > lf_x_start) if (s->mb_x > lf_x_start)
loop_filter(h, lf_x_start, s->mb_x); loop_filter(h, lf_x_start, s->mb_x);
@ -3842,7 +3893,7 @@ static int decode_slice(struct AVCodecContext *avctx, void *arg)
if (ret < 0) { if (ret < 0) {
av_log(h->s.avctx, AV_LOG_ERROR, av_log(h->s.avctx, AV_LOG_ERROR,
"error while decoding MB %d %d\n", s->mb_x, s->mb_y); "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); s->mb_y, ER_MB_ERROR);
return -1; return -1;
} }
@ -3863,13 +3914,13 @@ static int decode_slice(struct AVCodecContext *avctx, void *arg)
if ( get_bits_left(&s->gb) == 0 if ( get_bits_left(&s->gb) == 0
|| get_bits_left(&s->gb) > 0 && !(s->avctx->err_recognition & AV_EF_AGGRESSIVE)) { || get_bits_left(&s->gb) > 0 && !(s->avctx->err_recognition & AV_EF_AGGRESSIVE)) {
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, s->mb_x - 1, s->mb_y,
ER_MB_END); ER_MB_END);
return 0; return 0;
} else { } 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, s->mb_y, s->mb_x, s->mb_y,
ER_MB_END); ER_MB_END);
@ -3882,7 +3933,7 @@ static int decode_slice(struct AVCodecContext *avctx, void *arg)
tprintf(s->avctx, "slice end %d %d\n", tprintf(s->avctx, "slice end %d %d\n",
get_bits_count(&s->gb), s->gb.size_in_bits); get_bits_count(&s->gb), s->gb.size_in_bits);
if (get_bits_left(&s->gb) == 0) { 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, s->mb_x - 1, s->mb_y,
ER_MB_END); ER_MB_END);
if (s->mb_x > lf_x_start) if (s->mb_x > lf_x_start)
@ -3890,7 +3941,7 @@ static int decode_slice(struct AVCodecContext *avctx, void *arg)
return 0; return 0;
} else { } 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); s->mb_y, ER_MB_ERROR);
return -1; return -1;
@ -3923,7 +3974,7 @@ static int execute_decode_slices(H264Context *h, int context_count)
for (i = 1; i < context_count; i++) { for (i = 1; i < context_count; i++) {
hx = h->thread_context[i]; hx = h->thread_context[i];
hx->s.err_recognition = avctx->err_recognition; hx->s.err_recognition = avctx->err_recognition;
hx->s.error_count = 0; hx->s.er.error_count = 0;
hx->x264_build = h->x264_build; hx->x264_build = h->x264_build;
} }
@ -3937,7 +3988,7 @@ static int execute_decode_slices(H264Context *h, int context_count)
s->droppable = hx->s.droppable; s->droppable = hx->s.droppable;
s->picture_structure = hx->s.picture_structure; s->picture_structure = hx->s.picture_structure;
for (i = 1; i < context_count; i++) 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; return 0;

2
libavcodec/intrax8.c
Unescape View File

@ -781,7 +781,7 @@ int ff_intrax8_decode_picture(IntraX8Context * const w, int dquant, int quant_of
} }
error: 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, (s->mb_x>>1)-1, (s->mb_y>>1)-1,
ER_MB_END ); ER_MB_END );
return 0; return 0;

20
libavcodec/mpeg12.c
Unescape View File

@ -1609,7 +1609,7 @@ static int mpeg_field_start(MpegEncContext *s, const uint8_t *buf, int buf_size)
if (ff_MPV_frame_start(s, avctx) < 0) if (ff_MPV_frame_start(s, avctx) < 0)
return -1; return -1;
ff_er_frame_start(s); ff_mpeg_er_frame_start(s);
/* first check if we must repeat the frame */ /* first check if we must repeat the frame */
s->current_picture_ptr->f.repeat_pict = 0; s->current_picture_ptr->f.repeat_pict = 0;
@ -1903,7 +1903,7 @@ static int slice_decode_thread(AVCodecContext *c, void *arg)
int mb_y = s->start_mb_y; int mb_y = s->start_mb_y;
const int field_pic = s->picture_structure != PICT_FRAME; 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 (;;) { for (;;) {
uint32_t start_code; uint32_t start_code;
@ -1913,14 +1913,14 @@ static int slice_decode_thread(AVCodecContext *c, void *arg)
emms_c(); emms_c();
av_dlog(c, "ret:%d resync:%d/%d mb:%d/%d ts:%d/%d ec:%d\n", 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, 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 (ret < 0) {
if (c->err_recognition & AV_EF_EXPLODE) if (c->err_recognition & AV_EF_EXPLODE)
return ret; return ret;
if (s->resync_mb_x >= 0 && s->resync_mb_y >= 0) 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 { } 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) if (s->mb_y == s->end_mb_y)
@ -1965,7 +1965,7 @@ static int slice_end(AVCodecContext *avctx, AVFrame *pict)
s->current_picture_ptr->f.qscale_type = FF_QSCALE_TYPE_MPEG2; 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); ff_MPV_frame_end(s);
@ -2273,7 +2273,7 @@ static int decode_chunks(AVCodecContext *avctx,
avctx->execute(avctx, slice_decode_thread, &s2->thread_context[0], NULL, s->slice_count, sizeof(void*)); avctx->execute(avctx, slice_decode_thread, &s2->thread_context[0], NULL, s->slice_count, sizeof(void*));
for (i = 0; i < s->slice_count; i++) 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_VDPAU && uses_vdpau(avctx)) if (CONFIG_VDPAU && uses_vdpau(avctx))
@ -2326,7 +2326,7 @@ static int decode_chunks(AVCodecContext *avctx,
s2->thread_context, NULL, s2->thread_context, NULL,
s->slice_count, sizeof(void*)); s->slice_count, sizeof(void*));
for (i = 0; i < s->slice_count; i++) 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; s->slice_count = 0;
} }
if (last_code == 0 || last_code == SLICE_MIN_START_CODE) { if (last_code == 0 || last_code == SLICE_MIN_START_CODE) {
@ -2515,9 +2515,9 @@ static int decode_chunks(AVCodecContext *avctx,
if (avctx->err_recognition & AV_EF_EXPLODE) if (avctx->err_recognition & AV_EF_EXPLODE)
return ret; return ret;
if (s2->resync_mb_x >= 0 && s2->resync_mb_y >= 0) 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 { } 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);
} }
} }
} }

10
libavcodec/mpeg4videodec.c
Unescape View File

@ -798,13 +798,13 @@ int ff_mpeg4_decode_partitions(MpegEncContext *s)
mb_num= mpeg4_decode_partition_a(s); mb_num= mpeg4_decode_partition_a(s);
if(mb_num<0){ 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; return -1;
} }
if(s->resync_mb_x + s->resync_mb_y*s->mb_width + mb_num > s->mb_num){ 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"); 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; return -1;
} }
@ -825,15 +825,15 @@ int ff_mpeg4_decode_partitions(MpegEncContext *s)
return -1; 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( mpeg4_decode_partition_b(s, mb_num) < 0){
if(s->pict_type==AV_PICTURE_TYPE_P) 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; return -1;
}else{ }else{
if(s->pict_type==AV_PICTURE_TYPE_P) 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; return 0;

98
libavcodec/mpegvideo.c
Unescape View File

@ -145,6 +145,33 @@ const enum AVPixelFormat ff_hwaccel_pixfmt_list_420[] = {
AV_PIX_FMT_NONE 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 *av_restrict p, const uint8_t *avpriv_mpv_find_start_code(const uint8_t *av_restrict p,
const uint8_t *end, const uint8_t *end,
uint32_t *av_restrict state) uint32_t *av_restrict state)
@ -734,6 +761,43 @@ void ff_MPV_decode_defaults(MpegEncContext *s)
ff_MPV_common_defaults(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. * Initialize and allocates MpegEncContext fields dependent on the resolution.
*/ */
@ -800,12 +864,8 @@ static int init_context_frame(MpegEncContext *s)
} }
FF_ALLOC_OR_GOTO(s->avctx, s->er_temp_buffer, if (s->codec_id == AV_CODEC_ID_MPEG4 ||
mb_array_size * sizeof(uint8_t), fail); (s->flags & CODEC_FLAG_INTERLACED_ME)) {
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 */ /* interlaced direct mode decoding tables */
for (i = 0; i < 2; i++) { for (i = 0; i < 2; i++) {
int j, k; int j, k;
@ -854,7 +914,7 @@ static int init_context_frame(MpegEncContext *s)
FF_ALLOCZ_OR_GOTO(s->avctx, s->mbskip_table, mb_array_size + 2, fail); FF_ALLOCZ_OR_GOTO(s->avctx, s->mbskip_table, mb_array_size + 2, fail);
// Note the + 1 is for a quicker mpeg4 slice_end detection // Note the + 1 is for a quicker mpeg4 slice_end detection
return 0; return init_er(s);
fail: fail:
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
} }
@ -1023,8 +1083,8 @@ static int free_context_frame(MpegEncContext *s)
av_freep(&s->mbskip_table); av_freep(&s->mbskip_table);
av_freep(&s->error_status_table); av_freep(&s->er.error_status_table);
av_freep(&s->er_temp_buffer); av_freep(&s->er.er_temp_buffer);
av_freep(&s->mb_index2xy); av_freep(&s->mb_index2xy);
av_freep(&s->lambda_table); av_freep(&s->lambda_table);
@ -1595,7 +1655,7 @@ void ff_MPV_frame_end(MpegEncContext *s)
// just to make sure that all data is rendered. // just to make sure that all data is rendered.
if (CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration) { if (CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration) {
ff_xvmc_field_end(s); ff_xvmc_field_end(s);
} else if((s->error_count || s->encoding || !(s->avctx->codec->capabilities&CODEC_CAP_DRAW_HORIZ_BAND)) && } else if ((s->er.error_count || s->encoding || !(s->avctx->codec->capabilities&CODEC_CAP_DRAW_HORIZ_BAND)) &&
!s->avctx->hwaccel && !s->avctx->hwaccel &&
!(s->avctx->codec->capabilities & CODEC_CAP_HWACCEL_VDPAU) && !(s->avctx->codec->capabilities & CODEC_CAP_HWACCEL_VDPAU) &&
s->unrestricted_mv && s->unrestricted_mv &&
@ -3164,6 +3224,22 @@ void ff_set_qscale(MpegEncContext * s, int qscale)
void ff_MPV_report_decode_progress(MpegEncContext *s) 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); 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);
}

23
libavcodec/mpegvideo.h
Unescape View File

@ -30,6 +30,7 @@
#include "avcodec.h" #include "avcodec.h"
#include "dsputil.h" #include "dsputil.h"
#include "error_resilience.h"
#include "get_bits.h" #include "get_bits.h"
#include "h264chroma.h" #include "h264chroma.h"
#include "put_bits.h" #include "put_bits.h"
@ -494,19 +495,6 @@ typedef struct MpegEncContext {
int last_bits; ///< temp var used for calculating the above vars int last_bits; ///< temp var used for calculating the above vars
/* error concealment / resync */ /* 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_x; ///< x position of last resync marker
int resync_mb_y; ///< y 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 GetBitContext last_resync_gb; ///< used to search for the next resync marker
@ -715,15 +703,14 @@ typedef struct MpegEncContext {
int mpv_flags; ///< flags set by private options int mpv_flags; ///< flags set by private options
int quantizer_noise_shaping; int quantizer_noise_shaping;
/* error resilience stuff */
uint8_t *er_temp_buffer;
/* temp buffers for rate control */ /* temp buffers for rate control */
float *cplx_tab, *bits_tab; float *cplx_tab, *bits_tab;
/* flag to indicate a reinitialization is required, e.g. after /* flag to indicate a reinitialization is required, e.g. after
* a frame size change */ * a frame size change */
int context_reinit; int context_reinit;
ERContext er;
} MpegEncContext; } MpegEncContext;
#define REBASE_PICTURE(pic, new_ctx, old_ctx) \ #define REBASE_PICTURE(pic, new_ctx, old_ctx) \
@ -801,9 +788,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); 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_set_qscale(MpegEncContext * s, int qscale);
void ff_er_frame_start(MpegEncContext *s); void ff_mpeg_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);
int ff_dct_common_init(MpegEncContext *s); int ff_dct_common_init(MpegEncContext *s);
int ff_dct_encode_init(MpegEncContext *s); int ff_dct_encode_init(MpegEncContext *s);

2
libavcodec/mpegvideo_enc.c
Unescape View File

@ -3172,7 +3172,7 @@ static void merge_context_after_encode(MpegEncContext *dst, MpegEncContext *src)
MERGE(b_count); MERGE(b_count);
MERGE(skip_count); MERGE(skip_count);
MERGE(misc_bits); MERGE(misc_bits);
MERGE(error_count); MERGE(er.error_count);
MERGE(padding_bug_score); MERGE(padding_bug_score);
MERGE(current_picture.f.error[0]); MERGE(current_picture.f.error[0]);
MERGE(current_picture.f.error[1]); MERGE(current_picture.f.error[1]);

4
libavcodec/mss2.c
Unescape View File

@ -406,7 +406,7 @@ static int decode_wmv9(AVCodecContext *avctx, const uint8_t *buf, int buf_size,
return ret; return ret;
} }
ff_er_frame_start(s); ff_mpeg_er_frame_start(s);
v->bits = buf_size * 8; 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_vc1_decode_blocks(v);
ff_er_frame_end(s); ff_er_frame_end(&s->er);
ff_MPV_frame_end(s); ff_MPV_frame_end(s);

8
libavcodec/rv10.c
Unescape View File

@ -561,13 +561,13 @@ static int rv10_decode_packet(AVCodecContext *avctx,
if ((s->mb_x == 0 && s->mb_y == 0) || s->current_picture_ptr==NULL) { 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? 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); ff_MPV_frame_end(s);
s->mb_x= s->mb_y = s->resync_mb_x = s->resync_mb_y= 0; s->mb_x= s->mb_y = s->resync_mb_x = s->resync_mb_y= 0;
} }
if(ff_MPV_frame_start(s, avctx) < 0) if(ff_MPV_frame_start(s, avctx) < 0)
return -1; return -1;
ff_er_frame_start(s); ff_mpeg_er_frame_start(s);
} else { } else {
if (s->current_picture_ptr->f.pict_type != s->pict_type) { if (s->current_picture_ptr->f.pict_type != s->pict_type) {
av_log(s->avctx, AV_LOG_ERROR, "Slice type mismatch\n"); av_log(s->avctx, AV_LOG_ERROR, "Slice type mismatch\n");
@ -660,7 +660,7 @@ static int rv10_decode_packet(AVCodecContext *avctx,
if(ret == SLICE_END) break; 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; return active_bits_size;
} }
@ -733,7 +733,7 @@ static int rv10_decode_frame(AVCodecContext *avctx,
} }
if(s->current_picture_ptr != NULL && s->mb_y>=s->mb_height){ 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); ff_MPV_frame_end(s);
if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) { if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {

12
libavcodec/rv34.c
Unescape View File

@ -1433,7 +1433,7 @@ static int rv34_decode_slice(RV34DecContext *r, int end, const uint8_t* buf, int
else else
res = rv34_decode_intra_macroblock(r, r->intra_types + s->mb_x * 4 + 4); res = rv34_decode_intra_macroblock(r, r->intra_types + s->mb_x * 4 + 4);
if(res < 0){ 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; return -1;
} }
if (++s->mb_x == s->mb_width) { if (++s->mb_x == s->mb_width) {
@ -1456,7 +1456,7 @@ static int rv34_decode_slice(RV34DecContext *r, int end, const uint8_t* buf, int
s->first_slice_line=0; s->first_slice_line=0;
s->mb_num_left--; 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; return s->mb_y == s->mb_height;
} }
@ -1569,7 +1569,7 @@ static int finish_frame(AVCodecContext *avctx, AVFrame *pict)
MpegEncContext *s = &r->s; MpegEncContext *s = &r->s;
int got_picture = 0; int got_picture = 0;
ff_er_frame_end(s); ff_er_frame_end(&s->er);
ff_MPV_frame_end(s); ff_MPV_frame_end(s);
s->mb_num_left = 0; s->mb_num_left = 0;
@ -1651,7 +1651,7 @@ int ff_rv34_decode_frame(AVCodecContext *avctx,
if (s->mb_num_left > 0) { if (s->mb_num_left > 0) {
av_log(avctx, AV_LOG_ERROR, "New frame but still %d MB left.\n", av_log(avctx, AV_LOG_ERROR, "New frame but still %d MB left.\n",
s->mb_num_left); s->mb_num_left);
ff_er_frame_end(s); ff_er_frame_end(&s->er);
ff_MPV_frame_end(s); ff_MPV_frame_end(s);
} }
@ -1675,7 +1675,7 @@ int ff_rv34_decode_frame(AVCodecContext *avctx,
s->pict_type = si.type ? si.type : AV_PICTURE_TYPE_I; s->pict_type = si.type ? si.type : AV_PICTURE_TYPE_I;
if (ff_MPV_frame_start(s, s->avctx) < 0) if (ff_MPV_frame_start(s, s->avctx) < 0)
return -1; return -1;
ff_er_frame_start(s); ff_mpeg_er_frame_start(s);
if (!r->tmp_b_block_base) { if (!r->tmp_b_block_base) {
int i; int i;
@ -1774,7 +1774,7 @@ int ff_rv34_decode_frame(AVCodecContext *avctx,
av_log(avctx, AV_LOG_INFO, "marking unfished frame as finished\n"); av_log(avctx, AV_LOG_INFO, "marking unfished frame as finished\n");
/* always mark the current frame as finished, frame-mt supports /* always mark the current frame as finished, frame-mt supports
* only complete frames */ * only complete frames */
ff_er_frame_end(s); ff_er_frame_end(&s->er);
ff_MPV_frame_end(s); ff_MPV_frame_end(s);
s->mb_num_left = 0; s->mb_num_left = 0;
ff_thread_report_progress(&s->current_picture_ptr->f, INT_MAX, 0); ff_thread_report_progress(&s->current_picture_ptr->f, INT_MAX, 0);

24
libavcodec/vc1dec.c
Unescape View File

@ -4447,7 +4447,7 @@ static void vc1_decode_i_blocks(VC1Context *v)
if (v->s.loop_filter) vc1_loop_filter_iblk(v, v->pq); if (v->s.loop_filter) vc1_loop_filter_iblk(v, v->pq);
if (get_bits_count(&s->gb) > v->bits) { 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", av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i\n",
get_bits_count(&s->gb), v->bits); get_bits_count(&s->gb), v->bits);
return; return;
@ -4465,7 +4465,7 @@ static void vc1_decode_i_blocks(VC1Context *v)
/* This is intentionally mb_height and not end_mb_y - unlike in advanced /* This is intentionally mb_height and not end_mb_y - unlike in advanced
* profile, these only differ are when decoding MSS2 rectangles. */ * 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 /** Decode blocks of I-frame for advanced profile
@ -4575,7 +4575,7 @@ static void vc1_decode_i_blocks_adv(VC1Context *v)
if (get_bits_count(&s->gb) > v->bits) { if (get_bits_count(&s->gb) > v->bits) {
// TODO: may need modification to handle slice coding // 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", av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i\n",
get_bits_count(&s->gb), v->bits); get_bits_count(&s->gb), v->bits);
return; return;
@ -4600,7 +4600,7 @@ static void vc1_decode_i_blocks_adv(VC1Context *v)
} }
if (v->s.loop_filter) if (v->s.loop_filter)
ff_draw_horiz_band(s, (s->end_mb_y-1)*16, 16); 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); (s->end_mb_y << v->field_mode) - 1, ER_MB_END);
} }
@ -4652,7 +4652,7 @@ static void vc1_decode_p_blocks(VC1Context *v)
vc1_apply_p_loop_filter(v); vc1_apply_p_loop_filter(v);
if (get_bits_count(&s->gb) > v->bits || get_bits_count(&s->gb) < 0) { if (get_bits_count(&s->gb) > v->bits || get_bits_count(&s->gb) < 0) {
// TODO: may need modification to handle slice coding // 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", 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); get_bits_count(&s->gb), v->bits, s->mb_x, s->mb_y);
return; return;
@ -4675,7 +4675,7 @@ static void vc1_decode_p_blocks(VC1Context *v)
} }
if (s->end_mb_y >= s->start_mb_y) if (s->end_mb_y >= s->start_mb_y)
ff_draw_horiz_band(s, (s->end_mb_y - 1) * 16, 16); 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); (s->end_mb_y << v->field_mode) - 1, ER_MB_END);
} }
@ -4721,7 +4721,7 @@ static void vc1_decode_b_blocks(VC1Context *v)
vc1_decode_b_mb(v); vc1_decode_b_mb(v);
if (get_bits_count(&s->gb) > v->bits || get_bits_count(&s->gb) < 0) { if (get_bits_count(&s->gb) > v->bits || get_bits_count(&s->gb) < 0) {
// TODO: may need modification to handle slice coding // 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", 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); get_bits_count(&s->gb), v->bits, s->mb_x, s->mb_y);
return; return;
@ -4736,7 +4736,7 @@ static void vc1_decode_b_blocks(VC1Context *v)
} }
if (v->s.loop_filter) if (v->s.loop_filter)
ff_draw_horiz_band(s, (s->end_mb_y - 1) * 16, 16); 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); (s->end_mb_y << v->field_mode) - 1, ER_MB_END);
} }
@ -4744,7 +4744,7 @@ static void vc1_decode_skip_blocks(VC1Context *v)
{ {
MpegEncContext *s = &v->s; 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; s->first_slice_line = 1;
for (s->mb_y = s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) { for (s->mb_y = s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
s->mb_x = 0; s->mb_x = 0;
@ -5643,7 +5643,7 @@ static int vc1_decode_frame(AVCodecContext *avctx, void *data,
if (v->fcm == ILACE_FRAME && s->pict_type == AV_PICTURE_TYPE_B) if (v->fcm == ILACE_FRAME && s->pict_type == AV_PICTURE_TYPE_B)
goto err; // This codepath is still incomplete thus it is disabled goto err; // This codepath is still incomplete thus it is disabled
ff_er_frame_start(s); ff_mpeg_er_frame_start(s);
v->bits = buf_size * 8; v->bits = buf_size * 8;
v->end_mb_x = s->mb_width; v->end_mb_x = s->mb_width;
@ -5733,10 +5733,10 @@ static int vc1_decode_frame(AVCodecContext *avctx, void *data,
get_bits_count(&s->gb), s->gb.size_in_bits); get_bits_count(&s->gb), s->gb.size_in_bits);
// if (get_bits_count(&s->gb) > buf_size * 8) // if (get_bits_count(&s->gb) > buf_size * 8)
// return -1; // return -1;
if(s->error_occurred && s->pict_type == AV_PICTURE_TYPE_B) if(s->er.error_occurred && s->pict_type == AV_PICTURE_TYPE_B)
goto err; goto err;
if(!v->field_mode) if(!v->field_mode)
ff_er_frame_end(s); ff_er_frame_end(&s->er);
} }
ff_MPV_frame_end(s); ff_MPV_frame_end(s);

Write Preview
Loading…
Cancel
Save