decodemv.c 34.1 KB
Newer Older
John Koleszar's avatar
John Koleszar committed
1
/*
2
  Copyright (c) 2010 The WebM project authors. All Rights Reserved.
John Koleszar's avatar
John Koleszar committed
3
 *
4
 *  Use of this source code is governed by a BSD-style license
5
6
 *  that can be found in the LICENSE file in the root of the source
 *  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.
John Koleszar's avatar
John Koleszar committed
9
10
11
12
 */


#include "treereader.h"
John Koleszar's avatar
John Koleszar committed
13
14
#include "vp8/common/entropymv.h"
#include "vp8/common/entropymode.h"
John Koleszar's avatar
John Koleszar committed
15
#include "onyxd_int.h"
John Koleszar's avatar
John Koleszar committed
16
#include "vp8/common/findnearmv.h"
Scott LaVarnway's avatar
Scott LaVarnway committed
17

18
#include "vp8/common/seg_common.h"
19
#include "vp8/common/pred_common.h"
20

John Koleszar's avatar
John Koleszar committed
21
22
23
#if CONFIG_DEBUG
#include <assert.h>
#endif
24
25
26
27
28
29

//#define DEBUG_DEC_MV
#ifdef DEBUG_DEC_MV
int dec_mvcount = 0;
#endif

Scott LaVarnway's avatar
Scott LaVarnway committed
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
static int vp8_read_bmode(vp8_reader *bc, const vp8_prob *p)
{
    const int i = vp8_treed_read(bc, vp8_bmode_tree, p);

    return i;
}


static int vp8_read_ymode(vp8_reader *bc, const vp8_prob *p)
{
    const int i = vp8_treed_read(bc, vp8_ymode_tree, p);

    return i;
}

static int vp8_kfread_ymode(vp8_reader *bc, const vp8_prob *p)
{
    const int i = vp8_treed_read(bc, vp8_kf_ymode_tree, p);

    return i;
}
Yaowu Xu's avatar
Yaowu Xu committed
51
52
53
static int vp8_read_i8x8_mode(vp8_reader *bc, const vp8_prob *p)
{
    const int i = vp8_treed_read(bc, vp8_i8x8_mode_tree, p);
Scott LaVarnway's avatar
Scott LaVarnway committed
54

Yaowu Xu's avatar
Yaowu Xu committed
55
56
    return i;
}
Scott LaVarnway's avatar
Scott LaVarnway committed
57
58
59
60
61
62
63
64
65


static int vp8_read_uv_mode(vp8_reader *bc, const vp8_prob *p)
{
    const int i = vp8_treed_read(bc, vp8_uv_mode_tree, p);

    return i;
}

66
// This function reads the current macro block's segnent id from the bitstream
Paul Wilkins's avatar
Paul Wilkins committed
67
68
// It should only be called if a segment map update is indicated.
static void vp8_read_mb_segid(vp8_reader *r, MB_MODE_INFO *mi, MACROBLOCKD *x)
Scott LaVarnway's avatar
Scott LaVarnway committed
69
{
70
    /* Is segmentation enabled */
Scott LaVarnway's avatar
Scott LaVarnway committed
71
72
    if (x->segmentation_enabled && x->update_mb_segmentation_map)
    {
73
        /* If so then read the segment id. */
Scott LaVarnway's avatar
Scott LaVarnway committed
74
75
76
77
78
79
        if (vp8_read(r, x->mb_segment_tree_probs[0]))
            mi->segment_id = (unsigned char)(2 + vp8_read(r, x->mb_segment_tree_probs[2]));
        else
            mi->segment_id = (unsigned char)(vp8_read(r, x->mb_segment_tree_probs[1]));
    }
}
Yaowu Xu's avatar
Yaowu Xu committed
80
extern const int vp8_i8x8_block[4];
Paul Wilkins's avatar
Paul Wilkins committed
81
82
83
84
static void vp8_kfread_modes(VP8D_COMP *pbi,
                             MODE_INFO *m,
                             int mb_row,
                             int mb_col)
