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
// Returns a context number for the given MB prediction signal
unsigned char vp9_get_pred_context_switchable_interp(const VP9_COMMON *cm,
                                                     const MACROBLOCKD *xd) {
22
23
24
25
26
  const MODE_INFO *const mi = xd->mode_info_context;
  const MB_MODE_INFO *const above_mbmi = &mi[-cm->mode_info_stride].mbmi;
  const MB_MODE_INFO *const left_mbmi = &mi[-1].mbmi;
  const int left_in_image = xd->left_available && left_mbmi->mb_in_image;
  const int above_in_image = xd->up_available && above_mbmi->mb_in_image;
27
28
29
30
31
  // 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.
  // left
32
33
34
  const int left_mv_pred = is_inter_mode(left_mbmi->mode);
  const int left_interp = left_in_image && left_mv_pred ?
          vp9_switchable_interp_map[left_mbmi->interp_filter] :
35
36
37
          VP9_SWITCHABLE_FILTERS;

  // above
38
39
40
  const int above_mv_pred = is_inter_mode(above_mbmi->mode);
  const int above_interp = above_in_image && above_mv_pred ?
          vp9_switchable_interp_map[above_mbmi->interp_filter] :
41
42
43
44
45
46
          VP9_SWITCHABLE_FILTERS;

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

  if (left_interp == above_interp)
47
48
49
50
51
52
53
    return left_interp;
  else if (left_interp == VP9_SWITCHABLE_FILTERS &&
           above_interp != VP9_SWITCHABLE_FILTERS)
    return above_interp;
  else if (left_interp != VP9_SWITCHABLE_FILTERS &&
           above_interp == VP9_SWITCHABLE_FILTERS)
    return left_interp;
54
  else
55
    return VP9_SWITCHABLE_FILTERS;
56
}
57
// Returns a context number for the given MB prediction signal
58
unsigned char vp9_get_pred_context_intra_inter(const VP9_COMMON *cm,
59
                                               const MACROBLOCKD *xd) {
John Koleszar's avatar
John Koleszar committed
60
  int pred_context;
61
  const MODE_INFO *const mi = xd->mode_info_context;
62
63
64
65
  const MB_MODE_INFO *const above_mbmi = &mi[-cm->mode_info_stride].mbmi;
  const MB_MODE_INFO *const left_mbmi = &mi[-1].mbmi;
  const int left_in_image = xd->left_available && left_mbmi->mb_in_image;
  const int above_in_image = xd->up_available && above_mbmi->mb_in_image;
John Koleszar's avatar
John Koleszar committed
66
67
68
69
  // 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.
70
  if (above_in_image && left_in_image) {  // both edges available
71
72
    if (left_mbmi->ref_frame[0] == INTRA_FRAME &&
        above_mbmi->ref_frame[0] == INTRA_FRAME) {  // intra/intra (3)
73
74
      pred_context = 3;
    } else {  // intra/inter (1) or inter/inter (0)
75
76
      pred_context = left_mbmi->ref_frame[0] == INTRA_FRAME ||
                     above_mbmi->ref_frame[0] == INTRA_FRAME;
77
    }
78
  } else if (above_in_image || left_in_image) {  // one edge available
79
    const MB_MODE_INFO *edge_mbmi = above_in_image ? above_mbmi : left_mbmi;
80

81
    // inter: 0, intra: 2
82
    pred_context = 2 * (edge_mbmi->ref_frame[0] == INTRA_FRAME);
83
84
85
86
87
88
89
90
91
92
93
  } else {
    pred_context = 0;
  }
  assert(pred_context >= 0 && pred_context < INTRA_INTER_CONTEXTS);
  return pred_context;
}
// Returns a context number for the given MB prediction signal
unsigned char vp9_get_pred_context_comp_inter_inter(const VP9_COMMON *cm,
                                                    const MACROBLOCKD *xd) {
  int pred_context;
  const MODE_INFO *const mi = xd->mode_info_context;
94
95
96
97
  const MB_MODE_INFO *const above_mbmi = &mi[-cm->mode_info_stride].mbmi;
  const MB_MODE_INFO *const left_mbmi = &mi[-1].mbmi;
  const int left_in_image = xd->left_available && left_mbmi->mb_in_image;
  const int above_in_image = xd->up_available && above_mbmi->mb_in_image;
98
99
100
101
102
  // 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.
  if (above_in_image && left_in_image) {  // both edges available
103
104
    if (above_mbmi->ref_frame[1] <= INTRA_FRAME &&
        left_mbmi->ref_frame[1] <= INTRA_FRAME)
105
      // neither edge uses comp pred (0/1)
106
107
108
      pred_context = (above_mbmi->ref_frame[0] == cm->comp_fixed_ref) ^
                     (left_mbmi->ref_frame[0] == cm->comp_fixed_ref);
    else if (above_mbmi->ref_frame[1] <= INTRA_FRAME)
109
      // one of two edges uses comp pred (2/3)
110
111
112
      pred_context = 2 + (above_mbmi->ref_frame[0] == cm->comp_fixed_ref ||
                          above_mbmi->ref_frame[0] == INTRA_FRAME);
    else if (left_mbmi->ref_frame[1] <= INTRA_FRAME)
113
      // one of two edges uses comp pred (2/3)
114
115
116
      pred_context = 2 + (left_mbmi->ref_frame[0] == cm->comp_fixed_ref ||
                          left_mbmi->ref_frame[0] == INTRA_FRAME);
    else  // both edges use comp pred (4)
117
118
      pred_context = 4;
  } else if (above_in_image || left_in_image) {  // one edge available
119
    const MB_MODE_INFO *edge_mbmi = above_in_image ? above_mbmi : left_mbmi;
120

121
    if (edge_mbmi->ref_frame[1] <= INTRA_FRAME)
122
      // edge does not use comp pred (0/1)
123
124
125
      pred_context = edge_mbmi->ref_frame[0] == cm->comp_fixed_ref;
    else
      // edge uses comp pred (3)
126
127
128
129
130
131
132
      pred_context = 3;
  } else {  // no edges available (1)
    pred_context = 1;
  }
  assert(pred_context >= 0 && pred_context < COMP_INTER_CONTEXTS);
  return pred_context;
}
Ronald S. Bultje's avatar
Ronald S. Bultje committed
133

