vp9_pred_common.c 20.5 KB
Newer Older
Ronald S. Bultje's avatar
Ronald S. Bultje committed
1

2
/*
Paul Wilkins's avatar
Paul Wilkins committed
3
 *  Copyright (c) 2012 The WebM project authors. All Rights Reserved.
4
5
6
7
8
9
10
11
 *
 *  Use of this source code is governed by a BSD-style license
 *  that can be found in the LICENSE file in the root of the source
 *  tree. An additional intellectual property rights grant can be found
 *  in the file PATENTS.  All contributing project authors may
 *  be found in the AUTHORS file in the root of the source tree.
 */

12
13
#include <limits.h>

Ronald S. Bultje's avatar
Ronald S. Bultje committed
14
#include "vp9/common/vp9_common.h"
15
16
#include "vp9/common/vp9_pred_common.h"
#include "vp9/common/vp9_seg_common.h"
17
#include "vp9/common/vp9_treecoder.h"
18
19
20
21

// TBD prediction functions for various bitstream signals

// Returns a context number for the given MB prediction signal
22
unsigned char vp9_get_pred_context(const VP9_COMMON *const cm,
Paul Wilkins's avatar
Paul Wilkins committed
23
24
                                   const MACROBLOCKD *const xd,
                                   PRED_ID pred_id) {
John Koleszar's avatar
John Koleszar committed
25
  int pred_context;
26
27
28
  const MODE_INFO *const mi = xd->mode_info_context;
  const MODE_INFO *const above_mi = mi - cm->mode_info_stride;
  const MODE_INFO *const left_mi = mi - 1;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
29
30
  const int left_in_image = xd->left_available && left_mi->mbmi.mb_in_image;
  const int above_in_image = xd->up_available && above_mi->mbmi.mb_in_image;
John Koleszar's avatar
John Koleszar committed
31
32
33
34
35
  // Note:
  // The mode info data structure has a one element border above and to the
  // left of the entries correpsonding to real macroblocks.
  // The prediction flags in these dummy entries are initialised to 0.
  switch (pred_id) {
36
    case PRED_SEG_ID:
37
      pred_context = above_mi->mbmi.seg_id_predicted;
38
      if (xd->left_available)
39
        pred_context += left_mi->mbmi.seg_id_predicted;
John Koleszar's avatar
John Koleszar committed
40
      break;
41

42
    case PRED_MBSKIP:
43
      pred_context = above_mi->mbmi.mb_skip_coeff;
44
      if (xd->left_available)
45
        pred_context += left_mi->mbmi.mb_skip_coeff;
John Koleszar's avatar
John Koleszar committed
46
      break;
47

48
49
    case PRED_SWITCHABLE_INTERP: {
      // left
50
      const int left_mv_pred = is_inter_mode(left_mi->mbmi.mode);
51
52
53
54
55
      const int left_interp = left_in_image && left_mv_pred ?
                    vp9_switchable_interp_map[left_mi->mbmi.interp_filter] :
                    VP9_SWITCHABLE_FILTERS;

      // above
56
      const int above_mv_pred = is_inter_mode(above_mi->mbmi.mode);
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
      const int above_interp = above_in_image && above_mv_pred ?
                    vp9_switchable_interp_map[above_mi->mbmi.interp_filter] :
                    VP9_SWITCHABLE_FILTERS;

      assert(left_interp != -1);
      assert(above_interp != -1);

      if (left_interp == above_interp)
        pred_context = left_interp;
      else if (left_interp == VP9_SWITCHABLE_FILTERS &&
               above_interp != VP9_SWITCHABLE_FILTERS)
         pred_context = above_interp;
      else if (left_interp != VP9_SWITCHABLE_FILTERS &&
               above_interp == VP9_SWITCHABLE_FILTERS)
        pred_context = left_interp;
      else
        pred_context = VP9_SWITCHABLE_FILTERS;

75
      break;
76
    }
77

Ronald S. Bultje's avatar
Ronald S. Bultje committed
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
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
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
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
341
342
343
344
345
346
347
348
349
350
    case PRED_INTRA_INTER: {
      if (above_in_image && left_in_image) {  // both edges available
        if (left_mi->mbmi.ref_frame[0] == INTRA_FRAME &&
            above_mi->mbmi.ref_frame[0] == INTRA_FRAME) {  // intra/intra (3)
          pred_context = 3;
        } else {  // intra/inter (1) or inter/inter (0)
          pred_context = left_mi->mbmi.ref_frame[0] == INTRA_FRAME ||
                         above_mi->mbmi.ref_frame[0] == INTRA_FRAME;
        }
      } else if (above_in_image || left_in_image) {  // one edge available
        const MODE_INFO *edge = above_in_image ? above_mi : left_mi;

        // inter: 0, intra: 2
        pred_context = 2 * (edge->mbmi.ref_frame[0] == INTRA_FRAME);
      } else {
        pred_context = 0;
      }
      assert(pred_context >= 0 && pred_context < INTRA_INTER_CONTEXTS);
      break;
    }

    case PRED_COMP_INTER_INTER: {
      if (above_in_image && left_in_image) {  // both edges available
        if (above_mi->mbmi.ref_frame[1] <= INTRA_FRAME &&
            left_mi->mbmi.ref_frame[1] <= INTRA_FRAME) {
          // neither edge uses comp pred (0/1)
          pred_context = ((above_mi->mbmi.ref_frame[0] == cm->comp_fixed_ref) ^
                          (left_mi->mbmi.ref_frame[0] == cm->comp_fixed_ref));
        } else if (above_mi->mbmi.ref_frame[1] <= INTRA_FRAME) {
          // one of two edges uses comp pred (2/3)
          pred_context = 2 +
              (above_mi->mbmi.ref_frame[0] == cm->comp_fixed_ref ||
               above_mi->mbmi.ref_frame[0] == INTRA_FRAME);
        } else if (left_mi->mbmi.ref_frame[1] <= INTRA_FRAME) {
          // one of two edges uses comp pred (2/3)
          pred_context = 2 +
              (left_mi->mbmi.ref_frame[0] == cm->comp_fixed_ref ||
               left_mi->mbmi.ref_frame[0] == INTRA_FRAME);
        } else {  // both edges use comp pred (4)
          pred_context = 4;
        }
      } else if (above_in_image || left_in_image) {  // one edge available
        const MODE_INFO *edge = above_in_image ? above_mi : left_mi;

        if (edge->mbmi.ref_frame[1] <= INTRA_FRAME) {
          // edge does not use comp pred (0/1)
          pred_context = edge->mbmi.ref_frame[0] == cm->comp_fixed_ref;
        } else {  // edge uses comp pred (3)
          pred_context = 3;
        }
      } else {  // no edges available (1)
        pred_context = 1;
      }
      assert(pred_context >= 0 && pred_context < COMP_INTER_CONTEXTS);
      break;
    }

    case PRED_COMP_REF_P: {
      const int fix_ref_idx = cm->ref_frame_sign_bias[cm->comp_fixed_ref];
      const int var_ref_idx = !fix_ref_idx;

      if (above_in_image && left_in_image) {  // both edges available
        if (above_mi->mbmi.ref_frame[0] == INTRA_FRAME &&
            left_mi->mbmi.ref_frame[0] == INTRA_FRAME) {  // intra/intra (2)
          pred_context = 2;
        } else if (above_mi->mbmi.ref_frame[0] == INTRA_FRAME ||
                   left_mi->mbmi.ref_frame[0] == INTRA_FRAME) {  // intra/inter
          const MODE_INFO *edge = above_mi->mbmi.ref_frame[0] == INTRA_FRAME ?
                                  left_mi : above_mi;

          if (edge->mbmi.ref_frame[1] <= INTRA_FRAME) {  // single pred (1/3)
            pred_context = 1 +
                2 * edge->mbmi.ref_frame[0] != cm->comp_var_ref[1];
          } else {  // comp pred (1/3)
            pred_context = 1 +
                2 * edge->mbmi.ref_frame[var_ref_idx] != cm->comp_var_ref[1];
          }
        } else {  // inter/inter
          int l_sg = left_mi->mbmi.ref_frame[1] <= INTRA_FRAME;
          int a_sg = above_mi->mbmi.ref_frame[1] <= INTRA_FRAME;
          MV_REFERENCE_FRAME vrfa = a_sg ? above_mi->mbmi.ref_frame[0] :
              above_mi->mbmi.ref_frame[var_ref_idx];
          MV_REFERENCE_FRAME vrfl = l_sg ? left_mi->mbmi.ref_frame[0] :
              left_mi->mbmi.ref_frame[var_ref_idx];

          if (vrfa == vrfl && cm->comp_var_ref[1] == vrfa) {
            pred_context = 0;
          } else if (l_sg && a_sg) {  // single/single
            if ((vrfa == cm->comp_fixed_ref && vrfl == cm->comp_var_ref[0]) ||
                (vrfl == cm->comp_fixed_ref && vrfa == cm->comp_var_ref[0])) {
              pred_context = 4;
            } else if (vrfa == vrfl) {
              pred_context = 3;
            } else {
              pred_context = 1;
            }
          } else if (l_sg || a_sg) {  // single/comp
            MV_REFERENCE_FRAME vrfc = l_sg ? vrfa : vrfl;
            MV_REFERENCE_FRAME rfs = a_sg ? vrfa : vrfl;

            if (vrfc == cm->comp_var_ref[1] && rfs != cm->comp_var_ref[1]) {
              pred_context = 1;
            } else if (rfs == cm->comp_var_ref[1] &&
                       vrfc != cm->comp_var_ref[1]) {
              pred_context = 2;
            } else {
              pred_context = 4;
            }
          } else if (vrfa == vrfl) {  // comp/comp
            pred_context = 4;
          } else {
            pred_context = 2;
          }
        }
      } else if (above_in_image || left_in_image) {  // one edge available
        const MODE_INFO *edge = above_in_image ? above_mi : left_mi;

        if (edge->mbmi.ref_frame[0] == INTRA_FRAME) {
          pred_context = 2;
        } else if (edge->mbmi.ref_frame[1] > INTRA_FRAME) {
          pred_context =
              4 * edge->mbmi.ref_frame[var_ref_idx] != cm->comp_var_ref[1];
        } else {
          pred_context = 3 * edge->mbmi.ref_frame[0] != cm->comp_var_ref[1];
        }
      } else {  // no edges available (2)
        pred_context = 2;
      }
      assert(pred_context >= 0 && pred_context < REF_CONTEXTS);
      break;
    }

    case PRED_SINGLE_REF_P1: {
      if (above_in_image && left_in_image) {  // both edges available
        if (above_mi->mbmi.ref_frame[0] == INTRA_FRAME &&
            left_mi->mbmi.ref_frame[0] == INTRA_FRAME) {
          pred_context = 2;
        } else if (above_mi->mbmi.ref_frame[0] == INTRA_FRAME ||
                   left_mi->mbmi.ref_frame[0] == INTRA_FRAME) {
          const MODE_INFO *edge = above_mi->mbmi.ref_frame[0] == INTRA_FRAME ?
                                  left_mi : above_mi;

          if (edge->mbmi.ref_frame[1] <= INTRA_FRAME) {
            pred_context = 4 * (edge->mbmi.ref_frame[0] == LAST_FRAME);
          } else {
            pred_context = 1 + (edge->mbmi.ref_frame[0] == LAST_FRAME ||
                                edge->mbmi.ref_frame[1] == LAST_FRAME);
          }
        } else if (above_mi->mbmi.ref_frame[1] <= INTRA_FRAME &&
                   left_mi->mbmi.ref_frame[1] <= INTRA_FRAME) {
          pred_context = 2 * (above_mi->mbmi.ref_frame[0] == LAST_FRAME) +
                         2 * (left_mi->mbmi.ref_frame[0] == LAST_FRAME);
        } else if (above_mi->mbmi.ref_frame[1] > INTRA_FRAME &&
                   left_mi->mbmi.ref_frame[1] > INTRA_FRAME) {
          pred_context = 1 + (above_mi->mbmi.ref_frame[0] == LAST_FRAME ||
                              above_mi->mbmi.ref_frame[1] == LAST_FRAME ||
                              left_mi->mbmi.ref_frame[0] == LAST_FRAME ||
                              left_mi->mbmi.ref_frame[1] == LAST_FRAME);
        } else {
          MV_REFERENCE_FRAME rfs = above_mi->mbmi.ref_frame[1] <= INTRA_FRAME ?
              above_mi->mbmi.ref_frame[0] : left_mi->mbmi.ref_frame[0];
          MV_REFERENCE_FRAME crf1 = above_mi->mbmi.ref_frame[1] > INTRA_FRAME ?
              above_mi->mbmi.ref_frame[0] : left_mi->mbmi.ref_frame[0];
          MV_REFERENCE_FRAME crf2 = above_mi->mbmi.ref_frame[1] > INTRA_FRAME ?
              above_mi->mbmi.ref_frame[1] : left_mi->mbmi.ref_frame[1];

          if (rfs == LAST_FRAME) {
            pred_context = 3 + (crf1 == LAST_FRAME || crf2 == LAST_FRAME);
          } else {
            pred_context = crf1 == LAST_FRAME || crf2 == LAST_FRAME;
          }
        }
      } else if (above_in_image || left_in_image) {  // one edge available
        const MODE_INFO *edge = above_in_image ? above_mi : left_mi;

        if (edge->mbmi.ref_frame[0] == INTRA_FRAME) {
          pred_context = 2;
        } else if (edge->mbmi.ref_frame[1] <= INTRA_FRAME) {
          pred_context = 4 * (edge->mbmi.ref_frame[0] == LAST_FRAME);
        } else {
          pred_context = 1 + (edge->mbmi.ref_frame[0] == LAST_FRAME ||
                              edge->mbmi.ref_frame[1] == LAST_FRAME);
        }
      } else {  // no edges available (2)
        pred_context = 2;
      }
      assert(pred_context >= 0 && pred_context < REF_CONTEXTS);
      break;
    }

    case PRED_SINGLE_REF_P2: {
      if (above_in_image && left_in_image) {  // both edges available
        if (above_mi->mbmi.ref_frame[0] == INTRA_FRAME &&
            left_mi->mbmi.ref_frame[0] == INTRA_FRAME) {
          pred_context = 2;
        } else if (above_mi->mbmi.ref_frame[0] == INTRA_FRAME ||
                   left_mi->mbmi.ref_frame[0] == INTRA_FRAME) {
          const MODE_INFO *edge = above_mi->mbmi.ref_frame[0] == INTRA_FRAME ?
                                  left_mi : above_mi;

          if (edge->mbmi.ref_frame[1] <= INTRA_FRAME) {
            if (edge->mbmi.ref_frame[0] == LAST_FRAME) {
              pred_context = 3;
            } else {
              pred_context = 4 * (edge->mbmi.ref_frame[0] == GOLDEN_FRAME);
            }
          } else {
            pred_context = 1 + 2 * (edge->mbmi.ref_frame[0] == GOLDEN_FRAME ||
                                    edge->mbmi.ref_frame[1] == GOLDEN_FRAME);
          }
        } else if (above_mi->mbmi.ref_frame[1] <= INTRA_FRAME &&
                   left_mi->mbmi.ref_frame[1] <= INTRA_FRAME) {
          if (above_mi->mbmi.ref_frame[0] == LAST_FRAME &&
              left_mi->mbmi.ref_frame[0] == LAST_FRAME) {
            pred_context = 3;
          } else if (above_mi->mbmi.ref_frame[0] == LAST_FRAME ||
                     left_mi->mbmi.ref_frame[0] == LAST_FRAME) {
            const MODE_INFO *edge = above_mi->mbmi.ref_frame[0] == LAST_FRAME ?
                                    left_mi : above_mi;

            pred_context = 4 * (edge->mbmi.ref_frame[0] == GOLDEN_FRAME);
          } else {
            pred_context = 2 * (above_mi->mbmi.ref_frame[0] == GOLDEN_FRAME) +
                           2 * (left_mi->mbmi.ref_frame[0] == GOLDEN_FRAME);
          }
        } else if (above_mi->mbmi.ref_frame[1] > INTRA_FRAME &&
                   left_mi->mbmi.ref_frame[1] > INTRA_FRAME) {
          if (above_mi->mbmi.ref_frame[0] == left_mi->mbmi.ref_frame[0] &&
              above_mi->mbmi.ref_frame[1] == left_mi->mbmi.ref_frame[1]) {
            pred_context = 3 * (above_mi->mbmi.ref_frame[0] == GOLDEN_FRAME ||
                                above_mi->mbmi.ref_frame[1] == GOLDEN_FRAME ||
                                left_mi->mbmi.ref_frame[0] == GOLDEN_FRAME ||
                                left_mi->mbmi.ref_frame[1] == GOLDEN_FRAME);
          } else {
            pred_context = 2;
          }
        } else {
          MV_REFERENCE_FRAME rfs = above_mi->mbmi.ref_frame[1] <= INTRA_FRAME ?
              above_mi->mbmi.ref_frame[0] : left_mi->mbmi.ref_frame[0];
          MV_REFERENCE_FRAME crf1 = above_mi->mbmi.ref_frame[1] > INTRA_FRAME ?
              above_mi->mbmi.ref_frame[0] : left_mi->mbmi.ref_frame[0];
          MV_REFERENCE_FRAME crf2 = above_mi->mbmi.ref_frame[1] > INTRA_FRAME ?
              above_mi->mbmi.ref_frame[1] : left_mi->mbmi.ref_frame[1];

          if (rfs == GOLDEN_FRAME) {
            pred_context = 3 + (crf1 == GOLDEN_FRAME || crf2 == GOLDEN_FRAME);
          } else if (rfs == ALTREF_FRAME) {
            pred_context = crf1 == GOLDEN_FRAME || crf2 == GOLDEN_FRAME;
          } else {
            pred_context =
                1 + 2 * (crf1 == GOLDEN_FRAME || crf2 == GOLDEN_FRAME);
          }
        }
      } else if (above_in_image || left_in_image) {  // one edge available
        const MODE_INFO *edge = above_in_image ? above_mi : left_mi;

        if (edge->mbmi.ref_frame[0] == INTRA_FRAME ||
            (edge->mbmi.ref_frame[0] == LAST_FRAME &&
             edge->mbmi.ref_frame[1] <= INTRA_FRAME)) {
          pred_context = 2;
        } else if (edge->mbmi.ref_frame[1] <= INTRA_FRAME) {
          pred_context = 4 * (edge->mbmi.ref_frame[0] == GOLDEN_FRAME);
        } else {
          pred_context = 3 * (edge->mbmi.ref_frame[0] == GOLDEN_FRAME ||
                              edge->mbmi.ref_frame[1] == GOLDEN_FRAME);
        }
      } else {  // no edges available (2)
        pred_context = 2;
      }
      assert(pred_context >= 0 && pred_context < REF_CONTEXTS);
      break;
    }

351
352
353
354
355
356
357
358
359
360
361
    case PRED_TX_SIZE: {
      int above_context = TX_16X16, left_context = TX_16X16;
      int max_tx_size;
      if (mi->mbmi.sb_type < BLOCK_SIZE_SB8X8)
        max_tx_size = TX_4X4;
      else if (mi->mbmi.sb_type < BLOCK_SIZE_MB16X16)
        max_tx_size = TX_8X8;
      else if (mi->mbmi.sb_type < BLOCK_SIZE_SB32X32)
        max_tx_size = TX_16X16;
      else
        max_tx_size = TX_32X32;
Deb Mukherjee's avatar
Deb Mukherjee committed
362
      if (above_in_image) {
363
364
365
        above_context = (above_mi->mbmi.mb_skip_coeff ?
                         max_tx_size : above_mi->mbmi.txfm_size);
      }
Deb Mukherjee's avatar
Deb Mukherjee committed
366
      if (left_in_image) {
367
368
369
        left_context = (left_mi->mbmi.mb_skip_coeff ?
                        max_tx_size : left_mi->mbmi.txfm_size);
      }
Deb Mukherjee's avatar
Deb Mukherjee committed
370
      if (!left_in_image) {
371
372
        left_context = above_context;
      }
Deb Mukherjee's avatar
Deb Mukherjee committed
373
      if (!above_in_image) {
374
375
376
377
378
379
380
381
        above_context = left_context;
      }
      pred_context = (above_context + left_context + 1) >> 1;
      if (pred_context > max_tx_size)
        pred_context = max_tx_size;
      break;
    }

382
    default:
Ronald S. Bultje's avatar
Ronald S. Bultje committed
383
      assert(0);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
384
      pred_context = 0;  // *** add error trap code.
John Koleszar's avatar
John Koleszar committed
385
386
      break;
  }
387

John Koleszar's avatar
John Koleszar committed
388
  return pred_context;
389
390
391
392
}