Scott LaVarnway's avatar
Scott LaVarnway committed
85
86
87
{
    vp8_reader *const bc = & pbi->bc;
    const int mis = pbi->common.mode_info_stride;
Paul Wilkins's avatar
Paul Wilkins committed
88
    int map_index = mb_row * pbi->common.mb_cols + mb_col;
Paul Wilkins's avatar
Paul Wilkins committed
89
    MB_PREDICTION_MODE y_mode;
Paul Wilkins's avatar
Paul Wilkins committed
90

Paul Wilkins's avatar
Paul Wilkins committed
91
    // Read the Macroblock segmentation map if it is being updated explicitly
92
    // this frame (reset to 0 by default).
Paul Wilkins's avatar
Paul Wilkins committed
93
94
95
96
    m->mbmi.segment_id = 0;
    if (pbi->mb.update_mb_segmentation_map)
    {
        vp8_read_mb_segid(bc, &m->mbmi, &pbi->mb);
97
        pbi->common.last_frame_seg_map[map_index] = m->mbmi.segment_id;
Paul Wilkins's avatar
Paul Wilkins committed
98
    }
Scott LaVarnway's avatar
Scott LaVarnway committed
99

Paul Wilkins's avatar
Paul Wilkins committed
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
    if ( pbi->common.mb_no_coeff_skip &&
         ( !segfeature_active( &pbi->mb,
                               m->mbmi.segment_id, SEG_LVL_EOB ) ||
           ( get_segdata( &pbi->mb,
                          m->mbmi.segment_id, SEG_LVL_EOB ) != 0 ) ) )
    {
        m->mbmi.mb_skip_coeff = vp8_read(bc, pbi->prob_skip_false);
    }
    else
    {
        if ( segfeature_active( &pbi->mb,
                                m->mbmi.segment_id, SEG_LVL_EOB ) &&
             ( get_segdata( &pbi->mb,
                            m->mbmi.segment_id, SEG_LVL_EOB ) == 0 ) )
        {
            m->mbmi.mb_skip_coeff = 1;
        }
        else
            m->mbmi.mb_skip_coeff = 0;
    }
120

121
#if CONFIG_QIMODE
Paul Wilkins's avatar
Paul Wilkins committed
122
123
    y_mode = (MB_PREDICTION_MODE) vp8_kfread_ymode(bc,
        pbi->common.kf_ymode_prob[pbi->common.kf_ymode_probs_index]);
124
#else
Paul Wilkins's avatar
Paul Wilkins committed
125
126
    y_mode = (MB_PREDICTION_MODE) vp8_kfread_ymode(
                                      bc, pbi->common.kf_ymode_prob);
127
#endif
128
129
130
#if CONFIG_COMP_INTRA_PRED
    m->mbmi.second_mode = (MB_PREDICTION_MODE) (DC_PRED - 1);
#endif
131

Paul Wilkins's avatar
Paul Wilkins committed
132
133
134
135
136
    m->mbmi.ref_frame = INTRA_FRAME;

    if ((m->mbmi.mode = y_mode) == B_PRED)
    {
        int i = 0;
137
138
139
#if CONFIG_COMP_INTRA_PRED
        int use_comp_pred = vp8_read(bc, 128);
#endif
Paul Wilkins's avatar
Paul Wilkins committed
140
141
142
143
144
        do
        {
            const B_PREDICTION_MODE A = above_block_mode(m, i, mis);
            const B_PREDICTION_MODE L = left_block_mode(m, i);

145
            m->bmi[i].as_mode.first =
Paul Wilkins's avatar
Paul Wilkins committed
146
147
                (B_PREDICTION_MODE) vp8_read_bmode(
                                        bc, pbi->common.kf_bmode_prob [A] [L]);
148
149
150
151
152
153
154
155
156
157
158
159
#if CONFIG_COMP_INTRA_PRED
            if (use_comp_pred)
            {
                m->bmi[i].as_mode.second =
                    (B_PREDICTION_MODE) vp8_read_bmode(
                                                   bc, pbi->common.kf_bmode_prob [A] [L]);
            }
            else
            {
                m->bmi[i].as_mode.second = (B_PREDICTION_MODE) (B_DC_PRED - 1);
            }
#endif
Paul Wilkins's avatar
Paul Wilkins committed
160
161
162
163
164
165
166
167
168
169
170
        }
        while (++i < 16);
    }
    if((m->mbmi.mode = y_mode) == I8X8_PRED)
    {
        int i;
        int mode8x8;
        for(i=0;i<4;i++)
         {
             int ib = vp8_i8x8_block[i];
             mode8x8 = vp8_read_i8x8_mode(bc, pbi->common.i8x8_mode_prob);
171
172
173
174
175
176
177
178
179
180
             m->bmi[ib+0].as_mode.first= mode8x8;
             m->bmi[ib+1].as_mode.first= mode8x8;
             m->bmi[ib+4].as_mode.first= mode8x8;
             m->bmi[ib+5].as_mode.first= mode8x8;
#if CONFIG_COMP_INTRA_PRED
             m->bmi[ib+0].as_mode.second= (MB_PREDICTION_MODE) (DC_PRED - 1);
             m->bmi[ib+1].as_mode.second= (MB_PREDICTION_MODE) (DC_PRED - 1);
             m->bmi[ib+4].as_mode.second= (MB_PREDICTION_MODE) (DC_PRED - 1);
             m->bmi[ib+5].as_mode.second= (MB_PREDICTION_MODE) (DC_PRED - 1);
#endif
Paul Wilkins's avatar
Paul Wilkins committed
181
182
183
         }
   }
    else
184
#if CONFIG_UVINTRA
Yaowu Xu's avatar
Yaowu Xu committed
185
186
        m->mbmi.uv_mode = (MB_PREDICTION_MODE)vp8_read_uv_mode(bc,
            pbi->common.kf_uv_mode_prob[m->mbmi.mode]);
187
#else
Yaowu Xu's avatar
Yaowu Xu committed
188
189
        m->mbmi.uv_mode = (MB_PREDICTION_MODE)vp8_read_uv_mode(bc,
            pbi->common.kf_uv_mode_prob);
190
#endif
191
192
193
#if CONFIG_COMP_INTRA_PRED
    m->mbmi.second_uv_mode = (MB_PREDICTION_MODE) (DC_PRED - 1);
#endif
Scott LaVarnway's avatar
Scott LaVarnway committed
194
}
John Koleszar's avatar
John Koleszar committed
195
196
197
198
199
200
201
202
203
204
205
206
207
208

static int read_mvcomponent(vp8_reader *r, const MV_CONTEXT *mvc)
{
    const vp8_prob *const p = (const vp8_prob *) mvc;
    int x = 0;

    if (vp8_read(r, p [mvpis_short]))  /* Large */
    {
        int i = 0;

        do
        {
            x += vp8_read(r, p [MVPbits + i]) << i;
        }
209
        while (++i < mvnum_short_bits);
John Koleszar's avatar
John Koleszar committed
210
211
212
213
214
215
216

        i = mvlong_width - 1;  /* Skip bit 3, which is sometimes implicit */

        do
        {
            x += vp8_read(r, p [MVPbits + i]) << i;
        }
217
        while (--i > mvnum_short_bits);
John Koleszar's avatar
John Koleszar committed
218

219
220
        if (!(x & ~((2<<mvnum_short_bits)-1))  ||  vp8_read(r, p [MVPbits + mvnum_short_bits]))
            x += (mvnum_short);
John Koleszar's avatar
John Koleszar committed
221
222
223
224
225
226
227
228
229
230
231
232
    }
    else   /* small */
        x = vp8_treed_read(r, vp8_small_mvtree, p + MVPshort);

    if (x  &&  vp8_read(r, p [MVPsign]))
        x = -x;

    return x;
}

static void read_mv(vp8_reader *r, MV *mv, const MV_CONTEXT *mvc)
{
233
234
    mv->row = (short)(read_mvcomponent(r,   mvc) << 1);
    mv->col = (short)(read_mvcomponent(r, ++mvc) << 1);
235
236
#ifdef DEBUG_DEC_MV
    int i;
237
238
239
    printf("%d (np): %d %d\n", dec_mvcount++, mv->row, mv->col);
    //for (i=0; i<MVPcount;++i) printf("  %d", (&mvc[-1])->prob[i]); printf("\n");
    //for (i=0; i<MVPcount;++i) printf("  %d", (&mvc[0])->prob[i]); printf("\n");
240
#endif
John Koleszar's avatar
John Koleszar committed
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
}


static void read_mvcontexts(vp8_reader *bc, MV_CONTEXT *mvc)
{
    int i = 0;

    do
    {
        const vp8_prob *up = vp8_mv_update_probs[i].prob;
        vp8_prob *p = (vp8_prob *)(mvc + i);
        vp8_prob *const pstop = p + MVPcount;

        do
        {
            if (vp8_read(bc, *up++))
            {
                const vp8_prob x = (vp8_prob)vp8_read_literal(bc, 7);

                *p = x ? x << 1 : 1;
            }
        }
        while (++p < pstop);
    }
    while (++i < 2);
}

268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
#if CONFIG_HIGH_PRECISION_MV
static int read_mvcomponent_hp(vp8_reader *r, const MV_CONTEXT_HP *mvc)
{
    const vp8_prob *const p = (const vp8_prob *) mvc;
    int x = 0;

    if (vp8_read(r, p [mvpis_short_hp]))  /* Large */
    {
        int i = 0;

        do
        {
            x += vp8_read(r, p [MVPbits_hp + i]) << i;
        }
        while (++i < mvnum_short_bits_hp);

        i = mvlong_width_hp - 1;  /* Skip bit 3, which is sometimes implicit */

        do
        {
            x += vp8_read(r, p [MVPbits_hp + i]) << i;
        }
        while (--i > mvnum_short_bits_hp);

        if (!(x & ~((2<<mvnum_short_bits_hp)-1))  ||  vp8_read(r, p [MVPbits_hp + mvnum_short_bits_hp]))
            x += (mvnum_short_hp);
    }
    else   /* small */
        x = vp8_treed_read(r, vp8_small_mvtree_hp, p + MVPshort_hp);

    if (x  &&  vp8_read(r, p [MVPsign_hp]))
        x = -x;

    return x;
}