134
135
136
137
138
// Returns a context number for the given MB prediction signal
unsigned char vp9_get_pred_context_comp_ref_p(const VP9_COMMON *cm,
                                              const MACROBLOCKD *xd) {
  int pred_context;
  const MODE_INFO *const mi = xd->mode_info_context;
139
140
141
142
  const MB_MODE_INFO *const above_mbmi = &mi[-cm->mode_info_stride].mbmi;
  const MB_MODE_INFO *const left_mbmi = &mi[-1].mbmi;
  const int left_in_image = xd->left_available && left_mbmi->mb_in_image;
  const int above_in_image = xd->up_available && above_mbmi->mb_in_image;
143
144
145
146
147
148
149
150
  // 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.
  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
151
152
    if (above_mbmi->ref_frame[0] == INTRA_FRAME &&
        left_mbmi->ref_frame[0] == INTRA_FRAME) {  // intra/intra (2)
153
      pred_context = 2;
154
155
156
157
    } else if (above_mbmi->ref_frame[0] == INTRA_FRAME ||
               left_mbmi->ref_frame[0] == INTRA_FRAME) {  // intra/inter
      const MB_MODE_INFO *edge_mbmi = above_mbmi->ref_frame[0] == INTRA_FRAME ?
                                          left_mbmi : above_mbmi;
158

159
      if (edge_mbmi->ref_frame[1] <= INTRA_FRAME)  // single pred (1/3)
160
        pred_context = 1 + 2 * (edge_mbmi->ref_frame[0] != cm->comp_var_ref[1]);
161
      else  // comp pred (1/3)
162
163
        pred_context = 1 + 2 * (edge_mbmi->ref_frame[var_ref_idx]
                                    != cm->comp_var_ref[1]);
164
    } else {  // inter/inter
165
166
167
168
169
170
      int l_sg = left_mbmi->ref_frame[1] <= INTRA_FRAME;
      int a_sg = above_mbmi->ref_frame[1] <= INTRA_FRAME;
      MV_REFERENCE_FRAME vrfa = a_sg ? above_mbmi->ref_frame[0]
                                     : above_mbmi->ref_frame[var_ref_idx];
      MV_REFERENCE_FRAME vrfl = l_sg ? left_mbmi->ref_frame[0]
                                     : left_mbmi->ref_frame[var_ref_idx];
Ronald S. Bultje's avatar
Ronald S. Bultje committed
171

172
173
174
      if (vrfa == vrfl && cm->comp_var_ref[1] == vrfa) {
        pred_context = 0;
      } else if (l_sg && a_sg) {  // single/single
175
176
        if ((vrfa == cm->comp_fixed_ref && vrfl == cm->comp_var_ref[0]) ||
            (vrfl == cm->comp_fixed_ref && vrfa == cm->comp_var_ref[0]))
Ronald S. Bultje's avatar
Ronald S. Bultje committed
177
          pred_context = 4;
178
        else if (vrfa == vrfl)
Ronald S. Bultje's avatar
Ronald S. Bultje committed
179
          pred_context = 3;
180
        else
181
182
183
184
          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;
185
        if (vrfc == cm->comp_var_ref[1] && rfs != cm->comp_var_ref[1])
186
          pred_context = 1;
187
        else if (rfs == cm->comp_var_ref[1] && vrfc != cm->comp_var_ref[1])
Ronald S. Bultje's avatar
Ronald S. Bultje committed
188
          pred_context = 2;
189
        else
190
191
192
193
          pred_context = 4;
      } else if (vrfa == vrfl) {  // comp/comp
        pred_context = 4;
      } else {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
194
195
196
        pred_context = 2;
      }
    }
197
  } else if (above_in_image || left_in_image) {  // one edge available
198
    const MB_MODE_INFO *edge_mbmi = above_in_image ? above_mbmi : left_mbmi;
199

200
    if (edge_mbmi->ref_frame[0] == INTRA_FRAME)
201
      pred_context = 2;
202
    else if (edge_mbmi->ref_frame[1] > INTRA_FRAME)
203
204
      pred_context = 4 * (edge_mbmi->ref_frame[var_ref_idx]
                              != cm->comp_var_ref[1]);
205
    else
206
      pred_context = 3 * (edge_mbmi->ref_frame[0] != cm->comp_var_ref[1]);
207
208
209
210
  } else {  // no edges available (2)
    pred_context = 2;
  }
  assert(pred_context >= 0 && pred_context < REF_CONTEXTS);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