// This function returns a context probability for coding a given
// prediction signal
393
vp9_prob vp9_get_pred_prob(const VP9_COMMON *const cm,
Paul Wilkins's avatar
Paul Wilkins committed
394
395
                          const MACROBLOCKD *const xd,
                          PRED_ID pred_id) {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
396
  const int pred_context = vp9_get_pred_context(cm, xd, pred_id);
John Koleszar's avatar
John Koleszar committed
397
398

  switch (pred_id) {
399
    case PRED_SEG_ID:
Dmitry Kovalev's avatar
Dmitry Kovalev committed
400
      return cm->segment_pred_probs[pred_context];
401
    case PRED_MBSKIP:
Deb Mukherjee's avatar
Deb Mukherjee committed
402
      return cm->fc.mbskip_probs[pred_context];
Ronald S. Bultje's avatar
Ronald S. Bultje committed
403
404
405
406
407
408
409
410
411
412
    case PRED_INTRA_INTER:
      return cm->fc.intra_inter_prob[pred_context];
    case PRED_COMP_INTER_INTER:
      return cm->fc.comp_inter_prob[pred_context];
    case PRED_COMP_REF_P:
      return cm->fc.comp_ref_prob[pred_context];
    case PRED_SINGLE_REF_P1:
      return cm->fc.single_ref_prob[pred_context][0];
    case PRED_SINGLE_REF_P2:
      return cm->fc.single_ref_prob[pred_context][1];
413
    default:
Ronald S. Bultje's avatar
Ronald S. Bultje committed
414
      assert(0);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
415
      return 128;  // *** add error trap code.
John Koleszar's avatar
John Koleszar committed
416
  }
417
418
}