static void read_mv_hp(vp8_reader *r, MV *mv, const MV_CONTEXT_HP *mvc)
{
    mv->row = (short)(read_mvcomponent_hp(r,   mvc));
    mv->col = (short)(read_mvcomponent_hp(r, ++mvc));
#ifdef DEBUG_DEC_MV
    int i;
    printf("%d (hp): %d %d\n", dec_mvcount++, mv->row, mv->col);
    //for (i=0; i<MVPcount_hp;++i) printf("  %d", (&mvc[-1])->prob[i]); printf("\n");
    //for (i=0; i<MVPcount_hp;++i) printf("  %d", (&mvc[0])->prob[i]); printf("\n");
#endif
}

static void read_mvcontexts_hp(vp8_reader *bc, MV_CONTEXT_HP *mvc)
{
    int i = 0;

    do
    {
        const vp8_prob *up = vp8_mv_update_probs_hp[i].prob;
        vp8_prob *p = (vp8_prob *)(mvc + i);
        vp8_prob *const pstop = p + MVPcount_hp;

        do
        {
            if (vp8_read(bc, *up++))
            {
                const vp8_prob x = (vp8_prob)vp8_read_literal(bc, 7);

                *p = x ? x << 1 : 1;
            }
        }
        while (++p < pstop);
    }
    while (++i < 2);
}
#endif  /* CONFIG_HIGH_PRECISION_MV */

341
342
// Read the referncence frame
static MV_REFERENCE_FRAME read_ref_frame( VP8D_COMP *pbi,
Paul Wilkins's avatar
Paul Wilkins committed
343
                                          vp8_reader *const bc,
344
345
346
                                          unsigned char segment_id )
{
    MV_REFERENCE_FRAME ref_frame;
Paul Wilkins's avatar
Paul Wilkins committed
347
    int seg_ref_active;
Paul Wilkins's avatar
Paul Wilkins committed
348
    int seg_ref_count = 0;
349

350
    VP8_COMMON *const cm = & pbi->common;
351
352
    MACROBLOCKD *const xd = &pbi->mb;

Paul Wilkins's avatar
Paul Wilkins committed
353
354
355
    seg_ref_active = segfeature_active( xd,
                                        segment_id,
                                        SEG_LVL_REF_FRAME );
356

Paul Wilkins's avatar
Paul Wilkins committed
357
358
359
360
361
362
363
364
365
366
367
368
369
    // If segment coding enabled does the segment allow for more than one
    // possible reference frame
    if ( seg_ref_active )
    {
        seg_ref_count = check_segref( xd, segment_id, INTRA_FRAME ) +
                        check_segref( xd, segment_id, LAST_FRAME ) +
                        check_segref( xd, segment_id, GOLDEN_FRAME ) +
                        check_segref( xd, segment_id, ALTREF_FRAME );
    }

    // Segment reference frame features not available or allows for
    // multiple reference frame options
    if ( !seg_ref_active || (seg_ref_count > 1) )
370
    {
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
        // Values used in prediction model coding
        unsigned char prediction_flag;
        vp8_prob pred_prob;
        MV_REFERENCE_FRAME pred_ref;

        // Get the context probability the prediction flag
        pred_prob = get_pred_prob( cm, xd, PRED_REF );

        // Read the prediction status flag
        prediction_flag = (unsigned char)vp8_read( bc, pred_prob );

        // Store the prediction flag.
        set_pred_flag( xd, PRED_REF, prediction_flag );

        // Get the predicted reference frame.
        pred_ref = get_pred_ref( cm, xd );

        // If correctly predicted then use the predicted value
        if ( prediction_flag )
        {
            ref_frame = pred_ref;
        }
        // else decode the explicitly coded value
        else
        {
Paul Wilkins's avatar
Paul Wilkins committed
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
            vp8_prob mod_refprobs[PREDICTION_PROBS];
            vpx_memcpy( mod_refprobs,
                        cm->mod_refprobs[pred_ref], sizeof(mod_refprobs) );

            // If segment coding enabled blank out options that cant occur by
            // setting the branch probability to 0.
            if ( seg_ref_active )
            {
                mod_refprobs[INTRA_FRAME] *=
                    check_segref( xd, segment_id, INTRA_FRAME );
                mod_refprobs[LAST_FRAME] *=
                    check_segref( xd, segment_id, LAST_FRAME );
                mod_refprobs[GOLDEN_FRAME] *=
                    ( check_segref( xd, segment_id, GOLDEN_FRAME ) *
                      check_segref( xd, segment_id, ALTREF_FRAME ) );
            }
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436

            // Default to INTRA_FRAME (value 0)
            ref_frame = INTRA_FRAME;

            // Do we need to decode the Intra/Inter branch
            if ( mod_refprobs[0] )
                ref_frame = (MV_REFERENCE_FRAME) vp8_read(bc, mod_refprobs[0]);
            else
                ref_frame ++;

            if (ref_frame)
            {
                // Do we need to decode the Last/Gf_Arf branch
                if ( mod_refprobs[1] )
                    ref_frame += vp8_read(bc, mod_refprobs[1]);
                else
                    ref_frame++;

                if ( ref_frame > 1 )
                {
                    // Do we need to decode the GF/Arf branch
                    if ( mod_refprobs[2] )
                        ref_frame += vp8_read(bc, mod_refprobs[2]);
                    else
                    {
Paul Wilkins's avatar
Paul Wilkins committed
437
438
439
440
441
442
443
444
445
446
447
448
449
                        if ( seg_ref_active )
                        {
                            if ( (pred_ref == GOLDEN_FRAME) ||
                                 !check_segref( xd, segment_id, GOLDEN_FRAME) )
                            {
                                ref_frame = ALTREF_FRAME;
                            }
                            else
                                ref_frame = GOLDEN_FRAME;
                        }
                        else
                            ref_frame = (pred_ref == GOLDEN_FRAME)
                                        ? ALTREF_FRAME : GOLDEN_FRAME;
450
451
452
453
                    }
                }
            }
        }
454
455
    }

Paul Wilkins's avatar
Paul Wilkins committed
456
457
458
    // Segment reference frame features are enabled
    else
    {
459
460
461
462
        // The reference frame for the mb is considered as correclty predicted
        // if it is signaled at the segment level for the purposes of the
        // common prediction model
        set_pred_flag( xd, PRED_REF, 1 );
Paul Wilkins's avatar
Paul Wilkins committed
463
        ref_frame = get_pred_ref( cm, xd );
Paul Wilkins's avatar
Paul Wilkins committed
464
465
    }

466
467
    return (MV_REFERENCE_FRAME)ref_frame;
}
John Koleszar's avatar
John Koleszar committed
468
469
470
471
472
473
474
475