211

212
213
214
215
216
217
  return pred_context;
}
unsigned char vp9_get_pred_context_single_ref_p1(const VP9_COMMON *cm,
                                                 const MACROBLOCKD *xd) {
  int pred_context;
  const MODE_INFO *const mi = xd->mode_info_context;
218
219
220
221
  const MB_MODE_INFO *const above_mbmi = &mi[-cm->mode_info_stride].mbmi;
  const MB_MODE_INFO *const left_mbmi = &mi[-1].mbmi;
  const int left_in_image = xd->left_available && left_mbmi->mb_in_image;
  const int above_in_image = xd->up_available && above_mbmi->mb_in_image;
222
223
224
225
226
  // 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.
  if (above_in_image && left_in_image) {  // both edges available
227
228
    if (above_mbmi->ref_frame[0] == INTRA_FRAME &&
        left_mbmi->ref_frame[0] == INTRA_FRAME) {
229
      pred_context = 2;
230
231
232
233
    } else if (above_mbmi->ref_frame[0] == INTRA_FRAME ||
               left_mbmi->ref_frame[0] == INTRA_FRAME) {
      const MB_MODE_INFO *edge_mbmi = above_mbmi->ref_frame[0] == INTRA_FRAME ?
                                          left_mbmi : above_mbmi;
234

235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
      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_mbmi->ref_frame[1] <= INTRA_FRAME &&
               left_mbmi->ref_frame[1] <= INTRA_FRAME) {
      pred_context = 2 * (above_mbmi->ref_frame[0] == LAST_FRAME) +
                     2 * (left_mbmi->ref_frame[0] == LAST_FRAME);
    } else if (above_mbmi->ref_frame[1] > INTRA_FRAME &&
               left_mbmi->ref_frame[1] > INTRA_FRAME) {
      pred_context = 1 + (above_mbmi->ref_frame[0] == LAST_FRAME ||
                          above_mbmi->ref_frame[1] == LAST_FRAME ||
                          left_mbmi->ref_frame[0] == LAST_FRAME ||
                          left_mbmi->ref_frame[1] == LAST_FRAME);
250
    } else {
251
252
253
254
255
256
      MV_REFERENCE_FRAME rfs = above_mbmi->ref_frame[1] <= INTRA_FRAME ?
              above_mbmi->ref_frame[0] : left_mbmi->ref_frame[0];
      MV_REFERENCE_FRAME crf1 = above_mbmi->ref_frame[1] > INTRA_FRAME ?
              above_mbmi->ref_frame[0] : left_mbmi->ref_frame[0];
      MV_REFERENCE_FRAME crf2 = above_mbmi->ref_frame[1] > INTRA_FRAME ?
              above_mbmi->ref_frame[1] : left_mbmi->ref_frame[1];
Ronald S. Bultje's avatar
Ronald S. Bultje committed
257

258
      if (rfs == LAST_FRAME)
259
        pred_context = 3 + (crf1 == LAST_FRAME || crf2 == LAST_FRAME);
260
      else
261
262
263
        pred_context = crf1 == LAST_FRAME || crf2 == LAST_FRAME;
    }
  } else if (above_in_image || left_in_image) {  // one edge available
264
    const MB_MODE_INFO *edge_mbmi = above_in_image ? above_mbmi : left_mbmi;
265

266
    if (edge_mbmi->ref_frame[0] == INTRA_FRAME)
267
      pred_context = 2;
268
269
270
271
272
    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);
273
274
275
276
277
278
  } else {  // no edges available (2)
    pred_context = 2;
  }
  assert(pred_context >= 0 && pred_context < REF_CONTEXTS);
  return pred_context;
}
Ronald S. Bultje's avatar
Ronald S. Bultje committed
279