419
420
// This function returns a context probability ptr for coding a given
// prediction signal
421
const vp9_prob *vp9_get_pred_probs(const VP9_COMMON *const cm,
Paul Wilkins's avatar
Paul Wilkins committed
422
423
                                   const MACROBLOCKD *const xd,
                                   PRED_ID pred_id) {
424
  const MODE_INFO *const mi = xd->mode_info_context;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
425
  const int pred_context = vp9_get_pred_context(cm, xd, pred_id);
426
427
428

  switch (pred_id) {
    case PRED_SWITCHABLE_INTERP:
Dmitry Kovalev's avatar
Dmitry Kovalev committed
429
      return &cm->fc.switchable_interp_prob[pred_context][0];
430
431
432
433
434
435
436
437
438

    case PRED_TX_SIZE:
      if (mi->mbmi.sb_type < BLOCK_SIZE_MB16X16)
        return cm->fc.tx_probs_8x8p[pred_context];
      else if (mi->mbmi.sb_type < BLOCK_SIZE_SB32X32)
        return cm->fc.tx_probs_16x16p[pred_context];
      else
        return cm->fc.tx_probs_32x32p[pred_context];

439
    default:
Ronald S. Bultje's avatar
Ronald S. Bultje committed
440
      assert(0);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
441
      return NULL;  // *** add error trap code.
442
443
444
  }
}