static MB_PREDICTION_MODE read_mv_ref(vp8_reader *bc, const vp8_prob *p)
{
    const int i = vp8_treed_read(bc, vp8_mv_ref_tree, p);

    return (MB_PREDICTION_MODE)i;
}

476
static B_PREDICTION_MODE sub_mv_ref(vp8_reader *bc, const vp8_prob *p)
John Koleszar's avatar
John Koleszar committed
477
478
479
{
    const int i = vp8_treed_read(bc, vp8_sub_mv_ref_tree, p);

480
    return (B_PREDICTION_MODE)i;
John Koleszar's avatar
John Koleszar committed
481
}
Scott LaVarnway's avatar
Scott LaVarnway committed
482
483

#ifdef VPX_MODE_COUNT
John Koleszar's avatar
John Koleszar committed
484
485
486
487
488
489
490
491
unsigned int vp8_mv_cont_count[5][4] =
{
    { 0, 0, 0, 0 },
    { 0, 0, 0, 0 },
    { 0, 0, 0, 0 },
    { 0, 0, 0, 0 },
    { 0, 0, 0, 0 }
};
Scott LaVarnway's avatar
Scott LaVarnway committed
492
#endif
John Koleszar's avatar
John Koleszar committed
493

494
495
static const unsigned char mbsplit_fill_count[4] = {8, 8, 4, 1};
static const unsigned char mbsplit_fill_offset[4][16] = {
Scott LaVarnway's avatar
Scott LaVarnway committed
496
497
498
499
500
    { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15},
    { 0,  1,  4,  5,  8,  9, 12, 13,  2,  3,   6,  7, 10, 11, 14, 15},
    { 0,  1,  4,  5,  2,  3,  6,  7,  8,  9,  12, 13, 10, 11, 14, 15},
    { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15}
};
John Koleszar's avatar
John Koleszar committed
501
502
503



504
static void mb_mode_mv_init(VP8D_COMP *pbi)
Scott LaVarnway's avatar
Scott LaVarnway committed
505
{
506
    VP8_COMMON *const cm = & pbi->common;
Scott LaVarnway's avatar
Scott LaVarnway committed
507
508
    vp8_reader *const bc = & pbi->bc;
    MV_CONTEXT *const mvc = pbi->common.fc.mvc;
509
510
511
512
#if CONFIG_HIGH_PRECISION_MV
    MV_CONTEXT_HP *const mvc_hp = pbi->common.fc.mvc_hp;
    MACROBLOCKD *const xd  = & pbi->mb;
#endif
John Koleszar's avatar
John Koleszar committed
513

Scott LaVarnway's avatar
Scott LaVarnway committed
514
515
516
    pbi->prob_skip_false = 0;
    if (pbi->common.mb_no_coeff_skip)
        pbi->prob_skip_false = (vp8_prob)vp8_read_literal(bc, 8);
John Koleszar's avatar
John Koleszar committed
517

Scott LaVarnway's avatar
Scott LaVarnway committed
518
    if(pbi->common.frame_type != KEY_FRAME)
John Koleszar's avatar
John Koleszar committed
519
    {
520
521
522
523
524
        // Decode the baseline probabilities for decoding reference frame
        cm->prob_intra_coded = (vp8_prob)vp8_read_literal(bc, 8);
        cm->prob_last_coded  = (vp8_prob)vp8_read_literal(bc, 8);
        cm->prob_gf_coded    = (vp8_prob)vp8_read_literal(bc, 8);

525
526
527
        // Computes a modified set of probabilities for use when reference
        // frame prediction fails.
        compute_mod_refprobs( cm );
528

529
530
531
532
        pbi->common.comp_pred_mode = vp8_read(bc, 128);
        if (cm->comp_pred_mode)
            cm->comp_pred_mode += vp8_read(bc, 128);
        if (cm->comp_pred_mode == HYBRID_PREDICTION)
533
        {
Paul Wilkins's avatar
Paul Wilkins committed
534
            int i;
535
536
            for ( i = 0; i < COMP_PRED_CONTEXTS; i++ )
                cm->prob_comppred[i] = (vp8_prob)vp8_read_literal(bc, 8);
537
        }
John Koleszar's avatar
John Koleszar committed
538

Scott LaVarnway's avatar
Scott LaVarnway committed
539
        if (vp8_read_bit(bc))
John Koleszar's avatar
John Koleszar committed
540
        {
Scott LaVarnway's avatar
Scott LaVarnway committed
541
            int i = 0;
John Koleszar's avatar
John Koleszar committed
542

Scott LaVarnway's avatar
Scott LaVarnway committed
543
544
            do
            {
545
                cm->fc.ymode_prob[i] = (vp8_prob) vp8_read_literal(bc, 8);
Scott LaVarnway's avatar
Scott LaVarnway committed
546
            }
Yaowu Xu's avatar
Yaowu Xu committed
547
            while (++i < VP8_YMODES-1);
Scott LaVarnway's avatar
Scott LaVarnway committed
548
        }
549
550
551
#if CONFIG_UVINTRA
        //vp8_read_bit(bc);
#else
Scott LaVarnway's avatar
Scott LaVarnway committed
552
        if (vp8_read_bit(bc))
John Koleszar's avatar
John Koleszar committed
553
        {
Scott LaVarnway's avatar
Scott LaVarnway committed
554
555
556
557
            int i = 0;

            do
            {
558
                cm->fc.uv_mode_prob[i] = (vp8_prob) vp8_read_literal(bc, 8);
Scott LaVarnway's avatar
Scott LaVarnway committed
559
            }
Yaowu Xu's avatar
Yaowu Xu committed
560
            while (++i < VP8_UV_MODES-1);
John Koleszar's avatar
John Koleszar committed
561
        }
562
#endif /* CONFIG_UVINTRA */
563
564
565
566
567
#if CONFIG_HIGH_PRECISION_MV
        if (xd->allow_high_precision_mv)
            read_mvcontexts_hp(bc, mvc_hp);
        else
#endif
Scott LaVarnway's avatar
Scott LaVarnway committed
568
        read_mvcontexts(bc, mvc);
John Koleszar's avatar
John Koleszar committed
569
    }
Scott LaVarnway's avatar
Scott LaVarnway committed
570
}
John Koleszar's avatar
John Koleszar committed
571