280
281
282
283
unsigned char vp9_get_pred_context_single_ref_p2(const VP9_COMMON *cm,
                                                 const MACROBLOCKD *xd) {
  int pred_context;
  const MODE_INFO *const mi = xd->mode_info_context;
284
285
286
287
288
  const MB_MODE_INFO *const above_mbmi = &mi[-cm->mode_info_stride].mbmi;
  const MB_MODE_INFO *const left_mbmi = &mi[-1].mbmi;
  const int left_in_image = xd->left_available && left_mbmi->mb_in_image;
  const int above_in_image = xd->up_available && above_mbmi->mb_in_image;

289
290
291
292
293
  // 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.
  if (above_in_image && left_in_image) {  // both edges available
294
295
    if (above_mbmi->ref_frame[0] == INTRA_FRAME &&
        left_mbmi->ref_frame[0] == INTRA_FRAME) {
296
      pred_context = 2;
297
298
299
300
    } else if (above_mbmi->ref_frame[0] == INTRA_FRAME ||
               left_mbmi->ref_frame[0] == INTRA_FRAME) {
      const MB_MODE_INFO *edge_mbmi = above_mbmi->ref_frame[0] == INTRA_FRAME ?
                                          left_mbmi : above_mbmi;
301

302
303
      if (edge_mbmi->ref_frame[1] <= INTRA_FRAME) {
        if (edge_mbmi->ref_frame[0] == LAST_FRAME)
304
          pred_context = 3;
305
306
        else
          pred_context = 4 * (edge_mbmi->ref_frame[0] == GOLDEN_FRAME);
307
      } else {
308
309
        pred_context = 1 + 2 * (edge_mbmi->ref_frame[0] == GOLDEN_FRAME ||
                                edge_mbmi->ref_frame[1] == GOLDEN_FRAME);
310
      }
311
312
313
314
    } else if (above_mbmi->ref_frame[1] <= INTRA_FRAME &&
               left_mbmi->ref_frame[1] <= INTRA_FRAME) {
      if (above_mbmi->ref_frame[0] == LAST_FRAME &&
          left_mbmi->ref_frame[0] == LAST_FRAME) {
315
        pred_context = 3;
316
317
318
319
      } else if (above_mbmi->ref_frame[0] == LAST_FRAME ||
                 left_mbmi->ref_frame[0] == LAST_FRAME) {
        const MB_MODE_INFO *edge_mbmi = above_mbmi->ref_frame[0] == LAST_FRAME ?
                                           left_mbmi : above_mbmi;
320

321
        pred_context = 4 * (edge_mbmi->ref_frame[0] == GOLDEN_FRAME);
322
      } else {
323
324
        pred_context = 2 * (above_mbmi->ref_frame[0] == GOLDEN_FRAME) +
                       2 * (left_mbmi->ref_frame[0] == GOLDEN_FRAME);
325
      }
326
327
328
329
330
331
332
333
334
    } else if (above_mbmi->ref_frame[1] > INTRA_FRAME &&
               left_mbmi->ref_frame[1] > INTRA_FRAME) {
      if (above_mbmi->ref_frame[0] == left_mbmi->ref_frame[0] &&
          above_mbmi->ref_frame[1] == left_mbmi->ref_frame[1])
        pred_context = 3 * (above_mbmi->ref_frame[0] == GOLDEN_FRAME ||
                            above_mbmi->ref_frame[1] == GOLDEN_FRAME ||
                            left_mbmi->ref_frame[0] == GOLDEN_FRAME ||
                            left_mbmi->ref_frame[1] == GOLDEN_FRAME);
      else
Ronald S. Bultje's avatar
Ronald S. Bultje committed
335
        pred_context = 2;
336
    } else {
337
338
339
340
341
342
      MV_REFERENCE_FRAME rfs = above_mbmi->ref_frame[1] <= INTRA_FRAME ?
              above_mbmi->ref_frame[0] : left_mbmi->ref_frame[0];
      MV_REFERENCE_FRAME crf1 = above_mbmi->ref_frame[1] > INTRA_FRAME ?
              above_mbmi->ref_frame[0] : left_mbmi->ref_frame[0];
      MV_REFERENCE_FRAME crf2 = above_mbmi->ref_frame[1] > INTRA_FRAME ?
              above_mbmi->ref_frame[1] : left_mbmi->ref_frame[1];
Ronald S. Bultje's avatar
Ronald S. Bultje committed
343

344
      if (rfs == GOLDEN_FRAME)
345
        pred_context = 3 + (crf1 == GOLDEN_FRAME || crf2 == GOLDEN_FRAME);
346
      else if (rfs == ALTREF_FRAME)
347
        pred_context = crf1 == GOLDEN_FRAME || crf2 == GOLDEN_FRAME;
348
      else
349
        pred_context = 1 + 2 * (crf1 == GOLDEN_FRAME || crf2 == GOLDEN_FRAME);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
350
    }
351
  } else if (above_in_image || left_in_image) {  // one edge available
352
    const MB_MODE_INFO *edge_mbmi = above_in_image ? above_mbmi : left_mbmi;
353

354
355
356
    if (edge_mbmi->ref_frame[0] == INTRA_FRAME ||
        (edge_mbmi->ref_frame[0] == LAST_FRAME &&
         edge_mbmi->ref_frame[1] <= INTRA_FRAME))
357
      pred_context = 2;
358
359
360
361
362
    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);
363
364
  } else {  // no edges available (2)
    pred_context = 2;
John Koleszar's avatar
John Koleszar committed
365
  }
