LCOV - code coverage report
Current view: directory - media/libvpx/vp8/decoder - decodemv.c (source / functions) Found Hit Coverage
Test: app.info Lines: 190 0 0.0 %
Date: 2012-06-02 Functions: 14 0 0.0 %

       1                 : /*
       2                 :  *  Copyright (c) 2010 The WebM project authors. All Rights Reserved.
       3                 :  *
       4                 :  *  Use of this source code is governed by a BSD-style license
       5                 :  *  that can be found in the LICENSE file in the root of the source
       6                 :  *  tree. An additional intellectual property rights grant can be found
       7                 :  *  in the file PATENTS.  All contributing project authors may
       8                 :  *  be found in the AUTHORS file in the root of the source tree.
       9                 :  */
      10                 : 
      11                 : 
      12                 : #include "treereader.h"
      13                 : #include "vp8/common/entropymv.h"
      14                 : #include "vp8/common/entropymode.h"
      15                 : #include "onyxd_int.h"
      16                 : #include "vp8/common/findnearmv.h"
      17                 : 
      18                 : #if CONFIG_DEBUG
      19                 : #include <assert.h>
      20                 : #endif
      21               0 : static int vp8_read_bmode(vp8_reader *bc, const vp8_prob *p)
      22                 : {
      23               0 :     const int i = vp8_treed_read(bc, vp8_bmode_tree, p);
      24                 : 
      25               0 :     return i;
      26                 : }
      27                 : 
      28                 : 
      29               0 : static int vp8_read_ymode(vp8_reader *bc, const vp8_prob *p)
      30                 : {
      31               0 :     const int i = vp8_treed_read(bc, vp8_ymode_tree, p);
      32                 : 
      33               0 :     return i;
      34                 : }
      35                 : 
      36               0 : static int vp8_kfread_ymode(vp8_reader *bc, const vp8_prob *p)
      37                 : {
      38               0 :     const int i = vp8_treed_read(bc, vp8_kf_ymode_tree, p);
      39                 : 
      40               0 :     return i;
      41                 : }
      42                 : 
      43                 : 
      44                 : 
      45               0 : static int vp8_read_uv_mode(vp8_reader *bc, const vp8_prob *p)
      46                 : {
      47               0 :     const int i = vp8_treed_read(bc, vp8_uv_mode_tree, p);
      48                 : 
      49               0 :     return i;
      50                 : }
      51                 : 
      52               0 : static void vp8_read_mb_features(vp8_reader *r, MB_MODE_INFO *mi, MACROBLOCKD *x)
      53                 : {
      54                 :     /* Is segmentation enabled */
      55               0 :     if (x->segmentation_enabled && x->update_mb_segmentation_map)
      56                 :     {
      57                 :         /* If so then read the segment id. */
      58               0 :         if (vp8_read(r, x->mb_segment_tree_probs[0]))
      59               0 :             mi->segment_id = (unsigned char)(2 + vp8_read(r, x->mb_segment_tree_probs[2]));
      60                 :         else
      61               0 :             mi->segment_id = (unsigned char)(vp8_read(r, x->mb_segment_tree_probs[1]));
      62                 :     }
      63               0 : }
      64                 : 
      65               0 : static void vp8_kfread_modes(VP8D_COMP *pbi, MODE_INFO *m, int mb_row, int mb_col)
      66                 : {
      67               0 :     vp8_reader *const bc = & pbi->bc;
      68               0 :     const int mis = pbi->common.mode_info_stride;
      69                 : 
      70                 :         {
      71                 :             MB_PREDICTION_MODE y_mode;
      72                 : 
      73                 :             /* Read the Macroblock segmentation map if it is being updated explicitly this frame (reset to 0 above by default)
      74                 :              * By default on a key frame reset all MBs to segment 0
      75                 :              */
      76               0 :             m->mbmi.segment_id = 0;
      77                 : 
      78               0 :             if (pbi->mb.update_mb_segmentation_map)
      79               0 :                 vp8_read_mb_features(bc, &m->mbmi, &pbi->mb);
      80                 : 
      81                 :             /* Read the macroblock coeff skip flag if this feature is in use, else default to 0 */
      82               0 :             if (pbi->common.mb_no_coeff_skip)
      83               0 :                 m->mbmi.mb_skip_coeff = vp8_read(bc, pbi->prob_skip_false);
      84                 :             else
      85               0 :                 m->mbmi.mb_skip_coeff = 0;
      86                 : 
      87               0 :             y_mode = (MB_PREDICTION_MODE) vp8_kfread_ymode(bc, pbi->common.kf_ymode_prob);
      88                 : 
      89               0 :             m->mbmi.ref_frame = INTRA_FRAME;
      90                 : 
      91               0 :             if ((m->mbmi.mode = y_mode) == B_PRED)
      92                 :             {
      93               0 :                 int i = 0;
      94                 : 
      95                 :                 do
      96                 :                 {
      97               0 :                     const B_PREDICTION_MODE A = above_block_mode(m, i, mis);
      98               0 :                     const B_PREDICTION_MODE L = left_block_mode(m, i);
      99                 : 
     100               0 :                     m->bmi[i].as_mode = (B_PREDICTION_MODE) vp8_read_bmode(bc, pbi->common.kf_bmode_prob [A] [L]);
     101                 :                 }
     102               0 :                 while (++i < 16);
     103                 :             }
     104                 : 
     105               0 :             m->mbmi.uv_mode = (MB_PREDICTION_MODE)vp8_read_uv_mode(bc, pbi->common.kf_uv_mode_prob);
     106                 :         }
     107               0 : }
     108                 : 
     109               0 : static int read_mvcomponent(vp8_reader *r, const MV_CONTEXT *mvc)
     110                 : {
     111               0 :     const vp8_prob *const p = (const vp8_prob *) mvc;
     112               0 :     int x = 0;
     113                 : 
     114               0 :     if (vp8_read(r, p [mvpis_short]))  /* Large */
     115                 :     {
     116               0 :         int i = 0;
     117                 : 
     118                 :         do
     119                 :         {
     120               0 :             x += vp8_read(r, p [MVPbits + i]) << i;
     121                 :         }
     122               0 :         while (++i < 3);
     123                 : 
     124               0 :         i = mvlong_width - 1;  /* Skip bit 3, which is sometimes implicit */
     125                 : 
     126                 :         do
     127                 :         {
     128               0 :             x += vp8_read(r, p [MVPbits + i]) << i;
     129                 :         }
     130               0 :         while (--i > 3);
     131                 : 
     132               0 :         if (!(x & 0xFFF0)  ||  vp8_read(r, p [MVPbits + 3]))
     133               0 :             x += 8;
     134                 :     }
     135                 :     else   /* small */
     136               0 :         x = vp8_treed_read(r, vp8_small_mvtree, p + MVPshort);
     137                 : 
     138               0 :     if (x  &&  vp8_read(r, p [MVPsign]))
     139               0 :         x = -x;
     140                 : 
     141               0 :     return x;
     142                 : }
     143                 : 
     144               0 : static void read_mv(vp8_reader *r, MV *mv, const MV_CONTEXT *mvc)
     145                 : {
     146               0 :     mv->row = (short)(read_mvcomponent(r,   mvc) << 1);
     147               0 :     mv->col = (short)(read_mvcomponent(r, ++mvc) << 1);
     148               0 : }
     149                 : 
     150                 : 
     151               0 : static void read_mvcontexts(vp8_reader *bc, MV_CONTEXT *mvc)
     152                 : {
     153               0 :     int i = 0;
     154                 : 
     155                 :     do
     156                 :     {
     157               0 :         const vp8_prob *up = vp8_mv_update_probs[i].prob;
     158               0 :         vp8_prob *p = (vp8_prob *)(mvc + i);
     159               0 :         vp8_prob *const pstop = p + MVPcount;
     160                 : 
     161                 :         do
     162                 :         {
     163               0 :             if (vp8_read(bc, *up++))
     164                 :             {
     165               0 :                 const vp8_prob x = (vp8_prob)vp8_read_literal(bc, 7);
     166                 : 
     167               0 :                 *p = x ? x << 1 : 1;
     168                 :             }
     169                 :         }
     170               0 :         while (++p < pstop);
     171                 :     }
     172               0 :     while (++i < 2);
     173               0 : }
     174                 : 
     175                 : 
     176               0 : static MB_PREDICTION_MODE read_mv_ref(vp8_reader *bc, const vp8_prob *p)
     177                 : {
     178               0 :     const int i = vp8_treed_read(bc, vp8_mv_ref_tree, p);
     179                 : 
     180               0 :     return (MB_PREDICTION_MODE)i;
     181                 : }
     182                 : 
     183               0 : static B_PREDICTION_MODE sub_mv_ref(vp8_reader *bc, const vp8_prob *p)
     184                 : {
     185               0 :     const int i = vp8_treed_read(bc, vp8_sub_mv_ref_tree, p);
     186                 : 
     187               0 :     return (B_PREDICTION_MODE)i;
     188                 : }
     189                 : 
     190                 : #ifdef VPX_MODE_COUNT
     191                 : unsigned int vp8_mv_cont_count[5][4] =
     192                 : {
     193                 :     { 0, 0, 0, 0 },
     194                 :     { 0, 0, 0, 0 },
     195                 :     { 0, 0, 0, 0 },
     196                 :     { 0, 0, 0, 0 },
     197                 :     { 0, 0, 0, 0 }
     198                 : };
     199                 : #endif
     200                 : 
     201                 : static const unsigned char mbsplit_fill_count[4] = {8, 8, 4, 1};
     202                 : static const unsigned char mbsplit_fill_offset[4][16] = {
     203                 :     { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15},
     204                 :     { 0,  1,  4,  5,  8,  9, 12, 13,  2,  3,   6,  7, 10, 11, 14, 15},
     205                 :     { 0,  1,  4,  5,  2,  3,  6,  7,  8,  9,  12, 13, 10, 11, 14, 15},
     206                 :     { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15}
     207                 : };
     208                 : 
     209                 : 
     210                 : 
     211                 : 
     212               0 : static void mb_mode_mv_init(VP8D_COMP *pbi)
     213                 : {
     214               0 :     vp8_reader *const bc = & pbi->bc;
     215               0 :     MV_CONTEXT *const mvc = pbi->common.fc.mvc;
     216                 : 
     217                 : #if CONFIG_ERROR_CONCEALMENT
     218                 :     /* Default is that no macroblock is corrupt, therefore we initialize
     219                 :      * mvs_corrupt_from_mb to something very big, which we can be sure is
     220                 :      * outside the frame. */
     221                 :     pbi->mvs_corrupt_from_mb = UINT_MAX;
     222                 : #endif
     223               0 :     pbi->prob_skip_false = 0;
     224               0 :     if (pbi->common.mb_no_coeff_skip)
     225               0 :         pbi->prob_skip_false = (vp8_prob)vp8_read_literal(bc, 8);
     226                 : 
     227               0 :     if(pbi->common.frame_type != KEY_FRAME)
     228                 :     {
     229               0 :         pbi->prob_intra = (vp8_prob)vp8_read_literal(bc, 8);
     230               0 :         pbi->prob_last  = (vp8_prob)vp8_read_literal(bc, 8);
     231               0 :         pbi->prob_gf    = (vp8_prob)vp8_read_literal(bc, 8);
     232                 : 
     233               0 :         if (vp8_read_bit(bc))
     234                 :         {
     235               0 :             int i = 0;
     236                 : 
     237                 :             do
     238                 :             {
     239               0 :                 pbi->common.fc.ymode_prob[i] = (vp8_prob) vp8_read_literal(bc, 8);
     240                 :             }
     241               0 :             while (++i < 4);
     242                 :         }
     243                 : 
     244               0 :         if (vp8_read_bit(bc))
     245                 :         {
     246               0 :             int i = 0;
     247                 : 
     248                 :             do
     249                 :             {
     250               0 :                 pbi->common.fc.uv_mode_prob[i] = (vp8_prob) vp8_read_literal(bc, 8);
     251                 :             }
     252               0 :             while (++i < 3);
     253                 :         }
     254                 : 
     255               0 :         read_mvcontexts(bc, mvc);
     256                 :     }
     257               0 : }
     258                 : 
     259                 : 
     260               0 : static void read_mb_modes_mv(VP8D_COMP *pbi, MODE_INFO *mi, MB_MODE_INFO *mbmi,
     261                 :                             int mb_row, int mb_col)
     262                 : {
     263               0 :     vp8_reader *const bc = & pbi->bc;
     264               0 :     MV_CONTEXT *const mvc = pbi->common.fc.mvc;
     265               0 :     const int mis = pbi->common.mode_info_stride;
     266                 : 
     267               0 :     int_mv *const mv = & mbmi->mv;
     268                 :     int mb_to_left_edge;
     269                 :     int mb_to_right_edge;
     270                 :     int mb_to_top_edge;
     271                 :     int mb_to_bottom_edge;
     272                 : 
     273               0 :     mb_to_top_edge = pbi->mb.mb_to_top_edge;
     274               0 :     mb_to_bottom_edge = pbi->mb.mb_to_bottom_edge;
     275               0 :     mb_to_top_edge -= LEFT_TOP_MARGIN;
     276               0 :     mb_to_bottom_edge += RIGHT_BOTTOM_MARGIN;
     277                 : 
     278               0 :     mbmi->need_to_clamp_mvs = 0;
     279                 :     /* Distance of Mb to the various image edges.
     280                 :      * These specified to 8th pel as they are always compared to MV values that are in 1/8th pel units
     281                 :      */
     282               0 :     pbi->mb.mb_to_left_edge =
     283               0 :     mb_to_left_edge = -((mb_col * 16) << 3);
     284               0 :     mb_to_left_edge -= LEFT_TOP_MARGIN;
     285                 : 
     286               0 :     pbi->mb.mb_to_right_edge =
     287               0 :     mb_to_right_edge = ((pbi->common.mb_cols - 1 - mb_col) * 16) << 3;
     288               0 :     mb_to_right_edge += RIGHT_BOTTOM_MARGIN;
     289                 : 
     290                 :     /* If required read in new segmentation data for this MB */
     291               0 :     if (pbi->mb.update_mb_segmentation_map)
     292               0 :         vp8_read_mb_features(bc, mbmi, &pbi->mb);
     293                 : 
     294                 :     /* Read the macroblock coeff skip flag if this feature is in use, else default to 0 */
     295               0 :     if (pbi->common.mb_no_coeff_skip)
     296               0 :         mbmi->mb_skip_coeff = vp8_read(bc, pbi->prob_skip_false);
     297                 :     else
     298               0 :         mbmi->mb_skip_coeff = 0;
     299                 : 
     300               0 :     if ((mbmi->ref_frame = (MV_REFERENCE_FRAME) vp8_read(bc, pbi->prob_intra)))    /* inter MB */
     301                 :     {
     302                 :         int rct[4];
     303                 :         vp8_prob mv_ref_p [VP8_MVREFS-1];
     304                 :         int_mv nearest, nearby, best_mv;
     305                 : 
     306               0 :         if (vp8_read(bc, pbi->prob_last))
     307                 :         {
     308               0 :             mbmi->ref_frame = (MV_REFERENCE_FRAME)((int)mbmi->ref_frame + (int)(1 + vp8_read(bc, pbi->prob_gf)));
     309                 :         }
     310                 : 
     311               0 :         vp8_find_near_mvs(&pbi->mb, mi, &nearest, &nearby, &best_mv, rct, mbmi->ref_frame, pbi->common.ref_frame_sign_bias);
     312                 : 
     313               0 :         vp8_mv_ref_probs(mv_ref_p, rct);
     314                 : 
     315               0 :         mbmi->uv_mode = DC_PRED;
     316               0 :         switch (mbmi->mode = read_mv_ref(bc, mv_ref_p))
     317                 :         {
     318                 :         case SPLITMV:
     319                 :         {
     320               0 :             const int s = mbmi->partitioning =
     321               0 :                       vp8_treed_read(bc, vp8_mbsplit_tree, vp8_mbsplit_probs);
     322               0 :             const int num_p = vp8_mbsplit_count [s];
     323               0 :             int j = 0;
     324                 : 
     325                 :             do  /* for each subset j */
     326                 :             {
     327                 :                 int_mv leftmv, abovemv;
     328                 :                 int_mv blockmv;
     329                 :                 int k;  /* first block in subset j */
     330                 :                 int mv_contz;
     331               0 :                 k = vp8_mbsplit_offset[s][j];
     332                 : 
     333               0 :                 leftmv.as_int = left_block_mv(mi, k);
     334               0 :                 abovemv.as_int = above_block_mv(mi, k, mis);
     335               0 :                 mv_contz = vp8_mv_cont(&leftmv, &abovemv);
     336                 : 
     337               0 :                 switch (sub_mv_ref(bc, vp8_sub_mv_ref_prob2 [mv_contz])) /*pc->fc.sub_mv_ref_prob))*/
     338                 :                 {
     339                 :                 case NEW4X4:
     340               0 :                     read_mv(bc, &blockmv.as_mv, (const MV_CONTEXT *) mvc);
     341               0 :                     blockmv.as_mv.row += best_mv.as_mv.row;
     342               0 :                     blockmv.as_mv.col += best_mv.as_mv.col;
     343                 :   #ifdef VPX_MODE_COUNT
     344                 :                     vp8_mv_cont_count[mv_contz][3]++;
     345                 :   #endif
     346               0 :                     break;
     347                 :                 case LEFT4X4:
     348               0 :                     blockmv.as_int = leftmv.as_int;
     349                 :   #ifdef VPX_MODE_COUNT
     350                 :                     vp8_mv_cont_count[mv_contz][0]++;
     351                 :   #endif
     352               0 :                     break;
     353                 :                 case ABOVE4X4:
     354               0 :                     blockmv.as_int = abovemv.as_int;
     355                 :   #ifdef VPX_MODE_COUNT
     356                 :                     vp8_mv_cont_count[mv_contz][1]++;
     357                 :   #endif
     358               0 :                     break;
     359                 :                 case ZERO4X4:
     360               0 :                     blockmv.as_int = 0;
     361                 :   #ifdef VPX_MODE_COUNT
     362                 :                     vp8_mv_cont_count[mv_contz][2]++;
     363                 :   #endif
     364               0 :                     break;
     365                 :                 default:
     366               0 :                     break;
     367                 :                 }
     368                 : 
     369               0 :                 mbmi->need_to_clamp_mvs |= vp8_check_mv_bounds(&blockmv,
     370                 :                                                           mb_to_left_edge,
     371                 :                                                           mb_to_right_edge,
     372                 :                                                           mb_to_top_edge,
     373                 :                                                           mb_to_bottom_edge);
     374                 : 
     375                 :                 {
     376                 :                     /* Fill (uniform) modes, mvs of jth subset.
     377                 :                      Must do it here because ensuing subsets can
     378                 :                      refer back to us via "left" or "above". */
     379                 :                     const unsigned char *fill_offset;
     380               0 :                     unsigned int fill_count = mbsplit_fill_count[s];
     381                 : 
     382               0 :                     fill_offset = &mbsplit_fill_offset[s][(unsigned char)j * mbsplit_fill_count[s]];
     383                 : 
     384                 :                     do {
     385               0 :                         mi->bmi[ *fill_offset].mv.as_int = blockmv.as_int;
     386               0 :                         fill_offset++;
     387               0 :                     }while (--fill_count);
     388                 :                 }
     389                 : 
     390                 :             }
     391               0 :             while (++j < num_p);
     392                 :         }
     393                 : 
     394               0 :         mv->as_int = mi->bmi[15].mv.as_int;
     395                 : 
     396               0 :         break;  /* done with SPLITMV */
     397                 : 
     398                 :         case NEARMV:
     399               0 :             mv->as_int = nearby.as_int;
     400                 :             /* Clip "next_nearest" so that it does not extend to far out of image */
     401               0 :             vp8_clamp_mv(mv, mb_to_left_edge, mb_to_right_edge,
     402                 :                          mb_to_top_edge, mb_to_bottom_edge);
     403               0 :             goto propagate_mv;
     404                 : 
     405                 :         case NEARESTMV:
     406               0 :             mv->as_int = nearest.as_int;
     407                 :             /* Clip "next_nearest" so that it does not extend to far out of image */
     408               0 :             vp8_clamp_mv(mv, mb_to_left_edge, mb_to_right_edge,
     409                 :                          mb_to_top_edge, mb_to_bottom_edge);
     410               0 :             goto propagate_mv;
     411                 : 
     412                 :         case ZEROMV:
     413               0 :             mv->as_int = 0;
     414               0 :             goto propagate_mv;
     415                 : 
     416                 :         case NEWMV:
     417               0 :             read_mv(bc, &mv->as_mv, (const MV_CONTEXT *) mvc);
     418               0 :             mv->as_mv.row += best_mv.as_mv.row;
     419               0 :             mv->as_mv.col += best_mv.as_mv.col;
     420                 : 
     421                 :             /* Don't need to check this on NEARMV and NEARESTMV modes
     422                 :              * since those modes clamp the MV. The NEWMV mode does not,
     423                 :              * so signal to the prediction stage whether special
     424                 :              * handling may be required.
     425                 :              */
     426               0 :             mbmi->need_to_clamp_mvs = vp8_check_mv_bounds(mv,
     427                 :                                                       mb_to_left_edge,
     428                 :                                                       mb_to_right_edge,
     429                 :                                                       mb_to_top_edge,
     430                 :                                                       mb_to_bottom_edge);
     431                 : 
     432                 :         propagate_mv:  /* same MV throughout */
     433                 : #if CONFIG_ERROR_CONCEALMENT
     434                 :             if(pbi->ec_enabled)
     435                 :             {
     436                 :                 mi->bmi[ 0].mv.as_int =
     437                 :                 mi->bmi[ 1].mv.as_int =
     438                 :                 mi->bmi[ 2].mv.as_int =
     439                 :                 mi->bmi[ 3].mv.as_int =
     440                 :                 mi->bmi[ 4].mv.as_int =
     441                 :                 mi->bmi[ 5].mv.as_int =
     442                 :                 mi->bmi[ 6].mv.as_int =
     443                 :                 mi->bmi[ 7].mv.as_int =
     444                 :                 mi->bmi[ 8].mv.as_int =
     445                 :                 mi->bmi[ 9].mv.as_int =
     446                 :                 mi->bmi[10].mv.as_int =
     447                 :                 mi->bmi[11].mv.as_int =
     448                 :                 mi->bmi[12].mv.as_int =
     449                 :                 mi->bmi[13].mv.as_int =
     450                 :                 mi->bmi[14].mv.as_int =
     451                 :                 mi->bmi[15].mv.as_int = mv->as_int;
     452                 :             }
     453                 : #endif
     454               0 :             break;
     455                 :         default:;
     456                 :   #if CONFIG_DEBUG
     457                 :             assert(0);
     458                 :   #endif
     459                 :         }
     460                 :     }
     461                 :     else
     462                 :     {
     463                 :         /* required for left and above block mv */
     464               0 :         mbmi->mv.as_int = 0;
     465                 : 
     466                 :         /* MB is intra coded */
     467               0 :         if ((mbmi->mode = (MB_PREDICTION_MODE) vp8_read_ymode(bc, pbi->common.fc.ymode_prob)) == B_PRED)
     468                 :         {
     469               0 :             int j = 0;
     470                 :             do
     471                 :             {
     472               0 :                 mi->bmi[j].as_mode = (B_PREDICTION_MODE)vp8_read_bmode(bc, pbi->common.fc.bmode_prob);
     473                 :             }
     474               0 :             while (++j < 16);
     475                 :         }
     476                 : 
     477               0 :         mbmi->uv_mode = (MB_PREDICTION_MODE)vp8_read_uv_mode(bc, pbi->common.fc.uv_mode_prob);
     478                 :     }
     479                 : 
     480               0 : }
     481                 : 
     482               0 : void vp8_decode_mode_mvs(VP8D_COMP *pbi)
     483                 : {
     484               0 :     MODE_INFO *mi = pbi->common.mi;
     485               0 :     int mb_row = -1;
     486                 : 
     487               0 :     mb_mode_mv_init(pbi);
     488                 : 
     489               0 :     while (++mb_row < pbi->common.mb_rows)
     490                 :     {
     491               0 :         int mb_col = -1;
     492                 :         int mb_to_top_edge;
     493                 :         int mb_to_bottom_edge;
     494                 : 
     495               0 :         pbi->mb.mb_to_top_edge =
     496               0 :         mb_to_top_edge = -((mb_row * 16)) << 3;
     497               0 :         mb_to_top_edge -= LEFT_TOP_MARGIN;
     498                 : 
     499               0 :         pbi->mb.mb_to_bottom_edge =
     500               0 :         mb_to_bottom_edge = ((pbi->common.mb_rows - 1 - mb_row) * 16) << 3;
     501               0 :         mb_to_bottom_edge += RIGHT_BOTTOM_MARGIN;
     502                 : 
     503               0 :         while (++mb_col < pbi->common.mb_cols)
     504                 :         {
     505                 : #if CONFIG_ERROR_CONCEALMENT
     506                 :             int mb_num = mb_row * pbi->common.mb_cols + mb_col;
     507                 : #endif
     508                 :             /*read_mb_modes_mv(pbi, xd->mode_info_context, &xd->mode_info_context->mbmi, mb_row, mb_col);*/
     509               0 :             if(pbi->common.frame_type == KEY_FRAME)
     510               0 :                 vp8_kfread_modes(pbi, mi, mb_row, mb_col);
     511                 :             else
     512               0 :                 read_mb_modes_mv(pbi, mi, &mi->mbmi, mb_row, mb_col);
     513                 : 
     514                 : #if CONFIG_ERROR_CONCEALMENT
     515                 :             /* look for corruption. set mvs_corrupt_from_mb to the current
     516                 :              * mb_num if the frame is corrupt from this macroblock. */
     517                 :             if (vp8dx_bool_error(&pbi->bc) && mb_num < pbi->mvs_corrupt_from_mb)
     518                 :             {
     519                 :                 pbi->mvs_corrupt_from_mb = mb_num;
     520                 :                 /* no need to continue since the partition is corrupt from
     521                 :                  * here on.
     522                 :                  */
     523                 :                 return;
     524                 :             }
     525                 : #endif
     526                 : 
     527               0 :             mi++;       /* next macroblock */
     528                 :         }
     529                 : 
     530               0 :         mi++;           /* skip left predictor each row */
     531                 :     }
     532               0 : }
     533                 : 

Generated by: LCOV version 1.7