572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
// This function either reads the segment id for the current macroblock from
// the bitstream or if the value is temporally predicted asserts the predicted
// value
static void read_mb_segment_id ( VP8D_COMP *pbi,
                                 int mb_row, int mb_col )
{
    vp8_reader *const bc = & pbi->bc;
    VP8_COMMON *const cm = & pbi->common;
    MACROBLOCKD *const xd  = & pbi->mb;
    MODE_INFO *mi = xd->mode_info_context;
    MB_MODE_INFO *mbmi = &mi->mbmi;
    int index = mb_row * pbi->common.mb_cols + mb_col;

    if (xd->segmentation_enabled)
    {
        if (xd->update_mb_segmentation_map)
        {
            // Is temporal coding of the segment id for this mb enabled.
            if (cm->temporal_update)
            {
                // Get the context based probability for reading the
                // prediction status flag
                vp8_prob pred_prob =
                    get_pred_prob( cm, xd, PRED_SEG_ID );

                // Read the prediction status flag
                unsigned char seg_pred_flag =
                    (unsigned char)vp8_read(bc, pred_prob );

                // Store the prediction flag.
                set_pred_flag( xd, PRED_SEG_ID, seg_pred_flag );

                // If the value is flagged as correctly predicted
                // then use the predicted value
                if ( seg_pred_flag )
                {
                    mbmi->segment_id = get_pred_mb_segid( cm, index );
                }
                // Else .... decode it explicitly
                else
                {
                    vp8_read_mb_segid(bc, mbmi, xd );
                    cm->last_frame_seg_map[index] = mbmi->segment_id;
                }

            }
            // Normal unpredicted coding mode
            else
            {
                vp8_read_mb_segid(bc, mbmi, xd);
                cm->last_frame_seg_map[index] = mbmi->segment_id;
            }
        }
    }
    else
    {
        // The encoder explicitly sets the segment_id to 0
        // when segmentation is disabled
        mbmi->segment_id = 0;
    }
}
633

634
static void read_mb_modes_mv(VP8D_COMP *pbi, MODE_INFO *mi, MB_MODE_INFO *mbmi,
635
                             MODE_INFO *prev_mi,
Paul Wilkins's avatar
Paul Wilkins committed
636
                             int mb_row, int mb_col)
