decodemv.c 20.5 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

John Koleszar's avatar
John Koleszar committed
18
19
20
#if CONFIG_DEBUG
#include <assert.h>
#endif
21
static B_PREDICTION_MODE read_bmode(vp8_reader *bc, const vp8_prob *p)
Scott LaVarnway's avatar
Scott LaVarnway committed
22
23
24
{
    const int i = vp8_treed_read(bc, vp8_bmode_tree, p);

25
    return (B_PREDICTION_MODE)i;
Scott LaVarnway's avatar
Scott LaVarnway committed
26
27
}

28
static MB_PREDICTION_MODE read_ymode(vp8_reader *bc, const vp8_prob *p)
Scott LaVarnway's avatar
Scott LaVarnway committed
29
30
31
{
    const int i = vp8_treed_read(bc, vp8_ymode_tree, p);

32
    return (MB_PREDICTION_MODE)i;
Scott LaVarnway's avatar
Scott LaVarnway committed
33
34
}

35
static MB_PREDICTION_MODE read_kf_ymode(vp8_reader *bc, const vp8_prob *p)
Scott LaVarnway's avatar
Scott LaVarnway committed
36
37
38
{
    const int i = vp8_treed_read(bc, vp8_kf_ymode_tree, p);

39
    return (MB_PREDICTION_MODE)i;
Scott LaVarnway's avatar
Scott LaVarnway committed
40
41
}

42
static MB_PREDICTION_MODE read_uv_mode(vp8_reader *bc, const vp8_prob *p)
Scott LaVarnway's avatar
Scott LaVarnway committed
43
44
45
{
    const int i = vp8_treed_read(bc, vp8_uv_mode_tree, p);

46
    return (MB_PREDICTION_MODE)i;
Scott LaVarnway's avatar
Scott LaVarnway committed
47
48
}

49
static void read_kf_modes(VP8D_COMP *pbi, MODE_INFO *mi)
Scott LaVarnway's avatar
Scott LaVarnway committed
50
51
52
53
{
    vp8_reader *const bc = & pbi->bc;
    const int mis = pbi->common.mode_info_stride;

54
    mi->mbmi.ref_frame = INTRA_FRAME;
55
    mi->mbmi.mode = read_kf_ymode(bc, vp8_kf_ymode_prob);
Scott LaVarnway's avatar
Scott LaVarnway committed
56

57
58
59
    if (mi->mbmi.mode == B_PRED)
    {
        int i = 0;
Scott LaVarnway's avatar
Scott LaVarnway committed
60
        mi->mbmi.is_4x4 = 1;
Scott LaVarnway's avatar
Scott LaVarnway committed
61

62
63
64
65
        do
        {
            const B_PREDICTION_MODE A = above_block_mode(mi, i, mis);
            const B_PREDICTION_MODE L = left_block_mode(mi, i);
Scott LaVarnway's avatar
Scott LaVarnway committed
66

67
            mi->bmi[i].as_mode =
68
                read_bmode(bc, vp8_kf_bmode_prob [A] [L]);
Scott LaVarnway's avatar
Scott LaVarnway committed
69
        }
70
71
72
        while (++i < 16);
    }

73
    mi->mbmi.uv_mode = read_uv_mode(bc, vp8_kf_uv_mode_prob);
Scott LaVarnway's avatar
Scott LaVarnway committed
74
}
John Koleszar's avatar
John Koleszar committed
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141

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;
        }
        while (++i < 3);

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

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

        if (!(x & 0xFFF0)  ||  vp8_read(r, p [MVPbits + 3]))
            x += 8;
    }
    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)
{
    mv->row = (short)(read_mvcomponent(r,   mvc) << 1);
    mv->col = (short)(read_mvcomponent(r, ++mvc) << 1);
}


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);
}

