falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
31707 Commits
32 Branches
301MB
Tree: 014f8d8106
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '014f8d8106'
${ noResults }
FFmpeg/libavcodec/error_resilience.c

1156 lines
45KB
Raw Blame History 

  1. /*

  2.  * Error resilience / concealment

  3.  *

  4.  * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>

  5.  *

  6.  * This file is part of Libav.

  7.  *

  8.  * Libav 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.  * Libav 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 Libav; 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. #include "thread.h"

  36. 

  37. /*

  38.  * H264 redefines mb_intra so it is not mistakely used (its uninitialized in h264)

  39.  * but error concealment must support both h264 and h263 thus we must undo this

  40.  */

  41. #undef mb_intra

  42. 

  43. static void decode_mb(MpegEncContext *s, int ref){

  44.     s->dest[0] = s->current_picture.f.data[0] + (s->mb_y *  16 * s->linesize)                         + s->mb_x *  16;

  45.     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);

  46.     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);

  47. 

  48.     if(CONFIG_H264_DECODER && s->codec_id == CODEC_ID_H264){

  49.         H264Context *h= (void*)s;

  50.         h->mb_xy= s->mb_x + s->mb_y*s->mb_stride;

  51.         memset(h->non_zero_count_cache, 0, sizeof(h->non_zero_count_cache));

  52.         assert(ref>=0);

  53.         /* FIXME: It is posible albeit uncommon that slice references

  54.          * differ between slices. We take the easy approach and ignore

  55.          * it for now. If this turns out to have any relevance in

  56.          * practice then correct remapping should be added. */

  57.         if (ref >= h->ref_count[0])

  58.             ref=0;

  59.         fill_rectangle(&s->current_picture.f.ref_index[0][4*h->mb_xy], 2, 2, 2, ref, 1);

  60.         fill_rectangle(&h->ref_cache[0][scan8[0]], 4, 4, 8, ref, 1);

  61.         fill_rectangle(h->mv_cache[0][ scan8[0] ], 4, 4, 8, pack16to32(s->mv[0][0][0],s->mv[0][0][1]), 4);

  62.         assert(!FRAME_MBAFF);

  63.         ff_h264_hl_decode_mb(h);

  64.     }else{

  65.         assert(ref==0);

  66.     MPV_decode_mb(s, s->block);

  67.     }

  68. }

  69. 

  70. /**

  71.  * @param stride the number of MVs to get to the next row

  72.  * @param mv_step the number of MVs per row or column in a macroblock

  73.  */

  74. static void set_mv_strides(MpegEncContext *s, int *mv_step, int *stride){

  75.     if(s->codec_id == CODEC_ID_H264){

  76.         H264Context *h= (void*)s;

  77.         assert(s->quarter_sample);

  78.         *mv_step= 4;

  79.         *stride= h->b_stride;

  80.     }else{

  81.         *mv_step= 2;

  82.         *stride= s->b8_stride;

  83.     }

  84. }

  85. 

  86. /**

  87.  * Replace the current MB with a flat dc-only version.

  88.  */

  89. static void put_dc(MpegEncContext *s, uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, int mb_x, int mb_y)

  90. {

  91.     int dc, dcu, dcv, y, i;

  92.     for(i=0; i<4; i++){

  93.         dc= s->dc_val[0][mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*s->b8_stride];

  94.         if(dc<0) dc=0;

  95.         else if(dc>2040) dc=2040;

  96.         for(y=0; y<8; y++){

  97.             int x;

  98.             for(x=0; x<8; x++){

  99.                 dest_y[x + (i&1)*8 + (y + (i>>1)*8)*s->linesize]= dc/8;

  100.             }

  101.         }

  102.     }

  103.     dcu = s->dc_val[1][mb_x + mb_y*s->mb_stride];

  104.     dcv = s->dc_val[2][mb_x + mb_y*s->mb_stride];

  105.     if     (dcu<0   ) dcu=0;

  106.     else if(dcu>2040) dcu=2040;

  107.     if     (dcv<0   ) dcv=0;

  108.     else if(dcv>2040) dcv=2040;

  109.     for(y=0; y<8; y++){

  110.         int x;

  111.         for(x=0; x<8; x++){

  112.             dest_cb[x + y * s->uvlinesize] = dcu / 8;

  113.             dest_cr[x + y * s->uvlinesize] = dcv / 8;

  114.         }

  115.     }

  116. }

  117. 

  118. static void filter181(int16_t *data, int width, int height, int stride){

  119.     int x,y;

  120. 

  121.     /* horizontal filter */

  122.     for(y=1; y<height-1; y++){

  123.         int prev_dc= data[0 + y*stride];

  124. 

  125.         for(x=1; x<width-1; x++){

  126.             int dc;

  127. 

  128.             dc= - prev_dc

  129.                 + data[x     + y*stride]*8

  130.                 - data[x + 1 + y*stride];

  131.             dc= (dc*10923 + 32768)>>16;

  132.             prev_dc= data[x + y*stride];

  133.             data[x + y*stride]= dc;

  134.         }

  135.     }

  136. 

  137.     /* vertical filter */

  138.     for(x=1; x<width-1; x++){

  139.         int prev_dc= data[x];

  140. 

  141.         for(y=1; y<height-1; y++){

  142.             int dc;

  143. 

  144.             dc= - prev_dc

  145.                 + data[x +  y   *stride]*8

  146.                 - data[x + (y+1)*stride];

  147.             dc= (dc*10923 + 32768)>>16;

  148.             prev_dc= data[x + y*stride];

  149.             data[x + y*stride]= dc;

  150.         }

  151.     }

  152. }

  153. 

  154. /**

  155.  * guess the dc of blocks which do not have an undamaged dc

  156.  * @param w     width in 8 pixel blocks

  157.  * @param h     height in 8 pixel blocks

  158.  */

  159. static void guess_dc(MpegEncContext *s, int16_t *dc, int w, int h, int stride, int is_luma){

  160.     int b_x, b_y;

  161. 

  162.     for(b_y=0; b_y<h; b_y++){

  163.         for(b_x=0; b_x<w; b_x++){

  164.             int color[4]={1024,1024,1024,1024};

  165.             int distance[4]={9999,9999,9999,9999};

  166.             int mb_index, error, j;

  167.             int64_t guess, weight_sum;

  168. 

  169.             mb_index= (b_x>>is_luma) + (b_y>>is_luma)*s->mb_stride;

  170. 

  171.             error= s->error_status_table[mb_index];

  172. 

  173.             if(IS_INTER(s->current_picture.f.mb_type[mb_index])) continue; //inter

  174.             if(!(error&ER_DC_ERROR)) continue;           //dc-ok

  175. 

  176.             /* right block */

  177.             for(j=b_x+1; j<w; j++){

  178.                 int mb_index_j= (j>>is_luma) + (b_y>>is_luma)*s->mb_stride;

  179.                 int error_j= s->error_status_table[mb_index_j];

  180.                 int intra_j = IS_INTRA(s->current_picture.f.mb_type[mb_index_j]);

  181.                 if(intra_j==0 || !(error_j&ER_DC_ERROR)){

  182.                     color[0]= dc[j + b_y*stride];

  183.                     distance[0]= j-b_x;

  184.                     break;

  185.                 }

  186.             }

  187. 

  188.             /* left block */

  189.             for(j=b_x-1; j>=0; j--){

  190.                 int mb_index_j= (j>>is_luma) + (b_y>>is_luma)*s->mb_stride;

  191.                 int error_j= s->error_status_table[mb_index_j];

  192.                 int intra_j = IS_INTRA(s->current_picture.f.mb_type[mb_index_j]);

  193.                 if(intra_j==0 || !(error_j&ER_DC_ERROR)){

  194.                     color[1]= dc[j + b_y*stride];

  195.                     distance[1]= b_x-j;

  196.                     break;

  197.                 }

  198.             }

  199. 

  200.             /* bottom block */

  201.             for(j=b_y+1; j<h; j++){

  202.                 int mb_index_j= (b_x>>is_luma) + (j>>is_luma)*s->mb_stride;

  203.                 int error_j= s->error_status_table[mb_index_j];

  204.                 int intra_j = IS_INTRA(s->current_picture.f.mb_type[mb_index_j]);

  205.                 if(intra_j==0 || !(error_j&ER_DC_ERROR)){

  206.                     color[2]= dc[b_x + j*stride];

  207.                     distance[2]= j-b_y;

  208.                     break;

  209.                 }

  210.             }

  211. 

  212.             /* top block */

  213.             for(j=b_y-1; j>=0; j--){

  214.                 int mb_index_j= (b_x>>is_luma) + (j>>is_luma)*s->mb_stride;

  215.                 int error_j= s->error_status_table[mb_index_j];

  216.                 int intra_j = IS_INTRA(s->current_picture.f.mb_type[mb_index_j]);

  217.                 if(intra_j==0 || !(error_j&ER_DC_ERROR)){

  218.                     color[3]= dc[b_x + j*stride];

  219.                     distance[3]= b_y-j;

  220.                     break;

  221.                 }

  222.             }

  223. 

  224.             weight_sum=0;

  225.             guess=0;

  226.             for(j=0; j<4; j++){

  227.                 int64_t weight= 256*256*256*16/distance[j];

  228.                 guess+= weight*(int64_t)color[j];

  229.                 weight_sum+= weight;

  230.             }

  231.             guess= (guess + weight_sum/2) / weight_sum;

  232. 

  233.             dc[b_x + b_y*stride]= guess;

  234.         }

  235.     }

  236. }

  237. 

  238. /**

  239.  * simple horizontal deblocking filter used for error resilience

  240.  * @param w     width in 8 pixel blocks

  241.  * @param h     height in 8 pixel blocks

  242.  */

  243. static void h_block_filter(MpegEncContext *s, uint8_t *dst, int w, int h, int stride, int is_luma){

  244.     int b_x, b_y, mvx_stride, mvy_stride;

  245.     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;

  246.     set_mv_strides(s, &mvx_stride, &mvy_stride);

  247.     mvx_stride >>= is_luma;

  248.     mvy_stride *= mvx_stride;

  249. 

  250.     for(b_y=0; b_y<h; b_y++){

  251.         for(b_x=0; b_x<w-1; b_x++){

  252.             int y;

  253.             int left_status = s->error_status_table[( b_x   >>is_luma) + (b_y>>is_luma)*s->mb_stride];

  254.             int right_status= s->error_status_table[((b_x+1)>>is_luma) + (b_y>>is_luma)*s->mb_stride];

  255.             int left_intra  = IS_INTRA(s->current_picture.f.mb_type[( b_x      >> is_luma) + (b_y >> is_luma) * s->mb_stride]);

  256.             int right_intra = IS_INTRA(s->current_picture.f.mb_type[((b_x + 1) >> is_luma) + (b_y >> is_luma) * s->mb_stride]);

  257.             int left_damage =  left_status&ER_MB_ERROR;

  258.             int right_damage= right_status&ER_MB_ERROR;

  259.             int offset= b_x*8 + b_y*stride*8;

  260.             int16_t *left_mv=  s->current_picture.f.motion_val[0][mvy_stride*b_y + mvx_stride* b_x   ];

  261.             int16_t *right_mv= s->current_picture.f.motion_val[0][mvy_stride*b_y + mvx_stride*(b_x+1)];

  262. 

  263.             if(!(left_damage||right_damage)) continue; // both undamaged

  264. 

  265.             if(   (!left_intra) && (!right_intra)

  266.                && FFABS(left_mv[0]-right_mv[0]) + FFABS(left_mv[1]+right_mv[1]) < 2) continue;

  267. 

  268.             for(y=0; y<8; y++){

  269.                 int a,b,c,d;

  270. 

  271.                 a= dst[offset + 7 + y*stride] - dst[offset + 6 + y*stride];

  272.                 b= dst[offset + 8 + y*stride] - dst[offset + 7 + y*stride];

  273.                 c= dst[offset + 9 + y*stride] - dst[offset + 8 + y*stride];

  274. 

  275.                 d= FFABS(b) - ((FFABS(a) + FFABS(c) + 1)>>1);

  276.                 d= FFMAX(d, 0);

  277.                 if(b<0) d= -d;

  278. 

  279.                 if(d==0) continue;

  280. 

  281.                 if(!(left_damage && right_damage))

  282.                     d= d*16/9;

  283. 

  284.                 if(left_damage){

  285.                     dst[offset + 7 + y*stride] = cm[dst[offset + 7 + y*stride] + ((d*7)>>4)];

  286.                     dst[offset + 6 + y*stride] = cm[dst[offset + 6 + y*stride] + ((d*5)>>4)];

  287.                     dst[offset + 5 + y*stride] = cm[dst[offset + 5 + y*stride] + ((d*3)>>4)];

  288.                     dst[offset + 4 + y*stride] = cm[dst[offset + 4 + y*stride] + ((d*1)>>4)];

  289.                 }

  290.                 if(right_damage){

  291.                     dst[offset + 8 + y*stride] = cm[dst[offset + 8 + y*stride] - ((d*7)>>4)];

  292.                     dst[offset + 9 + y*stride] = cm[dst[offset + 9 + y*stride] - ((d*5)>>4)];

  293.                     dst[offset + 10+ y*stride] = cm[dst[offset +10 + y*stride] - ((d*3)>>4)];

  294.                     dst[offset + 11+ y*stride] = cm[dst[offset +11 + y*stride] - ((d*1)>>4)];

  295.                 }

  296.             }

  297.         }

  298.     }

  299. }

  300. 

  301. /**

  302.  * simple vertical deblocking filter used for error resilience

  303.  * @param w     width in 8 pixel blocks

  304.  * @param h     height in 8 pixel blocks

  305.  */

  306. static void v_block_filter(MpegEncContext *s, uint8_t *dst, int w, int h, int stride, int is_luma){

  307.     int b_x, b_y, mvx_stride, mvy_stride;

  308.     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;

  309.     set_mv_strides(s, &mvx_stride, &mvy_stride);

  310.     mvx_stride >>= is_luma;

  311.     mvy_stride *= mvx_stride;

  312. 

  313.     for(b_y=0; b_y<h-1; b_y++){

  314.         for(b_x=0; b_x<w; b_x++){

  315.             int x;

  316.             int top_status   = s->error_status_table[(b_x>>is_luma) + ( b_y   >>is_luma)*s->mb_stride];

  317.             int bottom_status= s->error_status_table[(b_x>>is_luma) + ((b_y+1)>>is_luma)*s->mb_stride];

  318.             int top_intra    = IS_INTRA(s->current_picture.f.mb_type[(b_x >> is_luma) + ( b_y      >> is_luma) * s->mb_stride]);

  319.             int bottom_intra = IS_INTRA(s->current_picture.f.mb_type[(b_x >> is_luma) + ((b_y + 1) >> is_luma) * s->mb_stride]);

  320.             int top_damage =      top_status&ER_MB_ERROR;

  321.             int bottom_damage= bottom_status&ER_MB_ERROR;

  322.             int offset= b_x*8 + b_y*stride*8;

  323.             int16_t *top_mv    = s->current_picture.f.motion_val[0][mvy_stride *  b_y      + mvx_stride * b_x];

  324.             int16_t *bottom_mv = s->current_picture.f.motion_val[0][mvy_stride * (b_y + 1) + mvx_stride * b_x];

  325. 

  326.             if(!(top_damage||bottom_damage)) continue; // both undamaged

  327. 

  328.             if(   (!top_intra) && (!bottom_intra)

  329.                && FFABS(top_mv[0]-bottom_mv[0]) + FFABS(top_mv[1]+bottom_mv[1]) < 2) continue;

  330. 

  331.             for(x=0; x<8; x++){

  332.                 int a,b,c,d;

  333. 

  334.                 a= dst[offset + x + 7*stride] - dst[offset + x + 6*stride];

  335.                 b= dst[offset + x + 8*stride] - dst[offset + x + 7*stride];

  336.                 c= dst[offset + x + 9*stride] - dst[offset + x + 8*stride];

  337. 

  338.                 d= FFABS(b) - ((FFABS(a) + FFABS(c)+1)>>1);

  339.                 d= FFMAX(d, 0);

  340.                 if(b<0) d= -d;

  341. 

  342.                 if(d==0) continue;

  343. 

  344.                 if(!(top_damage && bottom_damage))

  345.                     d= d*16/9;

  346. 

  347.                 if(top_damage){

  348.                     dst[offset + x +  7*stride] = cm[dst[offset + x +  7*stride] + ((d*7)>>4)];

  349.                     dst[offset + x +  6*stride] = cm[dst[offset + x +  6*stride] + ((d*5)>>4)];

  350.                     dst[offset + x +  5*stride] = cm[dst[offset + x +  5*stride] + ((d*3)>>4)];

  351.                     dst[offset + x +  4*stride] = cm[dst[offset + x +  4*stride] + ((d*1)>>4)];

  352.                 }

  353.                 if(bottom_damage){

  354.                     dst[offset + x +  8*stride] = cm[dst[offset + x +  8*stride] - ((d*7)>>4)];

  355.                     dst[offset + x +  9*stride] = cm[dst[offset + x +  9*stride] - ((d*5)>>4)];

  356.                     dst[offset + x + 10*stride] = cm[dst[offset + x + 10*stride] - ((d*3)>>4)];

  357.                     dst[offset + x + 11*stride] = cm[dst[offset + x + 11*stride] - ((d*1)>>4)];

  358.                 }

  359.             }

  360.         }

  361.     }

  362. }

  363. 

  364. static void guess_mv(MpegEncContext *s){

  365.     uint8_t fixed[s->mb_stride * s->mb_height];

  366. #define MV_FROZEN    3

  367. #define MV_CHANGED   2

  368. #define MV_UNCHANGED 1

  369.     const int mb_stride = s->mb_stride;

  370.     const int mb_width = s->mb_width;

  371.     const int mb_height= s->mb_height;

  372.     int i, depth, num_avail;

  373.     int mb_x, mb_y, mot_step, mot_stride;

  374. 

  375.     set_mv_strides(s, &mot_step, &mot_stride);

  376. 

  377.     num_avail=0;

  378.     for(i=0; i<s->mb_num; i++){

  379.         const int mb_xy= s->mb_index2xy[ i ];

  380.         int f=0;

  381.         int error= s->error_status_table[mb_xy];

  382. 

  383.         if(IS_INTRA(s->current_picture.f.mb_type[mb_xy])) f=MV_FROZEN; //intra //FIXME check

  384.         if(!(error&ER_MV_ERROR)) f=MV_FROZEN;           //inter with undamaged MV

  385. 

  386.         fixed[mb_xy]= f;

  387.         if(f==MV_FROZEN)

  388.             num_avail++;

  389.     }

  390. 

  391.     if((!(s->avctx->error_concealment&FF_EC_GUESS_MVS)) || num_avail <= mb_width/2){

  392.         for(mb_y=0; mb_y<s->mb_height; mb_y++){

  393.             for(mb_x=0; mb_x<s->mb_width; mb_x++){

  394.                 const int mb_xy= mb_x + mb_y*s->mb_stride;

  395. 

  396.                 if(IS_INTRA(s->current_picture.f.mb_type[mb_xy]))  continue;

  397.                 if(!(s->error_status_table[mb_xy]&ER_MV_ERROR)) continue;

  398. 

  399.                 s->mv_dir = s->last_picture.f.data[0] ? MV_DIR_FORWARD : MV_DIR_BACKWARD;

  400.                 s->mb_intra=0;

  401.                 s->mv_type = MV_TYPE_16X16;

  402.                 s->mb_skipped=0;

  403. 

  404.                 s->dsp.clear_blocks(s->block[0]);

  405. 

  406.                 s->mb_x= mb_x;

  407.                 s->mb_y= mb_y;

  408.                 s->mv[0][0][0]= 0;

  409.                 s->mv[0][0][1]= 0;

  410.                 decode_mb(s, 0);

  411.             }

  412.         }

  413.         return;

  414.     }

  415. 

  416.     for(depth=0;; depth++){

  417.         int changed, pass, none_left;

  418. 

  419.         none_left=1;

  420.         changed=1;

  421.         for(pass=0; (changed || pass<2) && pass<10; pass++){

  422.             int mb_x, mb_y;

  423. int score_sum=0;

  424. 

  425.             changed=0;

  426.             for(mb_y=0; mb_y<s->mb_height; mb_y++){

  427.                 for(mb_x=0; mb_x<s->mb_width; mb_x++){

  428.                     const int mb_xy= mb_x + mb_y*s->mb_stride;

  429.                     int mv_predictor[8][2]={{0}};

  430.                     int ref[8]={0};

  431.                     int pred_count=0;

  432.                     int j;

  433.                     int best_score=256*256*256*64;

  434.                     int best_pred=0;

  435.                     const int mot_index= (mb_x + mb_y*mot_stride) * mot_step;

  436.                     int prev_x, prev_y, prev_ref;

  437. 

  438.                     if((mb_x^mb_y^pass)&1) continue;

  439. 

  440.                     if(fixed[mb_xy]==MV_FROZEN) continue;

  441.                     assert(!IS_INTRA(s->current_picture.f.mb_type[mb_xy]));

  442.                     assert(s->last_picture_ptr && s->last_picture_ptr->f.data[0]);

  443. 

  444.                     j=0;

  445.                     if(mb_x>0           && fixed[mb_xy-1        ]==MV_FROZEN) j=1;

  446.                     if(mb_x+1<mb_width  && fixed[mb_xy+1        ]==MV_FROZEN) j=1;

  447.                     if(mb_y>0           && fixed[mb_xy-mb_stride]==MV_FROZEN) j=1;

  448.                     if(mb_y+1<mb_height && fixed[mb_xy+mb_stride]==MV_FROZEN) j=1;

  449.                     if(j==0) continue;

  450. 

  451.                     j=0;

  452.                     if(mb_x>0           && fixed[mb_xy-1        ]==MV_CHANGED) j=1;

  453.                     if(mb_x+1<mb_width  && fixed[mb_xy+1        ]==MV_CHANGED) j=1;

  454.                     if(mb_y>0           && fixed[mb_xy-mb_stride]==MV_CHANGED) j=1;

  455.                     if(mb_y+1<mb_height && fixed[mb_xy+mb_stride]==MV_CHANGED) j=1;

  456.                     if(j==0 && pass>1) continue;

  457. 

  458.                     none_left=0;

  459. 

  460.                     if(mb_x>0 && fixed[mb_xy-1]){

  461.                         mv_predictor[pred_count][0]= s->current_picture.f.motion_val[0][mot_index - mot_step][0];

  462.                         mv_predictor[pred_count][1]= s->current_picture.f.motion_val[0][mot_index - mot_step][1];

  463.                         ref         [pred_count]   = s->current_picture.f.ref_index[0][4*(mb_xy-1)];

  464.                         pred_count++;

  465.                     }

  466.                     if(mb_x+1<mb_width && fixed[mb_xy+1]){

  467.                         mv_predictor[pred_count][0]= s->current_picture.f.motion_val[0][mot_index + mot_step][0];

  468.                         mv_predictor[pred_count][1]= s->current_picture.f.motion_val[0][mot_index + mot_step][1];

  469.                         ref         [pred_count]   = s->current_picture.f.ref_index[0][4*(mb_xy+1)];

  470.                         pred_count++;

  471.                     }

  472.                     if(mb_y>0 && fixed[mb_xy-mb_stride]){

  473.                         mv_predictor[pred_count][0]= s->current_picture.f.motion_val[0][mot_index - mot_stride*mot_step][0];

  474.                         mv_predictor[pred_count][1]= s->current_picture.f.motion_val[0][mot_index - mot_stride*mot_step][1];

  475.                         ref         [pred_count]   = s->current_picture.f.ref_index[0][4*(mb_xy-s->mb_stride)];

  476.                         pred_count++;

  477.                     }

  478.                     if(mb_y+1<mb_height && fixed[mb_xy+mb_stride]){

  479.                         mv_predictor[pred_count][0]= s->current_picture.f.motion_val[0][mot_index + mot_stride*mot_step][0];

  480.                         mv_predictor[pred_count][1]= s->current_picture.f.motion_val[0][mot_index + mot_stride*mot_step][1];

  481.                         ref         [pred_count]   = s->current_picture.f.ref_index[0][4*(mb_xy+s->mb_stride)];

  482.                         pred_count++;

  483.                     }

  484.                     if(pred_count==0) continue;

  485. 

  486.                     if(pred_count>1){

  487.                         int sum_x=0, sum_y=0, sum_r=0;

  488.                         int max_x, max_y, min_x, min_y, max_r, min_r;

  489. 

  490.                         for(j=0; j<pred_count; j++){

  491.                             sum_x+= mv_predictor[j][0];

  492.                             sum_y+= mv_predictor[j][1];

  493.                             sum_r+= ref[j];

  494.                             if(j && ref[j] != ref[j-1])

  495.                                 goto skip_mean_and_median;

  496.                         }

  497. 

  498.                         /* mean */

  499.                         mv_predictor[pred_count][0] = sum_x/j;

  500.                         mv_predictor[pred_count][1] = sum_y/j;

  501.                         ref         [pred_count]    = sum_r/j;

  502. 

  503.                         /* median */

  504.                         if(pred_count>=3){

  505.                             min_y= min_x= min_r= 99999;

  506.                             max_y= max_x= max_r=-99999;

  507.                         }else{

  508.                             min_x=min_y=max_x=max_y=min_r=max_r=0;

  509.                         }

  510.                         for(j=0; j<pred_count; j++){

  511.                             max_x= FFMAX(max_x, mv_predictor[j][0]);

  512.                             max_y= FFMAX(max_y, mv_predictor[j][1]);

  513.                             max_r= FFMAX(max_r, ref[j]);

  514.                             min_x= FFMIN(min_x, mv_predictor[j][0]);

  515.                             min_y= FFMIN(min_y, mv_predictor[j][1]);

  516.                             min_r= FFMIN(min_r, ref[j]);

  517.                         }

  518.                         mv_predictor[pred_count+1][0] = sum_x - max_x - min_x;

  519.                         mv_predictor[pred_count+1][1] = sum_y - max_y - min_y;

  520.                         ref         [pred_count+1]    = sum_r - max_r - min_r;

  521. 

  522.                         if(pred_count==4){

  523.                             mv_predictor[pred_count+1][0] /= 2;

  524.                             mv_predictor[pred_count+1][1] /= 2;

  525.                             ref         [pred_count+1]    /= 2;

  526.                         }

  527.                         pred_count+=2;

  528.                     }

  529. skip_mean_and_median:

  530. 

  531.                     /* zero MV */

  532.                     pred_count++;

  533. 

  534.                     if (!fixed[mb_xy]) {

  535.                         if (s->avctx->codec_id == CODEC_ID_H264) {

  536.                             // FIXME

  537.                         } else {

  538.                             ff_thread_await_progress((AVFrame *) s->last_picture_ptr,

  539.                                                      mb_y, 0);

  540.                         }

  541.                         if (!s->last_picture.f.motion_val[0] ||

  542.                             !s->last_picture.f.ref_index[0])

  543.                             goto skip_last_mv;

  544.                         prev_x = s->last_picture.f.motion_val[0][mot_index][0];

  545.                         prev_y = s->last_picture.f.motion_val[0][mot_index][1];

  546.                         prev_ref = s->last_picture.f.ref_index[0][4*mb_xy];

  547.                     } else {

  548.                         prev_x = s->current_picture.f.motion_val[0][mot_index][0];

  549.                         prev_y = s->current_picture.f.motion_val[0][mot_index][1];

  550.                         prev_ref = s->current_picture.f.ref_index[0][4*mb_xy];

  551.                     }

  552. 

  553.                     /* last MV */

  554.                     mv_predictor[pred_count][0]= prev_x;

  555.                     mv_predictor[pred_count][1]= prev_y;

  556.                     ref         [pred_count]   = prev_ref;

  557.                     pred_count++;

  558.                 skip_last_mv:

  559. 

  560.                     s->mv_dir = MV_DIR_FORWARD;

  561.                     s->mb_intra=0;

  562.                     s->mv_type = MV_TYPE_16X16;

  563.                     s->mb_skipped=0;

  564. 

  565.                     s->dsp.clear_blocks(s->block[0]);

  566. 

  567.                     s->mb_x= mb_x;

  568.                     s->mb_y= mb_y;

  569. 

  570.                     for(j=0; j<pred_count; j++){

  571.                         int score=0;

  572.                         uint8_t *src = s->current_picture.f.data[0] + mb_x*16 + mb_y*16*s->linesize;

  573. 

  574.                         s->current_picture.f.motion_val[0][mot_index][0] = s->mv[0][0][0] = mv_predictor[j][0];

  575.                         s->current_picture.f.motion_val[0][mot_index][1] = s->mv[0][0][1] = mv_predictor[j][1];

  576. 

  577.                         if(ref[j]<0) //predictor intra or otherwise not available

  578.                             continue;

  579. 

  580.                         decode_mb(s, ref[j]);

  581. 

  582.                         if(mb_x>0 && fixed[mb_xy-1]){

  583.                             int k;

  584.                             for(k=0; k<16; k++)

  585.                                 score += FFABS(src[k*s->linesize-1 ]-src[k*s->linesize   ]);

  586.                         }

  587.                         if(mb_x+1<mb_width && fixed[mb_xy+1]){

  588.                             int k;

  589.                             for(k=0; k<16; k++)

  590.                                 score += FFABS(src[k*s->linesize+15]-src[k*s->linesize+16]);

  591.                         }

  592.                         if(mb_y>0 && fixed[mb_xy-mb_stride]){

  593.                             int k;

  594.                             for(k=0; k<16; k++)

  595.                                 score += FFABS(src[k-s->linesize   ]-src[k               ]);

  596.                         }

  597.                         if(mb_y+1<mb_height && fixed[mb_xy+mb_stride]){

  598.                             int k;

  599.                             for(k=0; k<16; k++)

  600.                                 score += FFABS(src[k+s->linesize*15]-src[k+s->linesize*16]);

  601.                         }

  602. 

  603.                         if(score <= best_score){ // <= will favor the last MV

  604.                             best_score= score;

  605.                             best_pred= j;

  606.                         }

  607.                     }

  608. score_sum+= best_score;

  609.                     s->mv[0][0][0]= mv_predictor[best_pred][0];

  610.                     s->mv[0][0][1]= mv_predictor[best_pred][1];

  611. 

  612.                     for(i=0; i<mot_step; i++)

  613.                         for(j=0; j<mot_step; j++){

  614.                             s->current_picture.f.motion_val[0][mot_index + i + j * mot_stride][0] = s->mv[0][0][0];

  615.                             s->current_picture.f.motion_val[0][mot_index + i + j * mot_stride][1] = s->mv[0][0][1];

  616.                         }

  617. 

  618.                     decode_mb(s, ref[best_pred]);

  619. 

  620. 

  621.                     if(s->mv[0][0][0] != prev_x || s->mv[0][0][1] != prev_y){

  622.                         fixed[mb_xy]=MV_CHANGED;

  623.                         changed++;

  624.                     }else

  625.                         fixed[mb_xy]=MV_UNCHANGED;

  626.                 }

  627.             }

  628. 

  629. //            printf(".%d/%d", changed, score_sum); fflush(stdout);

  630.         }

  631. 

  632.         if(none_left)

  633.             return;

  634. 

  635.         for(i=0; i<s->mb_num; i++){

  636.             int mb_xy= s->mb_index2xy[i];

  637.             if(fixed[mb_xy])

  638.                 fixed[mb_xy]=MV_FROZEN;

  639.         }

  640. //        printf(":"); fflush(stdout);

  641.     }

  642. }

  643. 

  644. static int is_intra_more_likely(MpegEncContext *s){

  645.     int is_intra_likely, i, j, undamaged_count, skip_amount, mb_x, mb_y;

  646. 

  647.     if (!s->last_picture_ptr || !s->last_picture_ptr->f.data[0]) return 1; //no previous frame available -> use spatial prediction

  648. 

  649.     undamaged_count=0;

  650.     for(i=0; i<s->mb_num; i++){

  651.         const int mb_xy= s->mb_index2xy[i];

  652.         const int error= s->error_status_table[mb_xy];

  653.         if(!((error&ER_DC_ERROR) && (error&ER_MV_ERROR)))

  654.             undamaged_count++;

  655.     }

  656. 

  657.     if(s->codec_id == CODEC_ID_H264){

  658.         H264Context *h= (void*)s;

  659.         if (h->list_count <= 0 || h->ref_count[0] <= 0 || !h->ref_list[0][0].f.data[0])

  660.             return 1;

  661.     }

  662. 

  663.     if(undamaged_count < 5) return 0; //almost all MBs damaged -> use temporal prediction

  664. 

  665.     //prevent dsp.sad() check, that requires access to the image

  666.     if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration && s->pict_type == AV_PICTURE_TYPE_I)

  667.         return 1;

  668. 

  669.     skip_amount = FFMAX(undamaged_count / 50, 1); // check only up to 50 MBs

  670.     is_intra_likely=0;

  671. 

  672.     j=0;

  673.     for(mb_y= 0; mb_y<s->mb_height-1; mb_y++){

  674.         for(mb_x= 0; mb_x<s->mb_width; mb_x++){

  675.             int error;

  676.             const int mb_xy= mb_x + mb_y*s->mb_stride;

  677. 

  678.             error= s->error_status_table[mb_xy];

  679.             if((error&ER_DC_ERROR) && (error&ER_MV_ERROR))

  680.                 continue; //skip damaged

  681. 

  682.             j++;

  683.             if((j%skip_amount) != 0) continue; //skip a few to speed things up

  684. 

  685.             if(s->pict_type==AV_PICTURE_TYPE_I){

  686.                 uint8_t *mb_ptr     = s->current_picture.f.data[0] + mb_x*16 + mb_y*16*s->linesize;

  687.                 uint8_t *last_mb_ptr= s->last_picture.f.data   [0] + mb_x*16 + mb_y*16*s->linesize;

  688. 

  689.                 if (s->avctx->codec_id == CODEC_ID_H264) {

  690.                     // FIXME

  691.                 } else {

  692.                     ff_thread_await_progress((AVFrame *) s->last_picture_ptr,

  693.                                              mb_y, 0);

  694.                 }

  695.                 is_intra_likely += s->dsp.sad[0](NULL, last_mb_ptr, mb_ptr                    , s->linesize, 16);

  696.                 is_intra_likely -= s->dsp.sad[0](NULL, last_mb_ptr, last_mb_ptr+s->linesize*16, s->linesize, 16);

  697.             }else{

  698.                 if (IS_INTRA(s->current_picture.f.mb_type[mb_xy]))

  699.                    is_intra_likely++;

  700.                 else

  701.                    is_intra_likely--;

  702.             }

  703.         }

  704.     }

  705. //printf("is_intra_likely: %d type:%d\n", is_intra_likely, s->pict_type);

  706.     return is_intra_likely > 0;

  707. }

  708. 

  709. void ff_er_frame_start(MpegEncContext *s){

  710.     if(!s->err_recognition) return;

  711. 

  712.     memset(s->error_status_table, ER_MB_ERROR|VP_START|ER_MB_END, s->mb_stride*s->mb_height*sizeof(uint8_t));

  713.     s->error_count= 3*s->mb_num;

  714.     s->error_occurred = 0;

  715. }

  716. 

  717. /**

  718.  * Add a slice.

  719.  * @param endx x component of the last macroblock, can be -1 for the last of the previous line

  720.  * @param status the status at the end (ER_MV_END, ER_AC_ERROR, ...), it is assumed that no earlier end or

  721.  *               error of the same type occurred

  722.  */

  723. void ff_er_add_slice(MpegEncContext *s, int startx, int starty, int endx, int endy, int status){

  724.     const int start_i= av_clip(startx + starty * s->mb_width    , 0, s->mb_num-1);

  725.     const int end_i  = av_clip(endx   + endy   * s->mb_width    , 0, s->mb_num);

  726.     const int start_xy= s->mb_index2xy[start_i];

  727.     const int end_xy  = s->mb_index2xy[end_i];

  728.     int mask= -1;

  729. 

  730.     if(s->avctx->hwaccel)

  731.         return;

  732. 

  733.     if(start_i > end_i || start_xy > end_xy){

  734.         av_log(s->avctx, AV_LOG_ERROR, "internal error, slice end before start\n");

  735.         return;

  736.     }

  737. 

  738.     if(!s->err_recognition) return;

  739. 

  740.     mask &= ~VP_START;

  741.     if(status & (ER_AC_ERROR|ER_AC_END)){

  742.         mask &= ~(ER_AC_ERROR|ER_AC_END);

  743.         s->error_count -= end_i - start_i + 1;

  744.     }

  745.     if(status & (ER_DC_ERROR|ER_DC_END)){

  746.         mask &= ~(ER_DC_ERROR|ER_DC_END);

  747.         s->error_count -= end_i - start_i + 1;

  748.     }

  749.     if(status & (ER_MV_ERROR|ER_MV_END)){

  750.         mask &= ~(ER_MV_ERROR|ER_MV_END);

  751.         s->error_count -= end_i - start_i + 1;

  752.     }

  753. 

  754.     if(status & ER_MB_ERROR) {

  755.         s->error_occurred = 1;

  756.         s->error_count= INT_MAX;

  757.     }

  758. 

  759.     if(mask == ~0x7F){

  760.         memset(&s->error_status_table[start_xy], 0, (end_xy - start_xy) * sizeof(uint8_t));

  761.     }else{

  762.         int i;

  763.         for(i=start_xy; i<end_xy; i++){

  764.             s->error_status_table[ i ] &= mask;

  765.         }

  766.     }

  767. 

  768.     if(end_i == s->mb_num)

  769.         s->error_count= INT_MAX;

  770.     else{

  771.         s->error_status_table[end_xy] &= mask;

  772.         s->error_status_table[end_xy] |= status;

  773.     }

  774. 

  775.     s->error_status_table[start_xy] |= VP_START;

  776. 

  777.     if(start_xy > 0 && s->avctx->thread_count <= 1 && s->avctx->skip_top*s->mb_width < start_i){

  778.         int prev_status= s->error_status_table[ s->mb_index2xy[start_i - 1] ];

  779. 

  780.         prev_status &= ~ VP_START;

  781.         if(prev_status != (ER_MV_END|ER_DC_END|ER_AC_END)) s->error_count= INT_MAX;

  782.     }

  783. }

  784. 

  785. void ff_er_frame_end(MpegEncContext *s){

  786.     int i, mb_x, mb_y, error, error_type, dc_error, mv_error, ac_error;

  787.     int distance;

  788.     int threshold_part[4]= {100,100,100};

  789.     int threshold= 50;

  790.     int is_intra_likely;

  791.     int size = s->b8_stride * 2 * s->mb_height;

  792.     Picture *pic= s->current_picture_ptr;

  793. 

  794.     if(!s->err_recognition || s->error_count==0 || s->avctx->lowres ||

  795.        s->avctx->hwaccel ||

  796.        s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU ||

  797.        s->picture_structure != PICT_FRAME || // we do not support ER of field pictures yet, though it should not crash if enabled

  798.        s->error_count==3*s->mb_width*(s->avctx->skip_top + s->avctx->skip_bottom)) return;

  799. 

  800.     if (s->current_picture.f.motion_val[0] == NULL) {

  801.         av_log(s->avctx, AV_LOG_ERROR, "Warning MVs not available\n");

  802. 

  803.         for(i=0; i<2; i++){

  804.             pic->f.ref_index[i] = av_mallocz(s->mb_stride * s->mb_height * 4 * sizeof(uint8_t));

  805.             pic->motion_val_base[i]= av_mallocz((size+4) * 2 * sizeof(uint16_t));

  806.             pic->f.motion_val[i] = pic->motion_val_base[i] + 4;

  807.         }

  808.         pic->f.motion_subsample_log2 = 3;

  809.         s->current_picture= *s->current_picture_ptr;

  810.     }

  811. 

  812.     if(s->avctx->debug&FF_DEBUG_ER){

  813.         for(mb_y=0; mb_y<s->mb_height; mb_y++){

  814.             for(mb_x=0; mb_x<s->mb_width; mb_x++){

  815.                 int status= s->error_status_table[mb_x + mb_y*s->mb_stride];

  816. 

  817.                 av_log(s->avctx, AV_LOG_DEBUG, "%2X ", status);

  818.             }

  819.             av_log(s->avctx, AV_LOG_DEBUG, "\n");

  820.         }

  821.     }

  822. 

  823.     /* handle overlapping slices */

  824.     for(error_type=1; error_type<=3; error_type++){

  825.         int end_ok=0;

  826. 

  827.         for(i=s->mb_num-1; i>=0; i--){

  828.             const int mb_xy= s->mb_index2xy[i];

  829.             int error= s->error_status_table[mb_xy];

  830. 

  831.             if(error&(1<<error_type))

  832.                 end_ok=1;

  833.             if(error&(8<<error_type))

  834.                 end_ok=1;

  835. 

  836.             if(!end_ok)

  837.                 s->error_status_table[mb_xy]|= 1<<error_type;

  838. 

  839.             if(error&VP_START)

  840.                 end_ok=0;

  841.         }

  842.     }

  843. 

  844.     /* handle slices with partitions of different length */

  845.     if(s->partitioned_frame){

  846.         int end_ok=0;

  847. 

  848.         for(i=s->mb_num-1; i>=0; i--){

  849.             const int mb_xy= s->mb_index2xy[i];

  850.             int error= s->error_status_table[mb_xy];

  851. 

  852.             if(error&ER_AC_END)

  853.                 end_ok=0;

  854.             if((error&ER_MV_END) || (error&ER_DC_END) || (error&ER_AC_ERROR))

  855.                 end_ok=1;

  856. 

  857.             if(!end_ok)

  858.                 s->error_status_table[mb_xy]|= ER_AC_ERROR;

  859. 

  860.             if(error&VP_START)

  861.                 end_ok=0;

  862.         }

  863.     }

  864. 

  865.     /* handle missing slices */

  866.     if(s->err_recognition&AV_EF_EXPLODE){

  867.         int end_ok=1;

  868. 

  869.         for(i=s->mb_num-2; i>=s->mb_width+100; i--){ //FIXME +100 hack

  870.             const int mb_xy= s->mb_index2xy[i];

  871.             int error1= s->error_status_table[mb_xy  ];

  872.             int error2= s->error_status_table[s->mb_index2xy[i+1]];

  873. 

  874.             if(error1&VP_START)

  875.                 end_ok=1;

  876. 

  877.             if(   error2==(VP_START|ER_MB_ERROR|ER_MB_END)

  878.                && error1!=(VP_START|ER_MB_ERROR|ER_MB_END)

  879.                && ((error1&ER_AC_END) || (error1&ER_DC_END) || (error1&ER_MV_END))){ //end & uninit

  880.                 end_ok=0;

  881.             }

  882. 

  883.             if(!end_ok)

  884.                 s->error_status_table[mb_xy]|= ER_MB_ERROR;

  885.         }

  886.     }

  887. 

  888.     /* backward mark errors */

  889.     distance=9999999;

  890.     for(error_type=1; error_type<=3; error_type++){

  891.         for(i=s->mb_num-1; i>=0; i--){

  892.             const int mb_xy= s->mb_index2xy[i];

  893.             int error= s->error_status_table[mb_xy];

  894. 

  895.             if(!s->mbskip_table[mb_xy]) //FIXME partition specific

  896.                 distance++;

  897.             if(error&(1<<error_type))

  898.                 distance= 0;

  899. 

  900.             if(s->partitioned_frame){

  901.                 if(distance < threshold_part[error_type-1])

  902.                     s->error_status_table[mb_xy]|= 1<<error_type;

  903.             }else{

  904.                 if(distance < threshold)

  905.                     s->error_status_table[mb_xy]|= 1<<error_type;

  906.             }

  907. 

  908.             if(error&VP_START)

  909.                 distance= 9999999;

  910.         }

  911.     }

  912. 

  913.     /* forward mark errors */

  914.     error=0;

  915.     for(i=0; i<s->mb_num; i++){

  916.         const int mb_xy= s->mb_index2xy[i];

  917.         int old_error= s->error_status_table[mb_xy];

  918. 

  919.         if(old_error&VP_START)

  920.             error= old_error& ER_MB_ERROR;

  921.         else{

  922.             error|= old_error& ER_MB_ERROR;

  923.             s->error_status_table[mb_xy]|= error;

  924.         }

  925.     }

  926. 

  927.     /* handle not partitioned case */

  928.     if(!s->partitioned_frame){

  929.         for(i=0; i<s->mb_num; i++){

  930.             const int mb_xy= s->mb_index2xy[i];

  931.             error= s->error_status_table[mb_xy];

  932.             if(error&ER_MB_ERROR)

  933.                 error|= ER_MB_ERROR;

  934.             s->error_status_table[mb_xy]= error;

  935.         }

  936.     }

  937. 

  938.     dc_error= ac_error= mv_error=0;

  939.     for(i=0; i<s->mb_num; i++){

  940.         const int mb_xy= s->mb_index2xy[i];

  941.         error= s->error_status_table[mb_xy];

  942.         if(error&ER_DC_ERROR) dc_error ++;

  943.         if(error&ER_AC_ERROR) ac_error ++;

  944.         if(error&ER_MV_ERROR) mv_error ++;

  945.     }

  946.     av_log(s->avctx, AV_LOG_INFO, "concealing %d DC, %d AC, %d MV errors\n", dc_error, ac_error, mv_error);

  947. 

  948.     is_intra_likely= is_intra_more_likely(s);

  949. 

  950.     /* set unknown mb-type to most likely */

  951.     for(i=0; i<s->mb_num; i++){

  952.         const int mb_xy= s->mb_index2xy[i];

  953.         error= s->error_status_table[mb_xy];

  954.         if(!((error&ER_DC_ERROR) && (error&ER_MV_ERROR)))

  955.             continue;

  956. 

  957.         if(is_intra_likely)

  958.             s->current_picture.f.mb_type[mb_xy] = MB_TYPE_INTRA4x4;

  959.         else

  960.             s->current_picture.f.mb_type[mb_xy] = MB_TYPE_16x16 | MB_TYPE_L0;

  961.     }

  962. 

  963.     // change inter to intra blocks if no reference frames are available

  964.     if (!s->last_picture.f.data[0] && !s->next_picture.f.data[0])

  965.         for(i=0; i<s->mb_num; i++){

  966.             const int mb_xy= s->mb_index2xy[i];

  967.             if (!IS_INTRA(s->current_picture.f.mb_type[mb_xy]))

  968.                 s->current_picture.f.mb_type[mb_xy] = MB_TYPE_INTRA4x4;

  969.         }

  970. 

  971.     /* handle inter blocks with damaged AC */

  972.     for(mb_y=0; mb_y<s->mb_height; mb_y++){

  973.         for(mb_x=0; mb_x<s->mb_width; mb_x++){

  974.             const int mb_xy= mb_x + mb_y * s->mb_stride;

  975.             const int mb_type= s->current_picture.f.mb_type[mb_xy];

  976.             int dir = !s->last_picture.f.data[0];

  977.             error= s->error_status_table[mb_xy];

  978. 

  979.             if(IS_INTRA(mb_type)) continue; //intra

  980.             if(error&ER_MV_ERROR) continue;              //inter with damaged MV

  981.             if(!(error&ER_AC_ERROR)) continue;           //undamaged inter

  982. 

  983.             s->mv_dir = dir ? MV_DIR_BACKWARD : MV_DIR_FORWARD;

  984.             s->mb_intra=0;

  985.             s->mb_skipped=0;

  986.             if(IS_8X8(mb_type)){

  987.                 int mb_index= mb_x*2 + mb_y*2*s->b8_stride;

  988.                 int j;

  989.                 s->mv_type = MV_TYPE_8X8;

  990.                 for(j=0; j<4; j++){

  991.                     s->mv[0][j][0] = s->current_picture.f.motion_val[dir][mb_index + (j & 1) + (j >> 1) * s->b8_stride][0];

  992.                     s->mv[0][j][1] = s->current_picture.f.motion_val[dir][mb_index + (j & 1) + (j >> 1) * s->b8_stride][1];

  993.                 }

  994.             }else{

  995.                 s->mv_type = MV_TYPE_16X16;

  996.                 s->mv[0][0][0] = s->current_picture.f.motion_val[dir][ mb_x*2 + mb_y*2*s->b8_stride ][0];

  997.                 s->mv[0][0][1] = s->current_picture.f.motion_val[dir][ mb_x*2 + mb_y*2*s->b8_stride ][1];

  998.             }

  999. 

  1000.             s->dsp.clear_blocks(s->block[0]);

  1001. 

  1002.             s->mb_x= mb_x;

  1003.             s->mb_y= mb_y;

  1004.             decode_mb(s, 0/*FIXME h264 partitioned slices need this set*/);

  1005.         }

  1006.     }

  1007. 

  1008.     /* guess MVs */

  1009.     if(s->pict_type==AV_PICTURE_TYPE_B){

  1010.         for(mb_y=0; mb_y<s->mb_height; mb_y++){

  1011.             for(mb_x=0; mb_x<s->mb_width; mb_x++){

  1012.                 int xy= mb_x*2 + mb_y*2*s->b8_stride;

  1013.                 const int mb_xy= mb_x + mb_y * s->mb_stride;

  1014.                 const int mb_type= s->current_picture.f.mb_type[mb_xy];

  1015.                 error= s->error_status_table[mb_xy];

  1016. 

  1017.                 if(IS_INTRA(mb_type)) continue;

  1018.                 if(!(error&ER_MV_ERROR)) continue;           //inter with undamaged MV

  1019.                 if(!(error&ER_AC_ERROR)) continue;           //undamaged inter

  1020. 

  1021.                 s->mv_dir = MV_DIR_FORWARD|MV_DIR_BACKWARD;

  1022.                 if(!s->last_picture.f.data[0]) s->mv_dir &= ~MV_DIR_FORWARD;

  1023.                 if(!s->next_picture.f.data[0]) s->mv_dir &= ~MV_DIR_BACKWARD;

  1024.                 s->mb_intra=0;

  1025.                 s->mv_type = MV_TYPE_16X16;

  1026.                 s->mb_skipped=0;

  1027. 

  1028.                 if(s->pp_time){

  1029.                     int time_pp= s->pp_time;

  1030.                     int time_pb= s->pb_time;

  1031. 

  1032.                     if (s->avctx->codec_id == CODEC_ID_H264) {

  1033.                         //FIXME

  1034.                     } else {

  1035.                         ff_thread_await_progress((AVFrame *) s->next_picture_ptr,

  1036.                                                  mb_y, 0);

  1037.                     }

  1038.                     s->mv[0][0][0] = s->next_picture.f.motion_val[0][xy][0] *            time_pb  / time_pp;

  1039.                     s->mv[0][0][1] = s->next_picture.f.motion_val[0][xy][1] *            time_pb  / time_pp;

  1040.                     s->mv[1][0][0] = s->next_picture.f.motion_val[0][xy][0] * (time_pb - time_pp) / time_pp;

  1041.                     s->mv[1][0][1] = s->next_picture.f.motion_val[0][xy][1] * (time_pb - time_pp) / time_pp;

  1042.                 }else{

  1043.                     s->mv[0][0][0]= 0;

  1044.                     s->mv[0][0][1]= 0;

  1045.                     s->mv[1][0][0]= 0;

  1046.                     s->mv[1][0][1]= 0;

  1047.                 }

  1048. 

  1049.                 s->dsp.clear_blocks(s->block[0]);

  1050.                 s->mb_x= mb_x;

  1051.                 s->mb_y= mb_y;

  1052.                 decode_mb(s, 0);

  1053.             }

  1054.         }

  1055.     }else

  1056.         guess_mv(s);

  1057. 

  1058.     /* the filters below are not XvMC compatible, skip them */

  1059.     if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration)

  1060.         goto ec_clean;

  1061.     /* fill DC for inter blocks */

  1062.     for(mb_y=0; mb_y<s->mb_height; mb_y++){

  1063.         for(mb_x=0; mb_x<s->mb_width; mb_x++){

  1064.             int dc, dcu, dcv, y, n;

  1065.             int16_t *dc_ptr;

  1066.             uint8_t *dest_y, *dest_cb, *dest_cr;

  1067.             const int mb_xy= mb_x + mb_y * s->mb_stride;

  1068.             const int mb_type = s->current_picture.f.mb_type[mb_xy];

  1069. 

  1070.             error= s->error_status_table[mb_xy];

  1071. 

  1072.             if(IS_INTRA(mb_type) && s->partitioned_frame) continue;

  1073. //            if(error&ER_MV_ERROR) continue; //inter data damaged FIXME is this good?

  1074. 

  1075.             dest_y  = s->current_picture.f.data[0] + mb_x * 16 + mb_y * 16 * s->linesize;

  1076.             dest_cb = s->current_picture.f.data[1] + mb_x *  8 + mb_y *  8 * s->uvlinesize;

  1077.             dest_cr = s->current_picture.f.data[2] + mb_x *  8 + mb_y *  8 * s->uvlinesize;

  1078. 

  1079.             dc_ptr= &s->dc_val[0][mb_x*2 + mb_y*2*s->b8_stride];

  1080.             for(n=0; n<4; n++){

  1081.                 dc=0;

  1082.                 for(y=0; y<8; y++){

  1083.                     int x;

  1084.                     for(x=0; x<8; x++){

  1085.                        dc+= dest_y[x + (n&1)*8 + (y + (n>>1)*8)*s->linesize];

  1086.                     }

  1087.                 }

  1088.                 dc_ptr[(n&1) + (n>>1)*s->b8_stride]= (dc+4)>>3;

  1089.             }

  1090. 

  1091.             dcu=dcv=0;

  1092.             for(y=0; y<8; y++){

  1093.                 int x;

  1094.                 for(x=0; x<8; x++){

  1095.                     dcu += dest_cb[x + y * s->uvlinesize];

  1096.                     dcv += dest_cr[x + y * s->uvlinesize];

  1097.                 }

  1098.             }

  1099.             s->dc_val[1][mb_x + mb_y*s->mb_stride]= (dcu+4)>>3;

  1100.             s->dc_val[2][mb_x + mb_y*s->mb_stride]= (dcv+4)>>3;

  1101.         }

  1102.     }

  1103. 

  1104.     /* guess DC for damaged blocks */

  1105.     guess_dc(s, s->dc_val[0], s->mb_width*2, s->mb_height*2, s->b8_stride, 1);

  1106.     guess_dc(s, s->dc_val[1], s->mb_width  , s->mb_height  , s->mb_stride, 0);

  1107.     guess_dc(s, s->dc_val[2], s->mb_width  , s->mb_height  , s->mb_stride, 0);

  1108. 

  1109.     /* filter luma DC */

  1110.     filter181(s->dc_val[0], s->mb_width*2, s->mb_height*2, s->b8_stride);

  1111. 

  1112.     /* render DC only intra */

  1113.     for(mb_y=0; mb_y<s->mb_height; mb_y++){

  1114.         for(mb_x=0; mb_x<s->mb_width; mb_x++){

  1115.             uint8_t *dest_y, *dest_cb, *dest_cr;

  1116.             const int mb_xy= mb_x + mb_y * s->mb_stride;

  1117.             const int mb_type = s->current_picture.f.mb_type[mb_xy];

  1118. 

  1119.             error= s->error_status_table[mb_xy];

  1120. 

  1121.             if(IS_INTER(mb_type)) continue;

  1122.             if(!(error&ER_AC_ERROR)) continue;              //undamaged

  1123. 

  1124.             dest_y  = s->current_picture.f.data[0] + mb_x * 16 + mb_y * 16 * s->linesize;

  1125.             dest_cb = s->current_picture.f.data[1] + mb_x *  8 + mb_y *  8 * s->uvlinesize;

  1126.             dest_cr = s->current_picture.f.data[2] + mb_x *  8 + mb_y *  8 * s->uvlinesize;

  1127. 

  1128.             put_dc(s, dest_y, dest_cb, dest_cr, mb_x, mb_y);

  1129.         }

  1130.     }

  1131. 

  1132.     if(s->avctx->error_concealment&FF_EC_DEBLOCK){

  1133.         /* filter horizontal block boundaries */

  1134.         h_block_filter(s, s->current_picture.f.data[0], s->mb_width*2, s->mb_height*2, s->linesize  , 1);

  1135.         h_block_filter(s, s->current_picture.f.data[1], s->mb_width  , s->mb_height  , s->uvlinesize, 0);

  1136.         h_block_filter(s, s->current_picture.f.data[2], s->mb_width  , s->mb_height  , s->uvlinesize, 0);

  1137. 

  1138.         /* filter vertical block boundaries */

  1139.         v_block_filter(s, s->current_picture.f.data[0], s->mb_width*2, s->mb_height*2, s->linesize  , 1);

  1140.         v_block_filter(s, s->current_picture.f.data[1], s->mb_width  , s->mb_height  , s->uvlinesize, 0);

  1141.         v_block_filter(s, s->current_picture.f.data[2], s->mb_width  , s->mb_height  , s->uvlinesize, 0);

  1142.     }

  1143. 

  1144. ec_clean:

  1145.     /* clean a few tables */

  1146.     for(i=0; i<s->mb_num; i++){

  1147.         const int mb_xy= s->mb_index2xy[i];

  1148.         int error= s->error_status_table[mb_xy];

  1149. 

  1150.         if(s->pict_type!=AV_PICTURE_TYPE_B && (error&(ER_DC_ERROR|ER_MV_ERROR|ER_AC_ERROR))){

  1151.             s->mbskip_table[mb_xy]=0;

  1152.         }

  1153.         s->mbintra_table[mb_xy]=1;

  1154.     }

  1155. }