Scott LaVarnway's avatar
Scott LaVarnway committed
637
{
638
    VP8_COMMON *const cm = & pbi->common;
Scott LaVarnway's avatar
Scott LaVarnway committed
639
640
    vp8_reader *const bc = & pbi->bc;
    MV_CONTEXT *const mvc = pbi->common.fc.mvc;
641
642
643
#if CONFIG_HIGH_PRECISION_MV
    MV_CONTEXT_HP *const mvc_hp = pbi->common.fc.mvc_hp;
#endif
Scott LaVarnway's avatar
Scott LaVarnway committed
644
    const int mis = pbi->common.mode_info_stride;
645
    MACROBLOCKD *const xd  = & pbi->mb;
646

647
    int index = mb_row * pbi->common.mb_cols + mb_col;
Scott LaVarnway's avatar
Scott LaVarnway committed
648
    int_mv *const mv = & mbmi->mv;
Scott LaVarnway's avatar
Scott LaVarnway committed
649
650
651
652
653
    int mb_to_left_edge;
    int mb_to_right_edge;
    int mb_to_top_edge;
    int mb_to_bottom_edge;

654
655
    mb_to_top_edge = xd->mb_to_top_edge;
    mb_to_bottom_edge = xd->mb_to_bottom_edge;
Scott LaVarnway's avatar
Scott LaVarnway committed
656
657
658
    mb_to_top_edge -= LEFT_TOP_MARGIN;
    mb_to_bottom_edge += RIGHT_BOTTOM_MARGIN;
    mbmi->need_to_clamp_mvs = 0;
Yaowu Xu's avatar
Yaowu Xu committed
659
    mbmi->need_to_clamp_secondmv = 0;
660
    mbmi->second_ref_frame = 0;
661
662
663
    /* Distance of Mb to the various image edges.
     * These specified to 8th pel as they are always compared to MV values that are in 1/8th pel units
     */
664
    xd->mb_to_left_edge =
Scott LaVarnway's avatar
Scott LaVarnway committed
665
666
667
    mb_to_left_edge = -((mb_col * 16) << 3);
    mb_to_left_edge -= LEFT_TOP_MARGIN;

668
    xd->mb_to_right_edge =
Scott LaVarnway's avatar
Scott LaVarnway committed
669
670
671
    mb_to_right_edge = ((pbi->common.mb_cols - 1 - mb_col) * 16) << 3;
    mb_to_right_edge += RIGHT_BOTTOM_MARGIN;

672
673
674
675
676
677
    // Make sure the MACROBLOCKD mode info pointer is pointed at the
    // correct entry for the current macroblock.
    xd->mode_info_context = mi;

    // Read the macroblock segment id.
    read_mb_segment_id ( pbi, mb_row, mb_col );
678

679
680
681
    if ( pbi->common.mb_no_coeff_skip &&
         ( !segfeature_active( xd,
                               mbmi->segment_id, SEG_LVL_EOB ) ||
Paul Wilkins's avatar
Paul Wilkins committed
682
           (get_segdata( xd, mbmi->segment_id, SEG_LVL_EOB ) != 0) ) )
683
684
685
    {
        // Read the macroblock coeff skip flag if this feature is in use,
        // else default to 0
Scott LaVarnway's avatar
Scott LaVarnway committed
686
        mbmi->mb_skip_coeff = vp8_read(bc, pbi->prob_skip_false);
687
    }
Scott LaVarnway's avatar
Scott LaVarnway committed
688
    else
689
690
691
    {
        if ( segfeature_active( xd,
                                mbmi->segment_id, SEG_LVL_EOB ) &&
Paul Wilkins's avatar
Paul Wilkins committed
692
             (get_segdata( xd, mbmi->segment_id, SEG_LVL_EOB ) == 0) )
693
694
695
696
697
698
        {
            mbmi->mb_skip_coeff = 1;
        }
        else
            mbmi->mb_skip_coeff = 0;
    }
John Koleszar's avatar
John Koleszar committed
699

700
    // Read the reference frame
Paul Wilkins's avatar
Paul Wilkins committed
701
    mbmi->ref_frame = read_ref_frame( pbi, bc, mbmi->segment_id );
702
703
704

    // If reference frame is an Inter frame
    if (mbmi->ref_frame)
John Koleszar's avatar
John Koleszar committed
705
    {
Scott LaVarnway's avatar
Scott LaVarnway committed
706
        int rct[4];
Scott LaVarnway's avatar
Scott LaVarnway committed
707
        int_mv nearest, nearby, best_mv;
708
        vp8_prob mv_ref_p [VP8_MVREFS-1];
John Koleszar's avatar
John Koleszar committed
709

710
711
712
        vp8_find_near_mvs(xd, mi,
            prev_mi,
            &nearest, &nearby, &best_mv, rct,
713
                          mbmi->ref_frame, pbi->common.ref_frame_sign_bias);
Yaowu Xu's avatar
Yaowu Xu committed
714
        vp8_mv_ref_probs(&pbi->common, mv_ref_p, rct);
715
716

        // Is the segment level mode feature enabled for this segment
717
        if ( segfeature_active( xd, mbmi->segment_id, SEG_LVL_MODE ) )
John Koleszar's avatar
John Koleszar committed
718
        {
719
            mbmi->mode =
Paul Wilkins's avatar
Paul Wilkins committed
720
                get_segdata( xd, mbmi->segment_id, SEG_LVL_MODE );
John Koleszar's avatar
John Koleszar committed
721
        }
722
723
724
        else
        {
            mbmi->mode = read_mv_ref(bc, mv_ref_p);
Yaowu Xu's avatar
Yaowu Xu committed
725
726

            vp8_accum_mv_refs(&pbi->common, mbmi->mode, rct);
727
        }
John Koleszar's avatar
John Koleszar committed
728

Scott LaVarnway's avatar
Scott LaVarnway committed
729
        mbmi->uv_mode = DC_PRED;
730
        switch (mbmi->mode)
John Koleszar's avatar
John Koleszar committed
731
        {
Scott LaVarnway's avatar
Scott LaVarnway committed
732
733
734
735
736
737
        case SPLITMV:
        {
            const int s = mbmi->partitioning =
                      vp8_treed_read(bc, vp8_mbsplit_tree, vp8_mbsplit_probs);
            const int num_p = vp8_mbsplit_count [s];
            int j = 0;
John Koleszar's avatar
John Koleszar committed
738

739
            mbmi->need_to_clamp_mvs = 0;
Scott LaVarnway's avatar
Scott LaVarnway committed
740
741
            do  /* for each subset j */
            {
Scott LaVarnway's avatar
Scott LaVarnway committed
742
                int_mv leftmv, abovemv;
Scott LaVarnway's avatar
Scott LaVarnway committed
743
                int_mv blockmv;
Scott LaVarnway's avatar
Scott LaVarnway committed
744
745
746
                int k;  /* first block in subset j */
                int mv_contz;
                k = vp8_mbsplit_offset[s][j];
John Koleszar's avatar
John Koleszar committed
747

Scott LaVarnway's avatar
Scott LaVarnway committed
748
749
                leftmv.as_int = left_block_mv(mi, k);
                abovemv.as_int = above_block_mv(mi, k, mis);
750
                mv_contz = vp8_mv_cont(&leftmv, &abovemv);
John Koleszar's avatar
John Koleszar committed
751

752
                switch (sub_mv_ref(bc, vp8_sub_mv_ref_prob2 [mv_contz])) /*pc->fc.sub_mv_ref_prob))*/
John Koleszar's avatar
John Koleszar committed
753
                {
Scott LaVarnway's avatar
Scott LaVarnway committed
754
                case NEW4X4:
755
756
757
758
759
#if CONFIG_HIGH_PRECISION_MV
                    if (xd->allow_high_precision_mv)
                        read_mv_hp(bc, &blockmv.as_mv, (const MV_CONTEXT_HP *) mvc_hp);
                    else
#endif
Scott LaVarnway's avatar
Scott LaVarnway committed
760
761
762
                    read_mv(bc, &blockmv.as_mv, (const MV_CONTEXT *) mvc);
                    blockmv.as_mv.row += best_mv.as_mv.row;
                    blockmv.as_mv.col += best_mv.as_mv.col;
Scott LaVarnway's avatar
Scott LaVarnway committed
763
764
765
766
767
  #ifdef VPX_MODE_COUNT
                    vp8_mv_cont_count[mv_contz][3]++;
  #endif
                    break;
                case LEFT4X4:
Scott LaVarnway's avatar
Scott LaVarnway committed
768
                    blockmv.as_int = leftmv.as_int;
Scott LaVarnway's avatar
Scott LaVarnway committed
769
770
771
772
773
  #ifdef VPX_MODE_COUNT
                    vp8_mv_cont_count[mv_contz][0]++;
  #endif
                    break;
                case ABOVE4X4:
Scott LaVarnway's avatar
Scott LaVarnway committed
774
                    blockmv.as_int = abovemv.as_int;
Scott LaVarnway's avatar
Scott LaVarnway committed
775
776
777
778
779
  #ifdef VPX_MODE_COUNT
                    vp8_mv_cont_count[mv_contz][1]++;
  #endif
                    break;
                case ZERO4X4:
Scott LaVarnway's avatar
Scott LaVarnway committed
780
                    blockmv.as_int = 0;
Scott LaVarnway's avatar
Scott LaVarnway committed
781
782
783
784
785
786
  #ifdef VPX_MODE_COUNT
                    vp8_mv_cont_count[mv_contz][2]++;
  #endif
                    break;
                default:
                    break;
John Koleszar's avatar
John Koleszar committed
787
788
                }

789
                mbmi->need_to_clamp_mvs |= vp8_check_mv_bounds(&blockmv,
Scott LaVarnway's avatar
Scott LaVarnway committed
790
791
792
793
                                                          mb_to_left_edge,
                                                          mb_to_right_edge,
                                                          mb_to_top_edge,
                                                          mb_to_bottom_edge);
John Koleszar's avatar
John Koleszar committed
794
795

                {
Scott LaVarnway's avatar
Scott LaVarnway committed
796
797
798
                    /* Fill (uniform) modes, mvs of jth subset.
                     Must do it here because ensuing subsets can
                     refer back to us via "left" or "above". */
799
800
                    const unsigned char *fill_offset;
                    unsigned int fill_count = mbsplit_fill_count[s];
John Koleszar's avatar
John Koleszar committed
801

802
                    fill_offset = &mbsplit_fill_offset[s][(unsigned char)j * mbsplit_fill_count[s]];
John Koleszar's avatar
John Koleszar committed
803

Scott LaVarnway's avatar
Scott LaVarnway committed
804
                    do {
Scott LaVarnway's avatar
Scott LaVarnway committed
805
                        mi->bmi[ *fill_offset].mv.as_int = blockmv.as_int;
806
                        fill_offset++;
Scott LaVarnway's avatar
Scott LaVarnway committed
807
                    }while (--fill_count);
John Koleszar's avatar
John Koleszar committed
808
809
810
                }

            }
Scott LaVarnway's avatar
Scott LaVarnway committed
811
812
            while (++j < num_p);
        }
John Koleszar's avatar
John Koleszar committed
813

Scott LaVarnway's avatar
Scott LaVarnway committed
814
        mv->as_int = mi->bmi[15].mv.as_int;
Scott LaVarnway's avatar
Scott LaVarnway committed
815
816
817
818

        break;  /* done with SPLITMV */

        case NEARMV:
Scott LaVarnway's avatar
Scott LaVarnway committed
819
            mv->as_int = nearby.as_int;
820
            /* Clip "next_nearest" so that it does not extend to far out of image */
Scott LaVarnway's avatar
Scott LaVarnway committed
821
822
            vp8_clamp_mv(mv, mb_to_left_edge, mb_to_right_edge,
                         mb_to_top_edge, mb_to_bottom_edge);
823
            goto propagate_mv;
Scott LaVarnway's avatar
Scott LaVarnway committed
824
825

        case NEARESTMV:
Scott LaVarnway's avatar
Scott LaVarnway committed
826
            mv->as_int = nearest.as_int;
827
            /* Clip "next_nearest" so that it does not extend to far out of image */
Scott LaVarnway's avatar
Scott LaVarnway committed
828
829
            vp8_clamp_mv(mv, mb_to_left_edge, mb_to_right_edge,
                         mb_to_top_edge, mb_to_bottom_edge);
830
            goto propagate_mv;
Scott LaVarnway's avatar
Scott LaVarnway committed
831
832

        case ZEROMV:
Scott LaVarnway's avatar
Scott LaVarnway committed
833
            mv->as_int = 0;
834
            goto propagate_mv;
Scott LaVarnway's avatar
Scott LaVarnway committed
835
836

        case NEWMV:
837
838
839
840
841
#if CONFIG_HIGH_PRECISION_MV
            if (xd->allow_high_precision_mv)
                read_mv_hp(bc, &mv->as_mv, (const MV_CONTEXT_HP *) mvc_hp);
            else
#endif
Scott LaVarnway's avatar
Scott LaVarnway committed
842
843
844
            read_mv(bc, &mv->as_mv, (const MV_CONTEXT *) mvc);
            mv->as_mv.row += best_mv.as_mv.row;
            mv->as_mv.col += best_mv.as_mv.col;
Scott LaVarnway's avatar
Scott LaVarnway committed
845
846
847
848
849
850

            /* Don't need to check this on NEARMV and NEARESTMV modes
             * since those modes clamp the MV. The NEWMV mode does not,
             * so signal to the prediction stage whether special
             * handling may be required.
             */
Scott LaVarnway's avatar
Scott LaVarnway committed
851
852
853
854
855
            mbmi->need_to_clamp_mvs = vp8_check_mv_bounds(mv,
                                                      mb_to_left_edge,
                                                      mb_to_right_edge,
                                                      mb_to_top_edge,
                                                      mb_to_bottom_edge);
856

857
        propagate_mv:  /* same MV throughout */
858

859
860
861
            if ( cm->comp_pred_mode == COMP_PREDICTION_ONLY ||
                 (cm->comp_pred_mode == HYBRID_PREDICTION &&
                     vp8_read(bc, get_pred_prob( cm, xd, PRED_COMP ))) )
862
863
864
865
866
867
868
            {
                mbmi->second_ref_frame = mbmi->ref_frame + 1;
                if (mbmi->second_ref_frame == 4)
                    mbmi->second_ref_frame = 1;
            }
            if (mbmi->second_ref_frame)
            {
Paul Wilkins's avatar
Paul Wilkins committed
869
870
871
872
873
                vp8_find_near_mvs(xd, mi,
                                  prev_mi,
                                  &nearest, &nearby, &best_mv, rct,
                                  (int)mbmi->second_ref_frame,
                                  pbi->common.ref_frame_sign_bias);
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
                switch (mbmi->mode) {
                case ZEROMV:
                    mbmi->second_mv.as_int = 0;
                    break;
                case NEARMV:
                    mbmi->second_mv.as_int = nearby.as_int;
                    vp8_clamp_mv(&mbmi->second_mv, mb_to_left_edge, mb_to_right_edge,
                                 mb_to_top_edge, mb_to_bottom_edge);
                    break;
                case NEARESTMV:
                    mbmi->second_mv.as_int = nearest.as_int;
                    vp8_clamp_mv(&mbmi->second_mv, mb_to_left_edge, mb_to_right_edge,
                                 mb_to_top_edge, mb_to_bottom_edge);
                    break;
                case NEWMV:
889
890
891
892
893
894
#if CONFIG_HIGH_PRECISION_MV
                    if (xd->allow_high_precision_mv)
                        read_mv_hp(bc, &mbmi->second_mv.as_mv,
                                   (const MV_CONTEXT_HP *) mvc_hp);
                    else
#endif
895
896
897
                    read_mv(bc, &mbmi->second_mv.as_mv, (const MV_CONTEXT *) mvc);
                    mbmi->second_mv.as_mv.row += best_mv.as_mv.row;
                    mbmi->second_mv.as_mv.col += best_mv.as_mv.col;
Yaowu Xu's avatar
Yaowu Xu committed
898
                    mbmi->need_to_clamp_secondmv = vp8_check_mv_bounds(&mbmi->second_mv,
899
900
901
902
903
904
905
906
907
908
                                                                   mb_to_left_edge,
                                                                   mb_to_right_edge,
                                                                   mb_to_top_edge,
                                                                   mb_to_bottom_edge);
                    break;
                default:
                    break;
                }
            }

909
            break;
Scott LaVarnway's avatar
Scott LaVarnway committed
910
911
912
913
914
915
916
917
        default:;
  #if CONFIG_DEBUG
            assert(0);
  #endif
        }
    }
    else
    {
Scott LaVarnway's avatar
Scott LaVarnway committed
918
919
        /* required for left and above block mv */
        mbmi->mv.as_int = 0;
John Koleszar's avatar
John Koleszar committed
920

Paul Wilkins's avatar
Paul Wilkins committed
921
922
923
924
925
926
927
928
        if ( segfeature_active( xd, mbmi->segment_id, SEG_LVL_MODE ) )
            mbmi->mode = (MB_PREDICTION_MODE)
                         get_segdata( xd, mbmi->segment_id, SEG_LVL_MODE );
        else
        {
            mbmi->mode = (MB_PREDICTION_MODE)
                         vp8_read_ymode(bc, pbi->common.fc.ymode_prob);
        }
929
930
931
#if CONFIG_COMP_INTRA_PRED
        mbmi->second_mode = (MB_PREDICTION_MODE) (DC_PRED - 1);
#endif
Paul Wilkins's avatar
Paul Wilkins committed
932
933
934

        // If MB mode is BPRED read the block modes
        if (mbmi->mode == B_PRED)
Scott LaVarnway's avatar
Scott LaVarnway committed
935
        {
Scott LaVarnway's avatar
Scott LaVarnway committed
936
            int j = 0;
937
#if CONFIG_COMP_INTRA_PRED
938
            int use_comp_pred = vp8_read(bc, 128);
939
#endif
940
941
            do
            {
942
943
944
945
946
947
948
949
950
951
952
                mi->bmi[j].as_mode.first = (B_PREDICTION_MODE)vp8_read_bmode(bc, pbi->common.fc.bmode_prob);
#if CONFIG_COMP_INTRA_PRED
                if (use_comp_pred)
                {
                    mi->bmi[j].as_mode.second = (B_PREDICTION_MODE)vp8_read_bmode(bc, pbi->common.fc.bmode_prob);
                }
                else
                {
                    mi->bmi[j].as_mode.second = (B_PREDICTION_MODE) (B_DC_PRED - 1);
                }
#endif
Scott LaVarnway's avatar
Scott LaVarnway committed
953
954
955
            }
            while (++j < 16);
        }
John Koleszar's avatar
John Koleszar committed
956

957
958
959
960
961
962
963
964
        if(mbmi->mode == I8X8_PRED)
        {
            int i;
            int mode8x8;
            for(i=0;i<4;i++)
            {
                int ib = vp8_i8x8_block[i];
                mode8x8 = vp8_read_i8x8_mode(bc, pbi->common.i8x8_mode_prob);
965
966
967
968
969
970
971
972
973
974
                mi->bmi[ib+0].as_mode.first= mode8x8;
                mi->bmi[ib+1].as_mode.first= mode8x8;
                mi->bmi[ib+4].as_mode.first= mode8x8;
                mi->bmi[ib+5].as_mode.first= mode8x8;
#if CONFIG_COMP_INTRA_PRED
                mi->bmi[ib+0].as_mode.second= (MB_PREDICTION_MODE) (DC_PRED - 1);
                mi->bmi[ib+1].as_mode.second= (MB_PREDICTION_MODE) (DC_PRED - 1);
                mi->bmi[ib+4].as_mode.second= (MB_PREDICTION_MODE) (DC_PRED - 1);
                mi->bmi[ib+5].as_mode.second= (MB_PREDICTION_MODE) (DC_PRED - 1);
#endif
975
976
977
            }
        }
        else
978
979
980
981
982
983
984
#if CONFIG_UVINTRA
            mbmi->uv_mode = (MB_PREDICTION_MODE)vp8_read_uv_mode(bc,
                                    pbi->common.fc.uv_mode_prob[mbmi->mode]);
#else
            mbmi->uv_mode = (MB_PREDICTION_MODE)vp8_read_uv_mode(bc,
                                    pbi->common.fc.uv_mode_prob);
#endif /*CONFIG_UVINTRA*/
985
986
987
#if CONFIG_COMP_INTRA_PRED
        mbmi->second_uv_mode = (MB_PREDICTION_MODE) (DC_PRED - 1);
#endif
Scott LaVarnway's avatar
Scott LaVarnway committed
988
    }
John Koleszar's avatar
John Koleszar committed
989

Scott LaVarnway's avatar
Scott LaVarnway committed
990
}
John Koleszar's avatar
John Koleszar committed
991