142
143
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
144
145
146
147
148
    { 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
149
150


151
static void mb_mode_mv_init(VP8D_COMP *pbi)
Scott LaVarnway's avatar
Scott LaVarnway committed
152
153
154
{
    vp8_reader *const bc = & pbi->bc;
    MV_CONTEXT *const mvc = pbi->common.fc.mvc;
John Koleszar's avatar
John Koleszar committed
155

156
157
158
159
160
161
#if CONFIG_ERROR_CONCEALMENT
    /* Default is that no macroblock is corrupt, therefore we initialize
     * mvs_corrupt_from_mb to something very big, which we can be sure is
     * outside the frame. */
    pbi->mvs_corrupt_from_mb = UINT_MAX;
#endif
Scott LaVarnway's avatar
Scott LaVarnway committed
162
163
164
    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
165

Scott LaVarnway's avatar
Scott LaVarnway committed
166
167
168
169
170
    if(pbi->common.frame_type != KEY_FRAME)
    {
        pbi->prob_intra = (vp8_prob)vp8_read_literal(bc, 8);
        pbi->prob_last  = (vp8_prob)vp8_read_literal(bc, 8);
        pbi->prob_gf    = (vp8_prob)vp8_read_literal(bc, 8);
John Koleszar's avatar
John Koleszar committed
171

Scott LaVarnway's avatar
Scott LaVarnway committed
172
173
174
        if (vp8_read_bit(bc))
        {
            int i = 0;
John Koleszar's avatar
John Koleszar committed
175

Scott LaVarnway's avatar
Scott LaVarnway committed
176
177
            do
            {
178
179
                pbi->common.fc.ymode_prob[i] =
                    (vp8_prob) vp8_read_literal(bc, 8);
Scott LaVarnway's avatar
Scott LaVarnway committed
180
181
182
            }
            while (++i < 4);
        }
John Koleszar's avatar
John Koleszar committed
183

Scott LaVarnway's avatar
Scott LaVarnway committed
184
        if (vp8_read_bit(bc))
John Koleszar's avatar
John Koleszar committed
185
        {
Scott LaVarnway's avatar
Scott LaVarnway committed
186
187
188
189
            int i = 0;

            do
            {
190
191
                pbi->common.fc.uv_mode_prob[i] =
                    (vp8_prob) vp8_read_literal(bc, 8);
Scott LaVarnway's avatar
Scott LaVarnway committed
192
193
            }
            while (++i < 3);
John Koleszar's avatar
John Koleszar committed
194
        }
Scott LaVarnway's avatar
Scott LaVarnway committed
195
196

        read_mvcontexts(bc, mvc);
John Koleszar's avatar
John Koleszar committed
197
    }
Scott LaVarnway's avatar
Scott LaVarnway committed
198
}
John Koleszar's avatar
John Koleszar committed
199

Scott LaVarnway's avatar
Scott LaVarnway committed
200
201
202
203
204
205
206
207
208
209
210
211
212
const vp8_prob vp8_sub_mv_ref_prob3 [8][VP8_SUBMVREFS-1] =
{
    { 147, 136, 18 },   /* SUBMVREF_NORMAL          */
    { 223, 1  , 34 },   /* SUBMVREF_LEFT_ABOVE_SAME */
    { 106, 145, 1  },   /* SUBMVREF_LEFT_ZED        */
    { 208, 1  , 1  },   /* SUBMVREF_LEFT_ABOVE_ZED  */
    { 179, 121, 1  },   /* SUBMVREF_ABOVE_ZED       */
    { 223, 1  , 34 },   /* SUBMVREF_LEFT_ABOVE_SAME */
    { 179, 121, 1  },   /* SUBMVREF_ABOVE_ZED       */
    { 208, 1  , 1  }    /* SUBMVREF_LEFT_ABOVE_ZED  */
};

static
213
const vp8_prob * get_sub_mv_ref_prob(const int left, const int above)
Scott LaVarnway's avatar
Scott LaVarnway committed
214
{
215
216
217
    int lez = (left == 0);
    int aez = (above == 0);
    int lea = (left == above);
Scott LaVarnway's avatar
Scott LaVarnway committed
218
219
220
221
222
223
224
225
226
    const vp8_prob * prob;

    prob = vp8_sub_mv_ref_prob3[(aez << 2) |
                                (lez << 1) |
                                (lea)];

    return prob;
}

227
static void decode_split_mv(vp8_reader *const bc, MODE_INFO *mi,
228
229
                        const MODE_INFO *left_mb, const MODE_INFO *above_mb,
                        MB_MODE_INFO *mbmi, int_mv best_mv,
230
231
232
233
                        MV_CONTEXT *const mvc, int mb_to_left_edge,
                        int mb_to_right_edge, int mb_to_top_edge,
                        int mb_to_bottom_edge)
{
Scott LaVarnway's avatar
Scott LaVarnway committed
234
235
236
    int s;      /* split configuration (16x8, 8x16, 8x8, 4x4) */
    int num_p;  /* number of partitions in the split configuration
                  (see vp8_mbsplit_count) */
237
238
    int j = 0;

Scott LaVarnway's avatar
Scott LaVarnway committed
239
240
241
242
243
244
245
246
247
248
249
250
251
    s = 3;
    num_p = 16;
    if( vp8_read(bc, 110) )
    {
        s = 2;
        num_p = 4;
        if( vp8_read(bc, 111) )
        {
            s = vp8_read(bc, 150);
            num_p = 2;
        }
    }

252
253
254
255
256
    do  /* for each subset j */
    {
        int_mv leftmv, abovemv;
        int_mv blockmv;
        int k;  /* first block in subset j */
Scott LaVarnway's avatar
Scott LaVarnway committed
257
258

        const vp8_prob *prob;
259
260
        k = vp8_mbsplit_offset[s][j];

261
262
263
264
265
266
267
268
269
270
        if (!(k & 3))
        {
            /* On L edge, get from MB to left of us */
            if(left_mb->mbmi.mode != SPLITMV)
                leftmv.as_int =  left_mb->mbmi.mv.as_int;
            else
                leftmv.as_int =  (left_mb->bmi + k + 4 - 1)->mv.as_int;
        }
        else
            leftmv.as_int =  (mi->bmi + k - 1)->mv.as_int;
271

272
273
274
275
276
277
278
279
280
281
        if (!(k >> 2))
        {
            /* On top edge, get from MB above us */
            if(above_mb->mbmi.mode != SPLITMV)
                abovemv.as_int =  above_mb->mbmi.mv.as_int;
            else
                abovemv.as_int =  (above_mb->bmi + k + 16 - 4)->mv.as_int;
        }
        else
            abovemv.as_int = (mi->bmi + k - 4)->mv.as_int;
Scott LaVarnway's avatar
Scott LaVarnway committed
282

283
        prob = get_sub_mv_ref_prob(leftmv.as_int, abovemv.as_int);
284

285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
        if( vp8_read(bc, prob[0]) )
        {
            if( vp8_read(bc, prob[1]) )
            {
                blockmv.as_int = 0;
                if( vp8_read(bc, prob[2]) )
                {
                    blockmv.as_mv.row = read_mvcomponent(bc, &mvc[0]) << 1;
                    blockmv.as_mv.row += best_mv.as_mv.row;
                    blockmv.as_mv.col = read_mvcomponent(bc, &mvc[1]) << 1;
                    blockmv.as_mv.col += best_mv.as_mv.col;
                }
            }
            else
            {
                blockmv.as_int = abovemv.as_int;
            }
        }
        else
        {
            blockmv.as_int = leftmv.as_int;
        }
307

308
309
310
311
312
313
        mbmi->need_to_clamp_mvs |= vp8_check_mv_bounds(&blockmv,
                                                  mb_to_left_edge,
                                                  mb_to_right_edge,
                                                  mb_to_top_edge,
                                                  mb_to_bottom_edge);

314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
        {
            /* Fill (uniform) modes, mvs of jth subset.
             Must do it here because ensuing subsets can
             refer back to us via "left" or "above". */
            const unsigned char *fill_offset;
            unsigned int fill_count = mbsplit_fill_count[s];

            fill_offset = &mbsplit_fill_offset[s]
                             [(unsigned char)j * mbsplit_fill_count[s]];

            do {
                mi->bmi[ *fill_offset].mv.as_int = blockmv.as_int;
                fill_offset++;
            }while (--fill_count);
        }

    }
    while (++j < num_p);
Scott LaVarnway's avatar
Scott LaVarnway committed
332
333

    mbmi->partitioning = s;
334
}
335

336
static void read_mb_modes_mv(VP8D_COMP *pbi, MODE_INFO *mi, MB_MODE_INFO *mbmi)
Scott LaVarnway's avatar
Scott LaVarnway committed
337
338
{
    vp8_reader *const bc = & pbi->bc;
Scott LaVarnway's avatar
Scott LaVarnway committed
339
340
341
342
343
344
345
346
347
348
349
350
351
    mbmi->ref_frame = (MV_REFERENCE_FRAME) vp8_read(bc, pbi->prob_intra);
    if (mbmi->ref_frame)    /* inter MB */
    {
        enum {CNT_INTRA, CNT_NEAREST, CNT_NEAR, CNT_SPLITMV};
        int cnt[4];
        int *cntx = cnt;
        int_mv near_mvs[4];
        int_mv *nmv = near_mvs;
        const int mis = pbi->mb.mode_info_stride;
        const MODE_INFO *above = mi - mis;
        const MODE_INFO *left = mi - 1;
        const MODE_INFO *aboveleft = above - 1;
        int *ref_frame_sign_bias = pbi->common.ref_frame_sign_bias;
Scott LaVarnway's avatar
Scott LaVarnway committed
352

Scott LaVarnway's avatar
Scott LaVarnway committed
353
        mbmi->need_to_clamp_mvs = 0;
Scott LaVarnway's avatar
Scott LaVarnway committed
354

Scott LaVarnway's avatar
Scott LaVarnway committed
355
356
357
358
359
        if (vp8_read(bc, pbi->prob_last))
        {
            mbmi->ref_frame =
                (MV_REFERENCE_FRAME)((int)(2 + vp8_read(bc, pbi->prob_gf)));
        }
Scott LaVarnway's avatar
Scott LaVarnway committed
360

Scott LaVarnway's avatar
Scott LaVarnway committed
361
362
363
        /* Zero accumulators */
        nmv[0].as_int = nmv[1].as_int = nmv[2].as_int = 0;
        cnt[0] = cnt[1] = cnt[2] = cnt[3] = 0;
Scott LaVarnway's avatar
Scott LaVarnway committed
364

Scott LaVarnway's avatar
Scott LaVarnway committed
365
366
367
368
369
370
371
372
373
374
        /* Process above */
        if (above->mbmi.ref_frame != INTRA_FRAME)
        {
            if (above->mbmi.mv.as_int)
            {
                (++nmv)->as_int = above->mbmi.mv.as_int;
                mv_bias(ref_frame_sign_bias[above->mbmi.ref_frame],
                        mbmi->ref_frame, nmv, ref_frame_sign_bias);
                ++cntx;
            }
Scott LaVarnway's avatar
Scott LaVarnway committed
375

Scott LaVarnway's avatar
Scott LaVarnway committed
376
377
            *cntx += 2;
        }
John Koleszar's avatar
John Koleszar committed
378

Scott LaVarnway's avatar
Scott LaVarnway committed
379
380
        /* Process left */
        if (left->mbmi.ref_frame != INTRA_FRAME)
John Koleszar's avatar
John Koleszar committed
381
        {
Scott LaVarnway's avatar
Scott LaVarnway committed
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
            if (left->mbmi.mv.as_int)
            {
                int_mv this_mv;

                this_mv.as_int = left->mbmi.mv.as_int;
                mv_bias(ref_frame_sign_bias[left->mbmi.ref_frame],
                        mbmi->ref_frame, &this_mv, ref_frame_sign_bias);

                if (this_mv.as_int != nmv->as_int)
                {
                    (++nmv)->as_int = this_mv.as_int;
                    ++cntx;
                }

                *cntx += 2;
            }
            else
                cnt[CNT_INTRA] += 2;
John Koleszar's avatar
John Koleszar committed
400
401
        }

Scott LaVarnway's avatar
Scott LaVarnway committed
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
        /* Process above left */
        if (aboveleft->mbmi.ref_frame != INTRA_FRAME)
        {
            if (aboveleft->mbmi.mv.as_int)
            {
                int_mv this_mv;

                this_mv.as_int = aboveleft->mbmi.mv.as_int;
                mv_bias(ref_frame_sign_bias[aboveleft->mbmi.ref_frame],
                        mbmi->ref_frame, &this_mv, ref_frame_sign_bias);

                if (this_mv.as_int != nmv->as_int)
                {
                    (++nmv)->as_int = this_mv.as_int;
                    ++cntx;
                }
John Koleszar's avatar
John Koleszar committed
418

Scott LaVarnway's avatar
Scott LaVarnway committed
419
420
421
422
423
424
                *cntx += 1;
            }
            else
                cnt[CNT_INTRA] += 1;
        }

425
        if( vp8_read(bc, vp8_mode_contexts [cnt[CNT_INTRA]] [0]) )
John Koleszar's avatar
John Koleszar committed
426
        {
Scott LaVarnway's avatar
Scott LaVarnway committed
427
428

            /* If we have three distinct MV's ... */
429
430
431
            /* See if above-left MV can be merged with NEAREST */
            cnt[CNT_NEAREST] += ( (cnt[CNT_SPLITMV] > 0) &
                (nmv->as_int == near_mvs[CNT_NEAREST].as_int));
Scott LaVarnway's avatar
Scott LaVarnway committed
432
433
434
435
436
437
438
439
440
441
442
443
444

            /* Swap near and nearest if necessary */
            if (cnt[CNT_NEAR] > cnt[CNT_NEAREST])
            {
                int tmp;
                tmp = cnt[CNT_NEAREST];
                cnt[CNT_NEAREST] = cnt[CNT_NEAR];
                cnt[CNT_NEAR] = tmp;
                tmp = near_mvs[CNT_NEAREST].as_int;
                near_mvs[CNT_NEAREST].as_int = near_mvs[CNT_NEAR].as_int;
                near_mvs[CNT_NEAR].as_int = tmp;
            }

445
            if( vp8_read(bc, vp8_mode_contexts [cnt[CNT_NEAREST]] [1]) )
446
            {
Scott LaVarnway's avatar
Scott LaVarnway committed
447

448
                if( vp8_read(bc, vp8_mode_contexts [cnt[CNT_NEAR]] [2]) )
Scott LaVarnway's avatar
Scott LaVarnway committed
449
                {
Scott LaVarnway's avatar
Scott LaVarnway committed
450
451
                    int mb_to_top_edge;
                    int mb_to_bottom_edge;
452
453
454
455
                    int mb_to_left_edge;
                    int mb_to_right_edge;
                    MV_CONTEXT *const mvc = pbi->common.fc.mvc;
                    int near_index;
Scott LaVarnway's avatar
Scott LaVarnway committed
456
457
458
459
460

                    mb_to_top_edge = pbi->mb.mb_to_top_edge;
                    mb_to_bottom_edge = pbi->mb.mb_to_bottom_edge;
                    mb_to_top_edge -= LEFT_TOP_MARGIN;
                    mb_to_bottom_edge += RIGHT_BOTTOM_MARGIN;
461
462
463
464
                    mb_to_right_edge = pbi->mb.mb_to_right_edge;
                    mb_to_right_edge += RIGHT_BOTTOM_MARGIN;
                    mb_to_left_edge = pbi->mb.mb_to_left_edge;
                    mb_to_left_edge -= LEFT_TOP_MARGIN;
Scott LaVarnway's avatar
Scott LaVarnway committed
465
466

                    /* Use near_mvs[0] to store the "best" MV */
467
468
                    near_index = CNT_INTRA +
                        (cnt[CNT_NEAREST] >= cnt[CNT_INTRA]);
Scott LaVarnway's avatar
Scott LaVarnway committed
469

470
                    vp8_clamp_mv2(&near_mvs[near_index], &pbi->mb);
Scott LaVarnway's avatar
Scott LaVarnway committed
471

472
473
474
                    cnt[CNT_SPLITMV] = ((above->mbmi.mode == SPLITMV)
                                        + (left->mbmi.mode == SPLITMV)) * 2
                                       + (aboveleft->mbmi.mode == SPLITMV);
Scott LaVarnway's avatar
Scott LaVarnway committed
475

476
                    if( vp8_read(bc, vp8_mode_contexts [cnt[CNT_SPLITMV]] [3]) )
Scott LaVarnway's avatar
Scott LaVarnway committed
477
                    {
478
479
480
                        decode_split_mv(bc, mi, left, above,
                                                    mbmi,
                                                    near_mvs[near_index],
Scott LaVarnway's avatar
Scott LaVarnway committed
481
482
483
484
485
                                                    mvc, mb_to_left_edge,
                                                    mb_to_right_edge,
                                                    mb_to_top_edge,
                                                    mb_to_bottom_edge);
                        mbmi->mv.as_int = mi->bmi[15].mv.as_int;
Scott LaVarnway's avatar
Scott LaVarnway committed
486
                        mbmi->mode =  SPLITMV;
Scott LaVarnway's avatar
Scott LaVarnway committed
487
                        mbmi->is_4x4 = 1;
Scott LaVarnway's avatar
Scott LaVarnway committed
488
489
490
                    }
                    else
                    {
Scott LaVarnway's avatar
Scott LaVarnway committed
491
492
                        int_mv *const mbmi_mv = & mbmi->mv;
                        read_mv(bc, &mbmi_mv->as_mv, (const MV_CONTEXT *) mvc);
493
494
                        mbmi_mv->as_mv.row += near_mvs[near_index].as_mv.row;
                        mbmi_mv->as_mv.col += near_mvs[near_index].as_mv.col;
Scott LaVarnway's avatar
Scott LaVarnway committed
495
496
497
498
499
500
501

                        /* 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.
                         */
                        mbmi->need_to_clamp_mvs =
Scott LaVarnway's avatar
Scott LaVarnway committed
502
                            vp8_check_mv_bounds(mbmi_mv, mb_to_left_edge,
Scott LaVarnway's avatar
Scott LaVarnway committed
503
504
505
506
507
508
509
510
511
                                                mb_to_right_edge,
                                                mb_to_top_edge,
                                                mb_to_bottom_edge);
                        mbmi->mode =  NEWMV;
                    }
                }
                else
                {
                    mbmi->mode =  NEARMV;
Scott LaVarnway's avatar
Scott LaVarnway committed
512
513
                    vp8_clamp_mv2(&near_mvs[CNT_NEAR], &pbi->mb);
                    mbmi->mv.as_int = near_mvs[CNT_NEAR].as_int;
Scott LaVarnway's avatar
Scott LaVarnway committed
514
515
516
517
518
                }
            }
            else
            {
                mbmi->mode =  NEARESTMV;
Scott LaVarnway's avatar
Scott LaVarnway committed
519
520
                vp8_clamp_mv2(&near_mvs[CNT_NEAREST], &pbi->mb);
                mbmi->mv.as_int = near_mvs[CNT_NEAREST].as_int;
521
            }
Scott LaVarnway's avatar
Scott LaVarnway committed
522
        }
523
524
        else
        {
Scott LaVarnway's avatar
Scott LaVarnway committed
525
526
527
528
529
            mbmi->mode =  ZEROMV;
            mbmi->mv.as_int = 0;
        }

#if CONFIG_ERROR_CONCEALMENT
530
        if(pbi->ec_enabled && (mbmi->mode != SPLITMV))
Scott LaVarnway's avatar
Scott LaVarnway committed
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
        {
            mi->bmi[ 0].mv.as_int =
            mi->bmi[ 1].mv.as_int =
            mi->bmi[ 2].mv.as_int =
            mi->bmi[ 3].mv.as_int =
            mi->bmi[ 4].mv.as_int =
            mi->bmi[ 5].mv.as_int =
            mi->bmi[ 6].mv.as_int =
            mi->bmi[ 7].mv.as_int =
            mi->bmi[ 8].mv.as_int =
            mi->bmi[ 9].mv.as_int =
            mi->bmi[10].mv.as_int =
            mi->bmi[11].mv.as_int =
            mi->bmi[12].mv.as_int =
            mi->bmi[13].mv.as_int =
            mi->bmi[14].mv.as_int =
Scott LaVarnway's avatar
Scott LaVarnway committed
547
            mi->bmi[15].mv.as_int = mbmi->mv.as_int;
Scott LaVarnway's avatar
Scott LaVarnway committed
548
549
        }
#endif
Scott LaVarnway's avatar
Scott LaVarnway committed
550
551
552
    }
    else
    {
Scott LaVarnway's avatar
Scott LaVarnway committed
553
554
        /* required for left and above block mv */
        mbmi->mv.as_int = 0;
John Koleszar's avatar
John Koleszar committed
555

Scott LaVarnway's avatar
Scott LaVarnway committed
556
        /* MB is intra coded */
557
        if ((mbmi->mode = read_ymode(bc, pbi->common.fc.ymode_prob)) == B_PRED)
Scott LaVarnway's avatar
Scott LaVarnway committed
558
        {
Scott LaVarnway's avatar
Scott LaVarnway committed
559
            int j = 0;
Scott LaVarnway's avatar
Scott LaVarnway committed
560
            mbmi->is_4x4 = 1;
Scott LaVarnway's avatar
Scott LaVarnway committed
561
562
            do
            {
563
                mi->bmi[j].as_mode = read_bmode(bc, pbi->common.fc.bmode_prob);
Scott LaVarnway's avatar
Scott LaVarnway committed
564
565
566
            }
            while (++j < 16);
        }
John Koleszar's avatar
John Koleszar committed
567

568
        mbmi->uv_mode = read_uv_mode(bc, pbi->common.fc.uv_mode_prob);
Scott LaVarnway's avatar
Scott LaVarnway committed
569
    }
John Koleszar's avatar
John Koleszar committed
570

Scott LaVarnway's avatar
Scott LaVarnway committed
571
}
John Koleszar's avatar
John Koleszar committed
572

573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
static void read_mb_features(vp8_reader *r, MB_MODE_INFO *mi, MACROBLOCKD *x)
{
    /* Is segmentation enabled */
    if (x->segmentation_enabled && x->update_mb_segmentation_map)
    {
        /* If so then read the segment id. */
        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]));
    }
}

