Replace ASMALIGN() with .p2align
[ffmpeg.git] / libavcodec / error_resilience.c
1 /*
2  * Error resilience / concealment
3  *
4  * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
5  *
6  * This file is part of FFmpeg.
7  *
8  * FFmpeg is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * FFmpeg is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with FFmpeg; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  */
22
23 /**
24  * @file
25  * Error resilience / concealment.
26  */
27
28 #include <limits.h>
29
30 #include "avcodec.h"
31 #include "dsputil.h"
32 #include "mpegvideo.h"
33 #include "h264.h"
34 #include "rectangle.h"
35
36 /*
37  * H264 redefines mb_intra so it is not mistakely used (its uninitialized in h264)
38  * but error concealment must support both h264 and h263 thus we must undo this
39  */
40 #undef mb_intra
41
42 static void decode_mb(MpegEncContext *s, int ref){
43     s->dest[0] = s->current_picture.data[0] + (s->mb_y * 16* s->linesize  ) + s->mb_x * 16;
44     s->dest[1] = s->current_picture.data[1] + (s->mb_y * (16>>s->chroma_y_shift) * s->uvlinesize) + s->mb_x * (16>>s->chroma_x_shift);
45     s->dest[2] = s->current_picture.data[2] + (s->mb_y * (16>>s->chroma_y_shift) * s->uvlinesize) + s->mb_x * (16>>s->chroma_x_shift);
46
47     if(CONFIG_H264_DECODER && s->codec_id == CODEC_ID_H264){
48         H264Context *h= (void*)s;
49         h->mb_xy= s->mb_x + s->mb_y*s->mb_stride;
50         memset(h->non_zero_count_cache, 0, sizeof(h->non_zero_count_cache));
51         assert(ref>=0);
52         if(ref >= h->ref_count[0]) //FIXME it is posible albeit uncommon that slice references differ between slices, we take the easy approuch and ignore it for now. If this turns out to have any relevance in practice then correct remapping should be added
53             ref=0;
54         fill_rectangle(&s->current_picture.ref_index[0][4*h->mb_xy], 2, 2, 2, ref, 1);
55         fill_rectangle(&h->ref_cache[0][scan8[0]], 4, 4, 8, ref, 1);
56         fill_rectangle(h->mv_cache[0][ scan8[0] ], 4, 4, 8, pack16to32(s->mv[0][0][0],s->mv[0][0][1]), 4);
57         assert(!FRAME_MBAFF);
58         ff_h264_hl_decode_mb(h);
59     }else{
60         assert(ref==0);
61     MPV_decode_mb(s, s->block);
62     }
63 }
64
65 /**
66  * @param stride the number of MVs to get to the next row
67  * @param mv_step the number of MVs per row or column in a macroblock
68  */
69 static void set_mv_strides(MpegEncContext *s, int *mv_step, int *stride){
70     if(s->codec_id == CODEC_ID_H264){
71         H264Context *h= (void*)s;
72         assert(s->quarter_sample);
73         *mv_step= 4;
74         *stride= h->b_stride;
75     }else{
76         *mv_step= 2;
77         *stride= s->b8_stride;
78     }
79 }
80
81 /**
82  * replaces the current MB with a flat dc only version.
83  */
84 static void put_dc(MpegEncContext *s, uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, int mb_x, int mb_y)
85 {
86     int dc, dcu, dcv, y, i;
87     for(i=0; i<4; i++){
88         dc= s->dc_val[0][mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*s->b8_stride];
89         if(dc<0) dc=0;
90         else if(dc>2040) dc=2040;
91         for(y=0; y<8; y++){
92             int x;
93             for(x=0; x<8; x++){
94                 dest_y[x + (i&1)*8 + (y + (i>>1)*8)*s->linesize]= dc/8;
95             }
96         }
97     }
98     dcu = s->dc_val[1][mb_x + mb_y*s->mb_stride];
99     dcv = s->dc_val[2][mb_x + mb_y*s->mb_stride];
100     if     (dcu<0   ) dcu=0;
101     else if(dcu>2040) dcu=2040;
102     if     (dcv<0   ) dcv=0;
103     else if(dcv>2040) dcv=2040;
104     for(y=0; y<8; y++){
105         int x;
106         for(x=0; x<8; x++){
107             dest_cb[x + y*(s->uvlinesize)]= dcu/8;
108             dest_cr[x + y*(s->uvlinesize)]= dcv/8;
109         }
110     }
111 }
112
113 static void filter181(int16_t *data, int width, int height, int stride){
114     int x,y;
115
116     /* horizontal filter */
117     for(y=1; y<height-1; y++){
118         int prev_dc= data[0 + y*stride];
119
120         for(x=1; x<width-1; x++){
121             int dc;
122
123             dc= - prev_dc
124                 + data[x     + y*stride]*8
125                 - data[x + 1 + y*stride];
126             dc= (dc*10923 + 32768)>>16;
127             prev_dc= data[x + y*stride];
128             data[x + y*stride]= dc;
129         }
130     }
131
132     /* vertical filter */
133     for(x=1; x<width-1; x++){
134         int prev_dc= data[x];
135
136         for(y=1; y<height-1; y++){
137             int dc;
138
139             dc= - prev_dc
140                 + data[x +  y   *stride]*8
141                 - data[x + (y+1)*stride];
142             dc= (dc*10923 + 32768)>>16;
143             prev_dc= data[x + y*stride];
144             data[x + y*stride]= dc;
145         }
146     }
147 }
148
149 /**
150  * guess the dc of blocks which do not have an undamaged dc
151  * @param w     width in 8 pixel blocks
152  * @param h     height in 8 pixel blocks
153  */
154 static void guess_dc(MpegEncContext *s, int16_t *dc, int w, int h, int stride, int is_luma){
155     int b_x, b_y;
156
157     for(b_y=0; b_y<h; b_y++){
158         for(b_x=0; b_x<w; b_x++){
159             int color[4]={1024,1024,1024,1024};
160             int distance[4]={9999,9999,9999,9999};
161             int mb_index, error, j;
162             int64_t guess, weight_sum;
163
164             mb_index= (b_x>>is_luma) + (b_y>>is_luma)*s->mb_stride;
165
166             error= s->error_status_table[mb_index];
167
168             if(IS_INTER(s->current_picture.mb_type[mb_index])) continue; //inter
169             if(!(error&DC_ERROR)) continue;           //dc-ok
170
171             /* right block */
172             for(j=b_x+1; j<w; j++){
173                 int mb_index_j= (j>>is_luma) + (b_y>>is_luma)*s->mb_stride;
174                 int error_j= s->error_status_table[mb_index_j];
175                 int intra_j= IS_INTRA(s->current_picture.mb_type[mb_index_j]);
176                 if(intra_j==0 || !(error_j&DC_ERROR)){
177                     color[0]= dc[j + b_y*stride];
178                     distance[0]= j-b_x;
179                     break;
180                 }
181             }
182
183             /* left block */
184             for(j=b_x-1; j>=0; j--){
185                 int mb_index_j= (j>>is_luma) + (b_y>>is_luma)*s->mb_stride;
186                 int error_j= s->error_status_table[mb_index_j];
187                 int intra_j= IS_INTRA(s->current_picture.mb_type[mb_index_j]);
188                 if(intra_j==0 || !(error_j&DC_ERROR)){
189                     color[1]= dc[j + b_y*stride];
190                     distance[1]= b_x-j;
191                     break;
192                 }
193             }
194
195             /* bottom block */
196             for(j=b_y+1; j<h; j++){
197                 int mb_index_j= (b_x>>is_luma) + (j>>is_luma)*s->mb_stride;
198                 int error_j= s->error_status_table[mb_index_j];
199                 int intra_j= IS_INTRA(s->current_picture.mb_type[mb_index_j]);
200                 if(intra_j==0 || !(error_j&DC_ERROR)){
201                     color[2]= dc[b_x + j*stride];
202                     distance[2]= j-b_y;
203                     break;
204                 }
205             }
206
207             /* top block */
208             for(j=b_y-1; j>=0; j--){
209                 int mb_index_j= (b_x>>is_luma) + (j>>is_luma)*s->mb_stride;
210                 int error_j= s->error_status_table[mb_index_j];
211                 int intra_j= IS_INTRA(s->current_picture.mb_type[mb_index_j]);
212                 if(intra_j==0 || !(error_j&DC_ERROR)){
213                     color[3]= dc[b_x + j*stride];
214                     distance[3]= b_y-j;
215                     break;
216                 }
217             }
218
219             weight_sum=0;
220             guess=0;
221             for(j=0; j<4; j++){
222                 int64_t weight= 256*256*256*16/distance[j];
223                 guess+= weight*(int64_t)color[j];
224                 weight_sum+= weight;
225             }
226             guess= (guess + weight_sum/2) / weight_sum;
227
228             dc[b_x + b_y*stride]= guess;
229         }
230     }
231 }
232
233 /**
234  * simple horizontal deblocking filter used for error resilience
235  * @param w     width in 8 pixel blocks
236  * @param h     height in 8 pixel blocks
237  */
238 static void h_block_filter(MpegEncContext *s, uint8_t *dst, int w, int h, int stride, int is_luma){
239     int b_x, b_y, mvx_stride, mvy_stride;
240     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
241     set_mv_strides(s, &mvx_stride, &mvy_stride);
242     mvx_stride >>= is_luma;
243     mvy_stride *= mvx_stride;
244
245     for(b_y=0; b_y<h; b_y++){
246         for(b_x=0; b_x<w-1; b_x++){
247             int y;
248             int left_status = s->error_status_table[( b_x   >>is_luma) + (b_y>>is_luma)*s->mb_stride];
249             int right_status= s->error_status_table[((b_x+1)>>is_luma) + (b_y>>is_luma)*s->mb_stride];
250             int left_intra=   IS_INTRA(s->current_picture.mb_type      [( b_x   >>is_luma) + (b_y>>is_luma)*s->mb_stride]);
251             int right_intra=  IS_INTRA(s->current_picture.mb_type      [((b_x+1)>>is_luma) + (b_y>>is_luma)*s->mb_stride]);
252             int left_damage =  left_status&(DC_ERROR|AC_ERROR|MV_ERROR);
253             int right_damage= right_status&(DC_ERROR|AC_ERROR|MV_ERROR);
254             int offset= b_x*8 + b_y*stride*8;
255             int16_t *left_mv=  s->current_picture.motion_val[0][mvy_stride*b_y + mvx_stride* b_x   ];
256             int16_t *right_mv= s->current_picture.motion_val[0][mvy_stride*b_y + mvx_stride*(b_x+1)];
257
258             if(!(left_damage||right_damage)) continue; // both undamaged
259
260             if(   (!left_intra) && (!right_intra)
261                && FFABS(left_mv[0]-right_mv[0]) + FFABS(left_mv[1]+right_mv[1]) < 2) continue;
262
263             for(y=0; y<8; y++){
264                 int a,b,c,d;
265
266                 a= dst[offset + 7 + y*stride] - dst[offset + 6 + y*stride];
267                 b= dst[offset + 8 + y*stride] - dst[offset + 7 + y*stride];
268                 c= dst[offset + 9 + y*stride] - dst[offset + 8 + y*stride];
269
270                 d= FFABS(b) - ((FFABS(a) + FFABS(c) + 1)>>1);
271                 d= FFMAX(d, 0);
272                 if(b<0) d= -d;
273
274                 if(d==0) continue;
275
276                 if(!(left_damage && right_damage))
277                     d= d*16/9;
278
279                 if(left_damage){
280                     dst[offset + 7 + y*stride] = cm[dst[offset + 7 + y*stride] + ((d*7)>>4)];
281                     dst[offset + 6 + y*stride] = cm[dst[offset + 6 + y*stride] + ((d*5)>>4)];
282                     dst[offset + 5 + y*stride] = cm[dst[offset + 5 + y*stride] + ((d*3)>>4)];
283                     dst[offset + 4 + y*stride] = cm[dst[offset + 4 + y*stride] + ((d*1)>>4)];
284                 }
285                 if(right_damage){
286                     dst[offset + 8 + y*stride] = cm[dst[offset + 8 + y*stride] - ((d*7)>>4)];
287                     dst[offset + 9 + y*stride] = cm[dst[offset + 9 + y*stride] - ((d*5)>>4)];
288                     dst[offset + 10+ y*stride] = cm[dst[offset +10 + y*stride] - ((d*3)>>4)];
289                     dst[offset + 11+ y*stride] = cm[dst[offset +11 + y*stride] - ((d*1)>>4)];
290                 }
291             }
292         }
293     }
294 }
295
296 /**
297  * simple vertical deblocking filter used for error resilience
298  * @param w     width in 8 pixel blocks
299  * @param h     height in 8 pixel blocks
300  */
301 static void v_block_filter(MpegEncContext *s, uint8_t *dst, int w, int h, int stride, int is_luma){
302     int b_x, b_y, mvx_stride, mvy_stride;
303     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
304     set_mv_strides(s, &mvx_stride, &mvy_stride);
305     mvx_stride >>= is_luma;
306     mvy_stride *= mvx_stride;
307
308     for(b_y=0; b_y<h-1; b_y++){
309         for(b_x=0; b_x<w; b_x++){
310             int x;
311             int top_status   = s->error_status_table[(b_x>>is_luma) + ( b_y   >>is_luma)*s->mb_stride];
312             int bottom_status= s->error_status_table[(b_x>>is_luma) + ((b_y+1)>>is_luma)*s->mb_stride];
313             int top_intra=     IS_INTRA(s->current_picture.mb_type      [(b_x>>is_luma) + ( b_y   >>is_luma)*s->mb_stride]);
314             int bottom_intra=  IS_INTRA(s->current_picture.mb_type      [(b_x>>is_luma) + ((b_y+1)>>is_luma)*s->mb_stride]);
315             int top_damage =      top_status&(DC_ERROR|AC_ERROR|MV_ERROR);
316             int bottom_damage= bottom_status&(DC_ERROR|AC_ERROR|MV_ERROR);
317             int offset= b_x*8 + b_y*stride*8;
318             int16_t *top_mv=    s->current_picture.motion_val[0][mvy_stride* b_y    + mvx_stride*b_x];
319             int16_t *bottom_mv= s->current_picture.motion_val[0][mvy_stride*(b_y+1) + mvx_stride*b_x];
320
321             if(!(top_damage||bottom_damage)) continue; // both undamaged
322
323             if(   (!top_intra) && (!bottom_intra)
324                && FFABS(top_mv[0]-bottom_mv[0]) + FFABS(top_mv[1]+bottom_mv[1]) < 2) continue;
325
326             for(x=0; x<8; x++){
327                 int a,b,c,d;
328
329                 a= dst[offset + x + 7*stride] - dst[offset + x + 6*stride];
330                 b= dst[offset + x + 8*stride] - dst[offset + x + 7*stride];
331                 c= dst[offset + x + 9*stride] - dst[offset + x + 8*stride];
332
333                 d= FFABS(b) - ((FFABS(a) + FFABS(c)+1)>>1);
334                 d= FFMAX(d, 0);
335                 if(b<0) d= -d;
336
337                 if(d==0) continue;
338
339                 if(!(top_damage && bottom_damage))
340                     d= d*16/9;
341
342                 if(top_damage){
343                     dst[offset + x +  7*stride] = cm[dst[offset + x +  7*stride] + ((d*7)>>4)];
344                     dst[offset + x +  6*stride] = cm[dst[offset + x +  6*stride] + ((d*5)>>4)];
345                     dst[offset + x +  5*stride] = cm[dst[offset + x +  5*stride] + ((d*3)>>4)];
346                     dst[offset + x +  4*stride] = cm[dst[offset + x +  4*stride] + ((d*1)>>4)];
347                 }
348                 if(bottom_damage){
349                     dst[offset + x +  8*stride] = cm[dst[offset + x +  8*stride] - ((d*7)>>4)];
350                     dst[offset + x +  9*stride] = cm[dst[offset + x +  9*stride] - ((d*5)>>4)];
351                     dst[offset + x + 10*stride] = cm[dst[offset + x + 10*stride] - ((d*3)>>4)];
352                     dst[offset + x + 11*stride] = cm[dst[offset + x + 11*stride] - ((d*1)>>4)];
353                 }
354             }
355         }
356     }
357 }
358
359 static void guess_mv(MpegEncContext *s){
360     uint8_t fixed[s->mb_stride * s->mb_height];
361 #define MV_FROZEN    3
362 #define MV_CHANGED   2
363 #define MV_UNCHANGED 1
364     const int mb_stride = s->mb_stride;
365     const int mb_width = s->mb_width;
366     const int mb_height= s->mb_height;
367     int i, depth, num_avail;
368     int mb_x, mb_y, mot_step, mot_stride;
369
370     set_mv_strides(s, &mot_step, &mot_stride);
371
372     num_avail=0;
373     for(i=0; i<s->mb_num; i++){
374         const int mb_xy= s->mb_index2xy[ i ];
375         int f=0;
376         int error= s->error_status_table[mb_xy];
377
378         if(IS_INTRA(s->current_picture.mb_type[mb_xy])) f=MV_FROZEN; //intra //FIXME check
379         if(!(error&MV_ERROR)) f=MV_FROZEN;           //inter with undamaged MV
380
381         fixed[mb_xy]= f;
382         if(f==MV_FROZEN)
383             num_avail++;
384     }
385
386     if((!(s->avctx->error_concealment&FF_EC_GUESS_MVS)) || num_avail <= mb_width/2){
387         for(mb_y=0; mb_y<s->mb_height; mb_y++){
388             for(mb_x=0; mb_x<s->mb_width; mb_x++){
389                 const int mb_xy= mb_x + mb_y*s->mb_stride;
390
391                 if(IS_INTRA(s->current_picture.mb_type[mb_xy]))  continue;
392                 if(!(s->error_status_table[mb_xy]&MV_ERROR)) continue;
393
394                 s->mv_dir = s->last_picture.data[0] ? MV_DIR_FORWARD : MV_DIR_BACKWARD;
395                 s->mb_intra=0;
396                 s->mv_type = MV_TYPE_16X16;
397                 s->mb_skipped=0;
398
399                 s->dsp.clear_blocks(s->block[0]);
400
401                 s->mb_x= mb_x;
402                 s->mb_y= mb_y;
403                 s->mv[0][0][0]= 0;
404                 s->mv[0][0][1]= 0;
405                 decode_mb(s, 0);
406             }
407         }
408         return;
409     }
410
411     for(depth=0;; depth++){
412         int changed, pass, none_left;
413
414         none_left=1;
415         changed=1;
416         for(pass=0; (changed || pass<2) && pass<10; pass++){
417             int mb_x, mb_y;
418 int score_sum=0;
419
420             changed=0;
421             for(mb_y=0; mb_y<s->mb_height; mb_y++){
422                 for(mb_x=0; mb_x<s->mb_width; mb_x++){
423                     const int mb_xy= mb_x + mb_y*s->mb_stride;
424                     int mv_predictor[8][2]={{0}};
425                     int ref[8]={0};
426                     int pred_count=0;
427                     int j;
428                     int best_score=256*256*256*64;
429                     int best_pred=0;
430                     const int mot_index= (mb_x + mb_y*mot_stride) * mot_step;
431                     int prev_x= s->current_picture.motion_val[0][mot_index][0];
432                     int prev_y= s->current_picture.motion_val[0][mot_index][1];
433
434                     if((mb_x^mb_y^pass)&1) continue;
435
436                     if(fixed[mb_xy]==MV_FROZEN) continue;
437                     assert(!IS_INTRA(s->current_picture.mb_type[mb_xy]));
438                     assert(s->last_picture_ptr && s->last_picture_ptr->data[0]);
439
440                     j=0;
441                     if(mb_x>0           && fixed[mb_xy-1        ]==MV_FROZEN) j=1;
442                     if(mb_x+1<mb_width  && fixed[mb_xy+1        ]==MV_FROZEN) j=1;
443                     if(mb_y>0           && fixed[mb_xy-mb_stride]==MV_FROZEN) j=1;
444                     if(mb_y+1<mb_height && fixed[mb_xy+mb_stride]==MV_FROZEN) j=1;
445                     if(j==0) continue;
446
447                     j=0;
448                     if(mb_x>0           && fixed[mb_xy-1        ]==MV_CHANGED) j=1;
449                     if(mb_x+1<mb_width  && fixed[mb_xy+1        ]==MV_CHANGED) j=1;
450                     if(mb_y>0           && fixed[mb_xy-mb_stride]==MV_CHANGED) j=1;
451                     if(mb_y+1<mb_height && fixed[mb_xy+mb_stride]==MV_CHANGED) j=1;
452                     if(j==0 && pass>1) continue;
453
454                     none_left=0;
455
456                     if(mb_x>0 && fixed[mb_xy-1]){
457                         mv_predictor[pred_count][0]= s->current_picture.motion_val[0][mot_index - mot_step][0];
458                         mv_predictor[pred_count][1]= s->current_picture.motion_val[0][mot_index - mot_step][1];
459                         ref         [pred_count]   = s->current_picture.ref_index[0][4*(mb_xy-1)];
460                         pred_count++;
461                     }
462                     if(mb_x+1<mb_width && fixed[mb_xy+1]){
463                         mv_predictor[pred_count][0]= s->current_picture.motion_val[0][mot_index + mot_step][0];
464                         mv_predictor[pred_count][1]= s->current_picture.motion_val[0][mot_index + mot_step][1];
465                         ref         [pred_count]   = s->current_picture.ref_index[0][4*(mb_xy+1)];
466                         pred_count++;
467                     }
468                     if(mb_y>0 && fixed[mb_xy-mb_stride]){
469                         mv_predictor[pred_count][0]= s->current_picture.motion_val[0][mot_index - mot_stride*mot_step][0];
470                         mv_predictor[pred_count][1]= s->current_picture.motion_val[0][mot_index - mot_stride*mot_step][1];
471                         ref         [pred_count]   = s->current_picture.ref_index[0][4*(mb_xy-s->mb_stride)];
472                         pred_count++;
473                     }
474                     if(mb_y+1<mb_height && fixed[mb_xy+mb_stride]){
475                         mv_predictor[pred_count][0]= s->current_picture.motion_val[0][mot_index + mot_stride*mot_step][0];
476                         mv_predictor[pred_count][1]= s->current_picture.motion_val[0][mot_index + mot_stride*mot_step][1];
477                         ref         [pred_count]   = s->current_picture.ref_index[0][4*(mb_xy+s->mb_stride)];
478                         pred_count++;
479                     }
480                     if(pred_count==0) continue;
481
482                     if(pred_count>1){
483                         int sum_x=0, sum_y=0, sum_r=0;
484                         int max_x, max_y, min_x, min_y, max_r, min_r;
485
486                         for(j=0; j<pred_count; j++){
487                             sum_x+= mv_predictor[j][0];
488                             sum_y+= mv_predictor[j][1];
489                             sum_r+= ref[j];
490                             if(j && ref[j] != ref[j-1])
491                                 goto skip_mean_and_median;
492                         }
493
494                         /* mean */
495                         mv_predictor[pred_count][0] = sum_x/j;
496                         mv_predictor[pred_count][1] = sum_y/j;
497                         ref         [pred_count]    = sum_r/j;
498
499                         /* median */
500                         if(pred_count>=3){
501                             min_y= min_x= min_r= 99999;
502                             max_y= max_x= max_r=-99999;
503                         }else{
504                             min_x=min_y=max_x=max_y=min_r=max_r=0;
505                         }
506                         for(j=0; j<pred_count; j++){
507                             max_x= FFMAX(max_x, mv_predictor[j][0]);
508                             max_y= FFMAX(max_y, mv_predictor[j][1]);
509                             max_r= FFMAX(max_r, ref[j]);
510                             min_x= FFMIN(min_x, mv_predictor[j][0]);
511                             min_y= FFMIN(min_y, mv_predictor[j][1]);
512                             min_r= FFMIN(min_r, ref[j]);
513                         }
514                         mv_predictor[pred_count+1][0] = sum_x - max_x - min_x;
515                         mv_predictor[pred_count+1][1] = sum_y - max_y - min_y;
516                         ref         [pred_count+1]    = sum_r - max_r - min_r;
517
518                         if(pred_count==4){
519                             mv_predictor[pred_count+1][0] /= 2;
520                             mv_predictor[pred_count+1][1] /= 2;
521                             ref         [pred_count+1]    /= 2;
522                         }
523                         pred_count+=2;
524                     }
525 skip_mean_and_median:
526
527                     /* zero MV */
528                     pred_count++;
529
530                     /* last MV */
531                     mv_predictor[pred_count][0]= s->current_picture.motion_val[0][mot_index][0];
532                     mv_predictor[pred_count][1]= s->current_picture.motion_val[0][mot_index][1];
533                     ref         [pred_count]   = s->current_picture.ref_index[0][4*mb_xy];
534                     pred_count++;
535
536                     s->mv_dir = MV_DIR_FORWARD;
537                     s->mb_intra=0;
538                     s->mv_type = MV_TYPE_16X16;
539                     s->mb_skipped=0;
540
541                     s->dsp.clear_blocks(s->block[0]);
542
543                     s->mb_x= mb_x;
544                     s->mb_y= mb_y;
545
546                     for(j=0; j<pred_count; j++){
547                         int score=0;
548                         uint8_t *src= s->current_picture.data[0] + mb_x*16 + mb_y*16*s->linesize;
549
550                         s->current_picture.motion_val[0][mot_index][0]= s->mv[0][0][0]= mv_predictor[j][0];
551                         s->current_picture.motion_val[0][mot_index][1]= s->mv[0][0][1]= mv_predictor[j][1];
552
553                         if(ref[j]<0) //predictor intra or otherwise not available
554                             continue;
555
556                         decode_mb(s, ref[j]);
557
558                         if(mb_x>0 && fixed[mb_xy-1]){
559                             int k;
560                             for(k=0; k<16; k++)
561                                 score += FFABS(src[k*s->linesize-1 ]-src[k*s->linesize   ]);
562                         }
563                         if(mb_x+1<mb_width && fixed[mb_xy+1]){
564                             int k;
565                             for(k=0; k<16; k++)
566                                 score += FFABS(src[k*s->linesize+15]-src[k*s->linesize+16]);
567                         }
568                         if(mb_y>0 && fixed[mb_xy-mb_stride]){
569                             int k;
570                             for(k=0; k<16; k++)
571                                 score += FFABS(src[k-s->linesize   ]-src[k               ]);
572                         }
573                         if(mb_y+1<mb_height && fixed[mb_xy+mb_stride]){
574                             int k;
575                             for(k=0; k<16; k++)
576                                 score += FFABS(src[k+s->linesize*15]-src[k+s->linesize*16]);
577                         }
578
579                         if(score <= best_score){ // <= will favor the last MV
580                             best_score= score;
581                             best_pred= j;
582                         }
583                     }
584 score_sum+= best_score;
585                     s->mv[0][0][0]= mv_predictor[best_pred][0];
586                     s->mv[0][0][1]= mv_predictor[best_pred][1];
587
588                     for(i=0; i<mot_step; i++)
589                         for(j=0; j<mot_step; j++){
590                             s->current_picture.motion_val[0][mot_index+i+j*mot_stride][0]= s->mv[0][0][0];
591                             s->current_picture.motion_val[0][mot_index+i+j*mot_stride][1]= s->mv[0][0][1];
592                         }
593
594                     decode_mb(s, ref[best_pred]);
595
596
597                     if(s->mv[0][0][0] != prev_x || s->mv[0][0][1] != prev_y){
598                         fixed[mb_xy]=MV_CHANGED;
599                         changed++;
600                     }else
601                         fixed[mb_xy]=MV_UNCHANGED;
602                 }
603             }
604
605 //            printf(".%d/%d", changed, score_sum); fflush(stdout);
606         }
607
608         if(none_left)
609             return;
610
611         for(i=0; i<s->mb_num; i++){
612             int mb_xy= s->mb_index2xy[i];
613             if(fixed[mb_xy])
614                 fixed[mb_xy]=MV_FROZEN;
615         }
616 //        printf(":"); fflush(stdout);
617     }
618 }
619
620 static int is_intra_more_likely(MpegEncContext *s){
621     int is_intra_likely, i, j, undamaged_count, skip_amount, mb_x, mb_y;
622
623     if(!s->last_picture_ptr || !s->last_picture_ptr->data[0]) return 1; //no previous frame available -> use spatial prediction
624
625     undamaged_count=0;
626     for(i=0; i<s->mb_num; i++){
627         const int mb_xy= s->mb_index2xy[i];
628         const int error= s->error_status_table[mb_xy];
629         if(!((error&DC_ERROR) && (error&MV_ERROR)))
630             undamaged_count++;
631     }
632
633     if(s->codec_id == CODEC_ID_H264){
634         H264Context *h= (void*)s;
635         if(h->ref_count[0] <= 0 || !h->ref_list[0][0].data[0])
636             return 1;
637     }
638
639     if(undamaged_count < 5) return 0; //almost all MBs damaged -> use temporal prediction
640
641     //prevent dsp.sad() check, that requires access to the image
642     if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration && s->pict_type == FF_I_TYPE)
643         return 1;
644
645     skip_amount= FFMAX(undamaged_count/50, 1); //check only upto 50 MBs
646     is_intra_likely=0;
647
648     j=0;
649     for(mb_y= 0; mb_y<s->mb_height-1; mb_y++){
650         for(mb_x= 0; mb_x<s->mb_width; mb_x++){
651             int error;
652             const int mb_xy= mb_x + mb_y*s->mb_stride;
653
654             error= s->error_status_table[mb_xy];
655             if((error&DC_ERROR) && (error&MV_ERROR))
656                 continue; //skip damaged
657
658             j++;
659             if((j%skip_amount) != 0) continue; //skip a few to speed things up
660
661             if(s->pict_type==FF_I_TYPE){
662                 uint8_t *mb_ptr     = s->current_picture.data[0] + mb_x*16 + mb_y*16*s->linesize;
663                 uint8_t *last_mb_ptr= s->last_picture.data   [0] + mb_x*16 + mb_y*16*s->linesize;
664
665                 is_intra_likely += s->dsp.sad[0](NULL, last_mb_ptr, mb_ptr                    , s->linesize, 16);
666                 is_intra_likely -= s->dsp.sad[0](NULL, last_mb_ptr, last_mb_ptr+s->linesize*16, s->linesize, 16);
667             }else{
668                 if(IS_INTRA(s->current_picture.mb_type[mb_xy]))
669                    is_intra_likely++;
670                 else
671                    is_intra_likely--;
672             }
673         }
674     }
675 //printf("is_intra_likely: %d type:%d\n", is_intra_likely, s->pict_type);
676     return is_intra_likely > 0;
677 }
678
679 void ff_er_frame_start(MpegEncContext *s){
680     if(!s->error_recognition) return;
681
682     memset(s->error_status_table, MV_ERROR|AC_ERROR|DC_ERROR|VP_START|AC_END|DC_END|MV_END, s->mb_stride*s->mb_height*sizeof(uint8_t));
683     s->error_count= 3*s->mb_num;
684 }
685
686 /**
687  * adds a slice.
688  * @param endx x component of the last macroblock, can be -1 for the last of the previous line
689  * @param status the status at the end (MV_END, AC_ERROR, ...), it is assumed that no earlier end or
690  *               error of the same type occurred
691  */
692 void ff_er_add_slice(MpegEncContext *s, int startx, int starty, int endx, int endy, int status){
693     const int start_i= av_clip(startx + starty * s->mb_width    , 0, s->mb_num-1);
694     const int end_i  = av_clip(endx   + endy   * s->mb_width    , 0, s->mb_num);
695     const int start_xy= s->mb_index2xy[start_i];
696     const int end_xy  = s->mb_index2xy[end_i];
697     int mask= -1;
698
699     if(s->avctx->hwaccel)
700         return;
701
702     if(start_i > end_i || start_xy > end_xy){
703         av_log(s->avctx, AV_LOG_ERROR, "internal error, slice end before start\n");
704         return;
705     }
706
707     if(!s->error_recognition) return;
708
709     mask &= ~VP_START;
710     if(status & (AC_ERROR|AC_END)){
711         mask &= ~(AC_ERROR|AC_END);
712         s->error_count -= end_i - start_i + 1;
713     }
714     if(status & (DC_ERROR|DC_END)){
715         mask &= ~(DC_ERROR|DC_END);
716         s->error_count -= end_i - start_i + 1;
717     }
718     if(status & (MV_ERROR|MV_END)){
719         mask &= ~(MV_ERROR|MV_END);
720         s->error_count -= end_i - start_i + 1;
721     }
722
723     if(status & (AC_ERROR|DC_ERROR|MV_ERROR)) s->error_count= INT_MAX;
724
725     if(mask == ~0x7F){
726         memset(&s->error_status_table[start_xy], 0, (end_xy - start_xy) * sizeof(uint8_t));
727     }else{
728         int i;
729         for(i=start_xy; i<end_xy; i++){
730             s->error_status_table[ i ] &= mask;
731         }
732     }
733
734     if(end_i == s->mb_num)
735         s->error_count= INT_MAX;
736     else{
737         s->error_status_table[end_xy] &= mask;
738         s->error_status_table[end_xy] |= status;
739     }
740
741     s->error_status_table[start_xy] |= VP_START;
742
743     if(start_xy > 0 && s->avctx->thread_count <= 1 && s->avctx->skip_top*s->mb_width < start_i){
744         int prev_status= s->error_status_table[ s->mb_index2xy[start_i - 1] ];
745
746         prev_status &= ~ VP_START;
747         if(prev_status != (MV_END|DC_END|AC_END)) s->error_count= INT_MAX;
748     }
749 }
750
751 void ff_er_frame_end(MpegEncContext *s){
752     int i, mb_x, mb_y, error, error_type, dc_error, mv_error, ac_error;
753     int distance;
754     int threshold_part[4]= {100,100,100};
755     int threshold= 50;
756     int is_intra_likely;
757     int size = s->b8_stride * 2 * s->mb_height;
758     Picture *pic= s->current_picture_ptr;
759
760     if(!s->error_recognition || s->error_count==0 || s->avctx->lowres ||
761        s->avctx->hwaccel ||
762        s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU ||
763        s->picture_structure != PICT_FRAME || // we dont support ER of field pictures yet, though it should not crash if enabled
764        s->error_count==3*s->mb_width*(s->avctx->skip_top + s->avctx->skip_bottom)) return;
765
766     if(s->current_picture.motion_val[0] == NULL){
767         av_log(s->avctx, AV_LOG_ERROR, "Warning MVs not available\n");
768
769         for(i=0; i<2; i++){
770             pic->ref_index[i]= av_mallocz(s->mb_stride * s->mb_height * 4 * sizeof(uint8_t));
771             pic->motion_val_base[i]= av_mallocz((size+4) * 2 * sizeof(uint16_t));
772             pic->motion_val[i]= pic->motion_val_base[i]+4;
773         }
774         pic->motion_subsample_log2= 3;
775         s->current_picture= *s->current_picture_ptr;
776     }
777
778     if(s->avctx->debug&FF_DEBUG_ER){
779         for(mb_y=0; mb_y<s->mb_height; mb_y++){
780             for(mb_x=0; mb_x<s->mb_width; mb_x++){
781                 int status= s->error_status_table[mb_x + mb_y*s->mb_stride];
782
783                 av_log(s->avctx, AV_LOG_DEBUG, "%2X ", status);
784             }
785             av_log(s->avctx, AV_LOG_DEBUG, "\n");
786         }
787     }
788
789 #if 1
790     /* handle overlapping slices */
791     for(error_type=1; error_type<=3; error_type++){
792         int end_ok=0;
793
794         for(i=s->mb_num-1; i>=0; i--){
795             const int mb_xy= s->mb_index2xy[i];
796             int error= s->error_status_table[mb_xy];
797
798             if(error&(1<<error_type))
799                 end_ok=1;
800             if(error&(8<<error_type))
801                 end_ok=1;
802
803             if(!end_ok)
804                 s->error_status_table[mb_xy]|= 1<<error_type;
805
806             if(error&VP_START)
807                 end_ok=0;
808         }
809     }
810 #endif
811 #if 1
812     /* handle slices with partitions of different length */
813     if(s->partitioned_frame){
814         int end_ok=0;
815
816         for(i=s->mb_num-1; i>=0; i--){
817             const int mb_xy= s->mb_index2xy[i];
818             int error= s->error_status_table[mb_xy];
819
820             if(error&AC_END)
821                 end_ok=0;
822             if((error&MV_END) || (error&DC_END) || (error&AC_ERROR))
823                 end_ok=1;
824
825             if(!end_ok)
826                 s->error_status_table[mb_xy]|= AC_ERROR;
827
828             if(error&VP_START)
829                 end_ok=0;
830         }
831     }
832 #endif
833     /* handle missing slices */
834     if(s->error_recognition>=4){
835         int end_ok=1;
836
837         for(i=s->mb_num-2; i>=s->mb_width+100; i--){ //FIXME +100 hack
838             const int mb_xy= s->mb_index2xy[i];
839             int error1= s->error_status_table[mb_xy  ];
840             int error2= s->error_status_table[s->mb_index2xy[i+1]];
841
842             if(error1&VP_START)
843                 end_ok=1;
844
845             if(   error2==(VP_START|DC_ERROR|AC_ERROR|MV_ERROR|AC_END|DC_END|MV_END)
846                && error1!=(VP_START|DC_ERROR|AC_ERROR|MV_ERROR|AC_END|DC_END|MV_END)
847                && ((error1&AC_END) || (error1&DC_END) || (error1&MV_END))){ //end & uninit
848                 end_ok=0;
849             }
850
851             if(!end_ok)
852                 s->error_status_table[mb_xy]|= DC_ERROR|AC_ERROR|MV_ERROR;
853         }
854     }
855
856 #if 1
857     /* backward mark errors */
858     distance=9999999;
859     for(error_type=1; error_type<=3; error_type++){
860         for(i=s->mb_num-1; i>=0; i--){
861             const int mb_xy= s->mb_index2xy[i];
862             int error= s->error_status_table[mb_xy];
863
864             if(!s->mbskip_table[mb_xy]) //FIXME partition specific
865                 distance++;
866             if(error&(1<<error_type))
867                 distance= 0;
868
869             if(s->partitioned_frame){
870                 if(distance < threshold_part[error_type-1])
871                     s->error_status_table[mb_xy]|= 1<<error_type;
872             }else{
873                 if(distance < threshold)
874                     s->error_status_table[mb_xy]|= 1<<error_type;
875             }
876
877             if(error&VP_START)
878                 distance= 9999999;
879         }
880     }
881 #endif
882
883     /* forward mark errors */
884     error=0;
885     for(i=0; i<s->mb_num; i++){
886         const int mb_xy= s->mb_index2xy[i];
887         int old_error= s->error_status_table[mb_xy];
888
889         if(old_error&VP_START)
890             error= old_error& (DC_ERROR|AC_ERROR|MV_ERROR);
891         else{
892             error|= old_error& (DC_ERROR|AC_ERROR|MV_ERROR);
893             s->error_status_table[mb_xy]|= error;
894         }
895     }
896 #if 1
897     /* handle not partitioned case */
898     if(!s->partitioned_frame){
899         for(i=0; i<s->mb_num; i++){
900             const int mb_xy= s->mb_index2xy[i];
901             error= s->error_status_table[mb_xy];
902             if(error&(AC_ERROR|DC_ERROR|MV_ERROR))
903                 error|= AC_ERROR|DC_ERROR|MV_ERROR;
904             s->error_status_table[mb_xy]= error;
905         }
906     }
907 #endif
908
909     dc_error= ac_error= mv_error=0;
910     for(i=0; i<s->mb_num; i++){
911         const int mb_xy= s->mb_index2xy[i];
912         error= s->error_status_table[mb_xy];
913         if(error&DC_ERROR) dc_error ++;
914         if(error&AC_ERROR) ac_error ++;
915         if(error&MV_ERROR) mv_error ++;
916     }
917     av_log(s->avctx, AV_LOG_INFO, "concealing %d DC, %d AC, %d MV errors\n", dc_error, ac_error, mv_error);
918
919     is_intra_likely= is_intra_more_likely(s);
920
921     /* set unknown mb-type to most likely */
922     for(i=0; i<s->mb_num; i++){
923         const int mb_xy= s->mb_index2xy[i];
924         error= s->error_status_table[mb_xy];
925         if(!((error&DC_ERROR) && (error&MV_ERROR)))
926             continue;
927
928         if(is_intra_likely)
929             s->current_picture.mb_type[mb_xy]= MB_TYPE_INTRA4x4;
930         else
931             s->current_picture.mb_type[mb_xy]= MB_TYPE_16x16 | MB_TYPE_L0;
932     }
933
934     // change inter to intra blocks if no reference frames are available
935     if (!s->last_picture.data[0] && !s->next_picture.data[0])
936         for(i=0; i<s->mb_num; i++){
937             const int mb_xy= s->mb_index2xy[i];
938             if(!IS_INTRA(s->current_picture.mb_type[mb_xy]))
939                 s->current_picture.mb_type[mb_xy]= MB_TYPE_INTRA4x4;
940         }
941
942     /* handle inter blocks with damaged AC */
943     for(mb_y=0; mb_y<s->mb_height; mb_y++){
944         for(mb_x=0; mb_x<s->mb_width; mb_x++){
945             const int mb_xy= mb_x + mb_y * s->mb_stride;
946             const int mb_type= s->current_picture.mb_type[mb_xy];
947             int dir = !s->last_picture.data[0];
948             error= s->error_status_table[mb_xy];
949
950             if(IS_INTRA(mb_type)) continue; //intra
951             if(error&MV_ERROR) continue;              //inter with damaged MV
952             if(!(error&AC_ERROR)) continue;           //undamaged inter
953
954             s->mv_dir = dir ? MV_DIR_BACKWARD : MV_DIR_FORWARD;
955             s->mb_intra=0;
956             s->mb_skipped=0;
957             if(IS_8X8(mb_type)){
958                 int mb_index= mb_x*2 + mb_y*2*s->b8_stride;
959                 int j;
960                 s->mv_type = MV_TYPE_8X8;
961                 for(j=0; j<4; j++){
962                     s->mv[0][j][0] = s->current_picture.motion_val[dir][ mb_index + (j&1) + (j>>1)*s->b8_stride ][0];
963                     s->mv[0][j][1] = s->current_picture.motion_val[dir][ mb_index + (j&1) + (j>>1)*s->b8_stride ][1];
964                 }
965             }else{
966                 s->mv_type = MV_TYPE_16X16;
967                 s->mv[0][0][0] = s->current_picture.motion_val[dir][ mb_x*2 + mb_y*2*s->b8_stride ][0];
968                 s->mv[0][0][1] = s->current_picture.motion_val[dir][ mb_x*2 + mb_y*2*s->b8_stride ][1];
969             }
970
971             s->dsp.clear_blocks(s->block[0]);
972
973             s->mb_x= mb_x;
974             s->mb_y= mb_y;
975             decode_mb(s, 0/*FIXME h264 partitioned slices need this set*/);
976         }
977     }
978
979     /* guess MVs */
980     if(s->pict_type==FF_B_TYPE){
981         for(mb_y=0; mb_y<s->mb_height; mb_y++){
982             for(mb_x=0; mb_x<s->mb_width; mb_x++){
983                 int xy= mb_x*2 + mb_y*2*s->b8_stride;
984                 const int mb_xy= mb_x + mb_y * s->mb_stride;
985                 const int mb_type= s->current_picture.mb_type[mb_xy];
986                 error= s->error_status_table[mb_xy];
987
988                 if(IS_INTRA(mb_type)) continue;
989                 if(!(error&MV_ERROR)) continue;           //inter with undamaged MV
990                 if(!(error&AC_ERROR)) continue;           //undamaged inter
991
992                 s->mv_dir = MV_DIR_FORWARD|MV_DIR_BACKWARD;
993                 if(!s->last_picture.data[0]) s->mv_dir &= ~MV_DIR_FORWARD;
994                 if(!s->next_picture.data[0]) s->mv_dir &= ~MV_DIR_BACKWARD;
995                 s->mb_intra=0;
996                 s->mv_type = MV_TYPE_16X16;
997                 s->mb_skipped=0;
998
999                 if(s->pp_time){
1000                     int time_pp= s->pp_time;
1001                     int time_pb= s->pb_time;
1002
1003                     s->mv[0][0][0] = s->next_picture.motion_val[0][xy][0]*time_pb/time_pp;
1004                     s->mv[0][0][1] = s->next_picture.motion_val[0][xy][1]*time_pb/time_pp;
1005                     s->mv[1][0][0] = s->next_picture.motion_val[0][xy][0]*(time_pb - time_pp)/time_pp;
1006                     s->mv[1][0][1] = s->next_picture.motion_val[0][xy][1]*(time_pb - time_pp)/time_pp;
1007                 }else{
1008                     s->mv[0][0][0]= 0;
1009                     s->mv[0][0][1]= 0;
1010                     s->mv[1][0][0]= 0;
1011                     s->mv[1][0][1]= 0;
1012                 }
1013
1014                 s->dsp.clear_blocks(s->block[0]);
1015                 s->mb_x= mb_x;
1016                 s->mb_y= mb_y;
1017                 decode_mb(s, 0);
1018             }
1019         }
1020     }else
1021         guess_mv(s);
1022
1023     /* the filters below are not XvMC compatible, skip them */
1024     if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration)
1025         goto ec_clean;
1026     /* fill DC for inter blocks */
1027     for(mb_y=0; mb_y<s->mb_height; mb_y++){
1028         for(mb_x=0; mb_x<s->mb_width; mb_x++){
1029             int dc, dcu, dcv, y, n;
1030             int16_t *dc_ptr;
1031             uint8_t *dest_y, *dest_cb, *dest_cr;
1032             const int mb_xy= mb_x + mb_y * s->mb_stride;
1033             const int mb_type= s->current_picture.mb_type[mb_xy];
1034
1035             error= s->error_status_table[mb_xy];
1036
1037             if(IS_INTRA(mb_type) && s->partitioned_frame) continue;
1038 //            if(error&MV_ERROR) continue; //inter data damaged FIXME is this good?
1039
1040             dest_y = s->current_picture.data[0] + mb_x*16 + mb_y*16*s->linesize;
1041             dest_cb= s->current_picture.data[1] + mb_x*8  + mb_y*8 *s->uvlinesize;
1042             dest_cr= s->current_picture.data[2] + mb_x*8  + mb_y*8 *s->uvlinesize;
1043
1044             dc_ptr= &s->dc_val[0][mb_x*2 + mb_y*2*s->b8_stride];
1045             for(n=0; n<4; n++){
1046                 dc=0;
1047                 for(y=0; y<8; y++){
1048                     int x;
1049                     for(x=0; x<8; x++){
1050                        dc+= dest_y[x + (n&1)*8 + (y + (n>>1)*8)*s->linesize];
1051                     }
1052                 }
1053                 dc_ptr[(n&1) + (n>>1)*s->b8_stride]= (dc+4)>>3;
1054             }
1055
1056             dcu=dcv=0;
1057             for(y=0; y<8; y++){
1058                 int x;
1059                 for(x=0; x<8; x++){
1060                     dcu+=dest_cb[x + y*(s->uvlinesize)];
1061                     dcv+=dest_cr[x + y*(s->uvlinesize)];
1062                 }
1063             }
1064             s->dc_val[1][mb_x + mb_y*s->mb_stride]= (dcu+4)>>3;
1065             s->dc_val[2][mb_x + mb_y*s->mb_stride]= (dcv+4)>>3;
1066         }
1067     }
1068 #if 1
1069     /* guess DC for damaged blocks */
1070     guess_dc(s, s->dc_val[0], s->mb_width*2, s->mb_height*2, s->b8_stride, 1);
1071     guess_dc(s, s->dc_val[1], s->mb_width  , s->mb_height  , s->mb_stride, 0);
1072     guess_dc(s, s->dc_val[2], s->mb_width  , s->mb_height  , s->mb_stride, 0);
1073 #endif
1074     /* filter luma DC */
1075     filter181(s->dc_val[0], s->mb_width*2, s->mb_height*2, s->b8_stride);
1076
1077 #if 1
1078     /* render DC only intra */
1079     for(mb_y=0; mb_y<s->mb_height; mb_y++){
1080         for(mb_x=0; mb_x<s->mb_width; mb_x++){
1081             uint8_t *dest_y, *dest_cb, *dest_cr;
1082             const int mb_xy= mb_x + mb_y * s->mb_stride;
1083             const int mb_type= s->current_picture.mb_type[mb_xy];
1084
1085             error= s->error_status_table[mb_xy];
1086
1087             if(IS_INTER(mb_type)) continue;
1088             if(!(error&AC_ERROR)) continue;              //undamaged
1089
1090             dest_y = s->current_picture.data[0] + mb_x*16 + mb_y*16*s->linesize;
1091             dest_cb= s->current_picture.data[1] + mb_x*8  + mb_y*8 *s->uvlinesize;
1092             dest_cr= s->current_picture.data[2] + mb_x*8  + mb_y*8 *s->uvlinesize;
1093
1094             put_dc(s, dest_y, dest_cb, dest_cr, mb_x, mb_y);
1095         }
1096     }
1097 #endif
1098
1099     if(s->avctx->error_concealment&FF_EC_DEBLOCK){
1100         /* filter horizontal block boundaries */
1101         h_block_filter(s, s->current_picture.data[0], s->mb_width*2, s->mb_height*2, s->linesize  , 1);
1102         h_block_filter(s, s->current_picture.data[1], s->mb_width  , s->mb_height  , s->uvlinesize, 0);
1103         h_block_filter(s, s->current_picture.data[2], s->mb_width  , s->mb_height  , s->uvlinesize, 0);
1104
1105         /* filter vertical block boundaries */
1106         v_block_filter(s, s->current_picture.data[0], s->mb_width*2, s->mb_height*2, s->linesize  , 1);
1107         v_block_filter(s, s->current_picture.data[1], s->mb_width  , s->mb_height  , s->uvlinesize, 0);
1108         v_block_filter(s, s->current_picture.data[2], s->mb_width  , s->mb_height  , s->uvlinesize, 0);
1109     }
1110
1111 ec_clean:
1112     /* clean a few tables */
1113     for(i=0; i<s->mb_num; i++){
1114         const int mb_xy= s->mb_index2xy[i];
1115         int error= s->error_status_table[mb_xy];
1116
1117         if(s->pict_type!=FF_B_TYPE && (error&(DC_ERROR|MV_ERROR|AC_ERROR))){
1118             s->mbskip_table[mb_xy]=0;
1119         }
1120         s->mbintra_table[mb_xy]=1;
1121     }
1122 }