Scott LaVarnway's avatar
Scott LaVarnway committed
992
993
994
void vp8_decode_mode_mvs(VP8D_COMP *pbi)
{
    MODE_INFO *mi = pbi->common.mi;
995
996
997

    MODE_INFO *prev_mi = pbi->common.prev_mi;

Scott LaVarnway's avatar
Scott LaVarnway committed
998
    int mb_row = -1;
John Koleszar's avatar
John Koleszar committed
999

1000
1001
1002
1003
1004
1005
#if 0
    FILE *statsfile;
    statsfile = fopen("decsegmap.stt", "a");
    fprintf(statsfile, "\n" );
#endif

1006
    mb_mode_mv_init(pbi);
John Koleszar's avatar
John Koleszar committed
1007

1008
1009
1010
1011
1012
1013
1014
#if CONFIG_QIMODE
    if(pbi->common.frame_type==KEY_FRAME && !pbi->common.kf_ymode_probs_update)
    {
        pbi->common.kf_ymode_probs_index = vp8_read_literal(&pbi->bc, 3);
    }
#endif

Scott LaVarnway's avatar
Scott LaVarnway committed
1015
1016
1017
1018
1019
    while (++mb_row < pbi->common.mb_rows)
    {
        int mb_col = -1;
        int mb_to_top_edge;
        int mb_to_bottom_edge;
John Koleszar's avatar
John Koleszar committed
1020

Scott LaVarnway's avatar
Scott LaVarnway committed
1021
1022
1023
        pbi->mb.mb_to_top_edge =
        mb_to_top_edge = -((mb_row * 16)) << 3;
        mb_to_top_edge -= LEFT_TOP_MARGIN;
John Koleszar's avatar
John Koleszar committed
1024

Scott LaVarnway's avatar
Scott LaVarnway committed
1025
1026
1027
        pbi->mb.mb_to_bottom_edge =
        mb_to_bottom_edge = ((pbi->common.mb_rows - 1 - mb_row) * 16) << 3;
        mb_to_bottom_edge += RIGHT_BOTTOM_MARGIN;
John Koleszar's avatar
John Koleszar committed
1028

1029
1030
1031
1032
#if 0
        fprintf(statsfile, "\n" );
#endif

Scott LaVarnway's avatar
Scott LaVarnway committed
1033
1034
        while (++mb_col < pbi->common.mb_cols)
        {
1035
            /*read_mb_modes_mv(pbi, xd->mode_info_context, &xd->mode_info_context->mbmi, mb_row, mb_col);*/
Scott LaVarnway's avatar
Scott LaVarnway committed
1036
1037
            if(pbi->common.frame_type == KEY_FRAME)
                vp8_kfread_modes(pbi, mi, mb_row, mb_col);
John Koleszar's avatar
John Koleszar committed
1038
            else
1039
1040
1041
                read_mb_modes_mv(pbi, mi, &mi->mbmi,
                prev_mi,
                mb_row, mb_col);
John Koleszar's avatar
John Koleszar committed
1042

Yaowu Xu's avatar
Yaowu Xu committed
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
            //printf("%3d", mi->mbmi.mode);

            /*
            if(pbi->common.current_video_frame==7)
            {
                FILE *fmode=fopen("kfmode.txt", "a");
                fprintf(fmode, "%3d:%3d:%d\n",mb_row, mb_col, mi->mbmi.mode);
                fclose(fmode);

            }*/
            /*
            if(mi->mbmi.mode==I8X8_PRED)
            {
                printf("F%3d:%d:%d\n", pbi->common.current_video_frame, mb_row, mb_col);
            }
            */
1059
1060
1061
1062
#if 0
            fprintf(statsfile, "%2d%2d%2d   ",
                mi->mbmi.segment_id, mi->mbmi.ref_frame, mi->mbmi.mode );
#endif
1063
            prev_mi++;
1064
            mi++;       /* next macroblock */
John Koleszar's avatar
John Koleszar committed
1065
        }
Yaowu Xu's avatar
Yaowu Xu committed
1066
       // printf("\n");
1067
        prev_mi++;
1068
        mi++;           /* skip left predictor each row */
John Koleszar's avatar
John Koleszar committed
1069
    }
1070
1071
1072
1073

#if 0
    fclose(statsfile);
#endif
1074

1075

1076
}