static void decode_mb_mode_mvs(VP8D_COMP *pbi, MODE_INFO *mi,
589
                               MB_MODE_INFO *mbmi)
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
{
    /* Read the Macroblock segmentation map if it is being updated explicitly
     * this frame (reset to 0 above by default)
     * By default on a key frame reset all MBs to segment 0
     */
    if (pbi->mb.update_mb_segmentation_map)
        read_mb_features(&pbi->bc, &mi->mbmi, &pbi->mb);
    else if(pbi->common.frame_type == KEY_FRAME)
        mi->mbmi.segment_id = 0;

    /* Read the macroblock coeff skip flag if this feature is in use,
     * else default to 0 */
    if (pbi->common.mb_no_coeff_skip)
        mi->mbmi.mb_skip_coeff = vp8_read(&pbi->bc, pbi->prob_skip_false);
    else
        mi->mbmi.mb_skip_coeff = 0;

Scott LaVarnway's avatar
Scott LaVarnway committed
607
    mi->mbmi.is_4x4 = 0;
608
609
610
    if(pbi->common.frame_type == KEY_FRAME)
        read_kf_modes(pbi, mi);
    else
611
        read_mb_modes_mv(pbi, mi, &mi->mbmi);
612
613
614

}

Scott LaVarnway's avatar
Scott LaVarnway committed
615
616
617
618
void vp8_decode_mode_mvs(VP8D_COMP *pbi)
{
    MODE_INFO *mi = pbi->common.mi;
    int mb_row = -1;
619
    int mb_to_right_edge_start;
John Koleszar's avatar
John Koleszar committed
620

621
    mb_mode_mv_init(pbi);
John Koleszar's avatar
John Koleszar committed
622

623
624
625
626
    pbi->mb.mb_to_top_edge = 0;
    pbi->mb.mb_to_bottom_edge = ((pbi->common.mb_rows - 1) * 16) << 3;
    mb_to_right_edge_start = ((pbi->common.mb_cols - 1) * 16) << 3;

Scott LaVarnway's avatar
Scott LaVarnway committed
627
628
629
    while (++mb_row < pbi->common.mb_rows)
    {
        int mb_col = -1;
John Koleszar's avatar
John Koleszar committed
630

631
632
        pbi->mb.mb_to_left_edge =  0;
        pbi->mb.mb_to_right_edge = mb_to_right_edge_start;
John Koleszar's avatar
John Koleszar committed
633

Scott LaVarnway's avatar
Scott LaVarnway committed
634
635
        while (++mb_col < pbi->common.mb_cols)
        {
636
#if CONFIG_ERROR_CONCEALMENT
637
            int mb_num = mb_row * pbi->common.mb_cols + mb_col;
638
#endif
639

640
            decode_mb_mode_mvs(pbi, mi, &mi->mbmi);
John Koleszar's avatar
John Koleszar committed
641

642
643
644
#if CONFIG_ERROR_CONCEALMENT
            /* look for corruption. set mvs_corrupt_from_mb to the current
             * mb_num if the frame is corrupt from this macroblock. */
Yaowu Xu's avatar
Yaowu Xu committed
645
646
            if (vp8dx_bool_error(&pbi->bc) && mb_num <
                (int)pbi->mvs_corrupt_from_mb)
647
648
649
650
651
652
653
654
655
            {
                pbi->mvs_corrupt_from_mb = mb_num;
                /* no need to continue since the partition is corrupt from
                 * here on.
                 */
                return;
            }
#endif

656
657
            pbi->mb.mb_to_left_edge -= (16 << 3);
            pbi->mb.mb_to_right_edge -= (16 << 3);
658
            mi++;       /* next macroblock */
John Koleszar's avatar
John Koleszar committed
659
        }
660
661
        pbi->mb.mb_to_top_edge -= (16 << 3);
        pbi->mb.mb_to_bottom_edge -= (16 << 3);
John Koleszar's avatar
John Koleszar committed
662

663
        mi++;           /* skip left predictor each row */
John Koleszar's avatar
John Koleszar committed
664
665
    }
}