445
446
// This function returns the status of the given prediction signal.
// I.e. is the predicted value for the given signal correct.
Paul Wilkins's avatar
Paul Wilkins committed
447
448
unsigned char vp9_get_pred_flag(const MACROBLOCKD *const xd,
                                PRED_ID pred_id) {
John Koleszar's avatar
John Koleszar committed
449
  switch (pred_id) {
450
    case PRED_SEG_ID:
Dmitry Kovalev's avatar
Dmitry Kovalev committed
451
      return xd->mode_info_context->mbmi.seg_id_predicted;
452
    case PRED_MBSKIP:
Dmitry Kovalev's avatar
Dmitry Kovalev committed
453
      return xd->mode_info_context->mbmi.mb_skip_coeff;
454
    default:
Ronald S. Bultje's avatar
Ronald S. Bultje committed
455
      assert(0);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
456
      return 0;  // *** add error trap code.
John Koleszar's avatar
John Koleszar committed
457
  }
458
459
460
461
}

// This function sets the status of the given prediction signal.
// I.e. is the predicted value for the given signal correct.
Paul Wilkins's avatar
Paul Wilkins committed
462
463
464
void vp9_set_pred_flag(MACROBLOCKD *const xd,
                       PRED_ID pred_id,
                       unsigned char pred_flag) {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
465
  const int mis = xd->mode_info_stride;
466
  BLOCK_SIZE_TYPE bsize = xd->mode_info_context->mbmi.sb_type;
467
468
  const int bh = 1 << mi_height_log2(bsize);
  const int bw = 1 << mi_width_log2(bsize);
469
#define sub(a, b) (b) < 0 ? (a) + (b) : (a)
470
471
  const int x_mis = sub(bw, xd->mb_to_right_edge >> (3 + LOG2_MI_SIZE));
  const int y_mis = sub(bh, xd->mb_to_bottom_edge >> (3 + LOG2_MI_SIZE));
472
473
#undef sub
  int x, y;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
474

John Koleszar's avatar
John Koleszar committed
475
  switch (pred_id) {
476
    case PRED_SEG_ID:
477
478
479
      for (y = 0; y < y_mis; y++) {
        for (x = 0; x < x_mis; x++) {
          xd->mode_info_context[y * mis + x].mbmi.seg_id_predicted = pred_flag;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
480
        }
Ronald S. Bultje's avatar
Ronald S. Bultje committed
481
      }
John Koleszar's avatar
John Koleszar committed
482
      break;
483

484
    case PRED_MBSKIP:
485
486
      for (y = 0; y < y_mis; y++) {
        for (x = 0; x < x_mis; x++) {
487
          xd->mode_info_context[y * mis + x].mbmi.mb_skip_coeff = pred_flag;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
488
489
        }
      }
John Koleszar's avatar
John Koleszar committed
490
      break;
491

492
    default:
Ronald S. Bultje's avatar
Ronald S. Bultje committed
493
      assert(0);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
494
      // *** add error trap code.
John Koleszar's avatar
John Koleszar committed
495
496
      break;
  }
497
498
499
500
501
502
503
}


// The following contain the guts of the prediction code used to
// peredict various bitstream signals.

// Macroblock segment id prediction function
504
505
506
507
508
509
510
511
512
513
514
515
516
517
int vp9_get_pred_mi_segid(VP9_COMMON *cm, BLOCK_SIZE_TYPE sb_type,
                          int mi_row, int mi_col) {
  const int mi_index = mi_row * cm->mi_cols + mi_col;
  const int bw = 1 << mi_width_log2(sb_type);
  const int bh = 1 << mi_height_log2(sb_type);
  const int ymis = MIN(cm->mi_rows - mi_row, bh);
  const int xmis = MIN(cm->mi_cols - mi_col, bw);
  int segment_id = INT_MAX;
  int x, y;

  for (y = 0; y < ymis; y++) {
    for (x = 0; x < xmis; x++) {
      const int index = mi_index + (y * cm->mi_cols + x);
      segment_id = MIN(segment_id, cm->last_frame_seg_map[index]);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
518
519
    }
  }
520
  return segment_id;
521
}