366
  assert(pred_context >= 0 && pred_context < REF_CONTEXTS);
John Koleszar's avatar
John Koleszar committed
367
  return pred_context;
368
}
369
370
371
// Returns a context number for the given MB prediction signal
unsigned char vp9_get_pred_context_tx_size(const VP9_COMMON *cm,
                                           const MACROBLOCKD *xd) {
372
373
374
  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;
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
  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;
  // 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.
  int above_context, left_context;
  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;
391

392
  above_context = left_context = max_tx_size;
393
394
395
396
397
398
399
400
401
402

  if (above_in_image)
    above_context = above_mi->mbmi.mb_skip_coeff ? max_tx_size
                                                 : above_mi->mbmi.txfm_size;

  if (left_in_image)
    left_context = left_mi->mbmi.mb_skip_coeff ? max_tx_size
                                               : left_mi->mbmi.txfm_size;

  if (!left_in_image)
403
    left_context = above_context;
404
405

  if (!above_in_image)
406
407
    above_context = left_context;

408
  return above_context + left_context > max_tx_size;
409
410
}

411
412
413
414
void vp9_set_pred_flag_seg_id(VP9_COMMON *cm, BLOCK_SIZE_TYPE bsize,
                              int mi_row, int mi_col, uint8_t pred_flag) {
  MODE_INFO *mi = &cm->mi[mi_row * cm->mode_info_stride + mi_col];
  const int bw = 1 << mi_width_log2(bsize);
415
  const int bh = 1 << mi_height_log2(bsize);
416
417
418
419
420
421
422
423
424
425
426
427
  const int xmis = MIN(cm->mi_cols - mi_col, bw);
  const int ymis = MIN(cm->mi_rows - mi_row, bh);
  int x, y;

  for (y = 0; y < ymis; y++)
    for (x = 0; x < xmis; x++)
      mi[y * cm->mode_info_stride + x].mbmi.seg_id_predicted = pred_flag;
}

void vp9_set_pred_flag_mbskip(VP9_COMMON *cm, BLOCK_SIZE_TYPE bsize,
                              int mi_row, int mi_col, uint8_t pred_flag) {
  MODE_INFO *mi = &cm->mi[mi_row * cm->mode_info_stride + mi_col];
428
  const int bw = 1 << mi_width_log2(bsize);
429
430
431
  const int bh = 1 << mi_height_log2(bsize);
  const int xmis = MIN(cm->mi_cols - mi_col, bw);
  const int ymis = MIN(cm->mi_rows - mi_row, bh);
432
  int x, y;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
433

434
435
436
  for (y = 0; y < ymis; y++)
    for (x = 0; x < xmis; x++)
      mi[y * cm->mode_info_stride + x].mbmi.mb_skip_coeff = pred_flag;
437
438
}

439
440
441
442
443
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);
444
  const int xmis = MIN(cm->mi_cols - mi_col, bw);
445
446
  const int ymis = MIN(cm->mi_rows - mi_row, bh);
  int x, y, segment_id = INT_MAX;
447

448
449
450
451
452
453
  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);
454
  return segment_id;
455
}