vp9_pred_common.c 20.1 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 *cm, const MACROBLOCKD *xd,
Paul Wilkins's avatar
Paul Wilkins committed
23
                                   PRED_ID pred_id) {
John Koleszar's avatar
John Koleszar committed
24
  int pred_context;
25
26
27
  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
28
29
  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
30
31
32
33
34
  // 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) {
35
    case PRED_SEG_ID:
36
      pred_context = above_mi->mbmi.seg_id_predicted;
37
      if (xd->left_available)
38
        pred_context += left_mi->mbmi.seg_id_predicted;
John Koleszar's avatar
John Koleszar committed
39
      break;
40

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

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

      // above
55
      const int above_mv_pred = is_inter_mode(above_mi->mbmi.mode);
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
      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;

74
      break;
75
    }
76

Ronald S. Bultje's avatar
Ronald S. Bultje committed
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
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
    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;
    }

350
    case PRED_TX_SIZE: {
351
      int above_context, left_context;
352
353
354
355
356
357
358
359
360
      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;
361
      above_context = left_context = max_tx_size;
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
        above_context = left_context;
      }
376
      pred_context = (above_context + left_context > max_tx_size);
377
378
379
      break;
    }

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

John Koleszar's avatar
John Koleszar committed
386
  return pred_context;
387
388
389
390
}

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

  switch (pred_id) {
396
    case PRED_SEG_ID:
Dmitry Kovalev's avatar
Dmitry Kovalev committed
397
      return cm->segment_pred_probs[pred_context];
398
    case PRED_MBSKIP:
Deb Mukherjee's avatar
Deb Mukherjee committed
399
      return cm->fc.mbskip_probs[pred_context];
Ronald S. Bultje's avatar
Ronald S. Bultje committed
400
401
402
403
404
405
406
407
408
409
    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];
410
    default:
Ronald S. Bultje's avatar
Ronald S. Bultje committed
411
      assert(0);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
412
      return 128;  // *** add error trap code.
John Koleszar's avatar
John Koleszar committed
413
  }
414
415
}

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

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

    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];

435
    default:
Ronald S. Bultje's avatar
Ronald S. Bultje committed
436
      assert(0);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
437
      return NULL;  // *** add error trap code.
438
439
440
  }
}

441
442
// 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
443
444
unsigned char vp9_get_pred_flag(const MACROBLOCKD *const xd,
                                PRED_ID pred_id) {
John Koleszar's avatar
John Koleszar committed
445
  switch (pred_id) {
446
    case PRED_SEG_ID:
Dmitry Kovalev's avatar
Dmitry Kovalev committed
447
      return xd->mode_info_context->mbmi.seg_id_predicted;
448
    case PRED_MBSKIP:
Dmitry Kovalev's avatar
Dmitry Kovalev committed
449
      return xd->mode_info_context->mbmi.mb_skip_coeff;
450
    default:
Ronald S. Bultje's avatar
Ronald S. Bultje committed
451
      assert(0);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
452
      return 0;  // *** add error trap code.
John Koleszar's avatar
John Koleszar committed
453
  }
454
455
456
457
}

// This function sets the status of the given prediction signal.
// I.e. is the predicted value for the given signal correct.
Dmitry Kovalev's avatar
Dmitry Kovalev committed
458
void vp9_set_pred_flag(MACROBLOCKD *xd, BLOCK_SIZE_TYPE bsize, PRED_ID pred_id,
Paul Wilkins's avatar
Paul Wilkins committed
459
                       unsigned char pred_flag) {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
460
  const int mis = xd->mode_info_stride;
461
462
  const int bh = 1 << mi_height_log2(bsize);
  const int bw = 1 << mi_width_log2(bsize);
463
#define sub(a, b) (b) < 0 ? (a) + (b) : (a)
464
465
  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));
466
467
#undef sub
  int x, y;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
468

John Koleszar's avatar
John Koleszar committed
469
  switch (pred_id) {
470
    case PRED_SEG_ID:
471
472
      for (y = 0; y < y_mis; y++)
        for (x = 0; x < x_mis; x++)
473
          xd->mode_info_context[y * mis + x].mbmi.seg_id_predicted = pred_flag;
John Koleszar's avatar
John Koleszar committed
474
      break;
475

476
    case PRED_MBSKIP:
477
478
      for (y = 0; y < y_mis; y++)
        for (x = 0; x < x_mis; x++)
479
          xd->mode_info_context[y * mis + x].mbmi.mb_skip_coeff = pred_flag;
John Koleszar's avatar
John Koleszar committed
480
      break;
481

482
    default:
Ronald S. Bultje's avatar
Ronald S. Bultje committed
483
      assert(0);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
484
      // *** add error trap code.
John Koleszar's avatar
John Koleszar committed
485
486
      break;
  }
487
488
}

489
490
491
492
493
int vp9_get_segment_id(VP9_COMMON *cm, const uint8_t *segment_ids,
                       BLOCK_SIZE_TYPE bsize, int mi_row, int mi_col) {
  const int mi_offset = mi_row * cm->mi_cols + mi_col;
  const int bw = 1 << mi_width_log2(bsize);
  const int bh = 1 << mi_height_log2(bsize);
494
  const int xmis = MIN(cm->mi_cols - mi_col, bw);
495
496
  const int ymis = MIN(cm->mi_rows - mi_row, bh);
  int x, y, segment_id = INT_MAX;
497

498
499
500
501
502
503
  for (y = 0; y < ymis; y++)
    for (x = 0; x < xmis; x++)
      segment_id = MIN(segment_id,
                       segment_ids[mi_offset + y * cm->mi_cols + x]);

  assert(segment_id >= 0 && segment_id < MAX_MB_SEGMENTS);
504
  return segment_id;
505
}