src/third_party/libvpx/source/libvpx/vp9/common/vp9_pred_common.c

   1
   2 /*
   3  *  Copyright (c) 2012 The WebM project authors. All Rights Reserved.
   4  *
   5  *  Use of this source code is governed by a BSD-style license
   6  *  that can be found in the LICENSE file in the root of the source
   7  *  tree. An additional intellectual property rights grant can be found
   8  *  in the file PATENTS.  All contributing project authors may
   9  *  be found in the AUTHORS file in the root of the source tree.
  10  */
  11
  12 #include <limits.h>
  13
  14 #include "vp9/common/vp9_common.h"
  15 #include "vp9/common/vp9_pred_common.h"
  16 #include "vp9/common/vp9_seg_common.h"
  17
  18 static INLINE const MB_MODE_INFO *get_mbmi(const MODE_INFO *const mi) {
  19   return (mi != NULL) ? &mi->mbmi : NULL;
  20 }
  21
  22 // Returns a context number for the given MB prediction signal
  23 int vp9_get_pred_context_switchable_interp(const MACROBLOCKD *xd) {
  24   // Note:
  25   // The mode info data structure has a one element border above and to the
  26   // left of the entries correpsonding to real macroblocks.
  27   // The prediction flags in these dummy entries are initialised to 0.
  28   const MB_MODE_INFO *const left_mbmi = get_mbmi(get_left_mi(xd));
  29   const int left_type = left_mbmi != NULL && is_inter_block(left_mbmi) ?
  30                            left_mbmi->interp_filter : SWITCHABLE_FILTERS;
  31   const MB_MODE_INFO *const above_mbmi = get_mbmi(get_above_mi(xd));
  32   const int above_type = above_mbmi != NULL && is_inter_block(above_mbmi) ?
  33                              above_mbmi->interp_filter : SWITCHABLE_FILTERS;
  34
  35   if (left_type == above_type)
  36     return left_type;
  37   else if (left_type == SWITCHABLE_FILTERS && above_type != SWITCHABLE_FILTERS)
  38     return above_type;
  39   else if (left_type != SWITCHABLE_FILTERS && above_type == SWITCHABLE_FILTERS)
  40     return left_type;
  41   else
  42     return SWITCHABLE_FILTERS;
  43 }
  44
  45 // The mode info data structure has a one element border above and to the
  46 // left of the entries corresponding to real macroblocks.
  47 // The prediction flags in these dummy entries are initialized to 0.
  48 // 0 - inter/inter, inter/--, --/inter, --/--
  49 // 1 - intra/inter, inter/intra
  50 // 2 - intra/--, --/intra
  51 // 3 - intra/intra
  52 int vp9_get_intra_inter_context(const MACROBLOCKD *xd) {
  53   const MB_MODE_INFO *const above_mbmi = get_mbmi(get_above_mi(xd));
  54   const MB_MODE_INFO *const left_mbmi = get_mbmi(get_left_mi(xd));
  55   const int has_above = above_mbmi != NULL;
  56   const int has_left = left_mbmi != NULL;
  57
  58   if (has_above && has_left) {  // both edges available
  59     const int above_intra = !is_inter_block(above_mbmi);
  60     const int left_intra = !is_inter_block(left_mbmi);
  61     return left_intra && above_intra ? 3
  62                                      : left_intra || above_intra;
  63   } else if (has_above || has_left) {  // one edge available
  64     return 2 * !is_inter_block(has_above ? above_mbmi : left_mbmi);
  65   } else {
  66     return 0;
  67   }
  68 }
  69
  70 int vp9_get_reference_mode_context(const VP9_COMMON *cm,
  71                                    const MACROBLOCKD *xd) {
  72   int ctx;
  73   const MB_MODE_INFO *const above_mbmi = get_mbmi(get_above_mi(xd));
  74   const MB_MODE_INFO *const left_mbmi = get_mbmi(get_left_mi(xd));
  75   const int has_above = above_mbmi != NULL;
  76   const int has_left = left_mbmi != NULL;
  77   // Note:
  78   // The mode info data structure has a one element border above and to the
  79   // left of the entries correpsonding to real macroblocks.
  80   // The prediction flags in these dummy entries are initialised to 0.
  81   if (has_above && has_left) {  // both edges available
  82     if (!has_second_ref(above_mbmi) && !has_second_ref(left_mbmi))
  83       // neither edge uses comp pred (0/1)
  84       ctx = (above_mbmi->ref_frame[0] == cm->comp_fixed_ref) ^
  85             (left_mbmi->ref_frame[0] == cm->comp_fixed_ref);
  86     else if (!has_second_ref(above_mbmi))
  87       // one of two edges uses comp pred (2/3)
  88       ctx = 2 + (above_mbmi->ref_frame[0] == cm->comp_fixed_ref ||
  89                  !is_inter_block(above_mbmi));
  90     else if (!has_second_ref(left_mbmi))
  91       // one of two edges uses comp pred (2/3)
  92       ctx = 2 + (left_mbmi->ref_frame[0] == cm->comp_fixed_ref ||
  93                  !is_inter_block(left_mbmi));
  94     else  // both edges use comp pred (4)
  95       ctx = 4;
  96   } else if (has_above || has_left) {  // one edge available
  97     const MB_MODE_INFO *edge_mbmi = has_above ? above_mbmi : left_mbmi;
  98
  99     if (!has_second_ref(edge_mbmi))
 100       // edge does not use comp pred (0/1)
 101       ctx = edge_mbmi->ref_frame[0] == cm->comp_fixed_ref;
 102     else
 103       // edge uses comp pred (3)
 104       ctx = 3;
 105   } else {  // no edges available (1)
 106     ctx = 1;
 107   }
 108   assert(ctx >= 0 && ctx < COMP_INTER_CONTEXTS);
 109   return ctx;
 110 }
 111
 112 // Returns a context number for the given MB prediction signal
 113 int vp9_get_pred_context_comp_ref_p(const VP9_COMMON *cm,
 114                                     const MACROBLOCKD *xd) {
 115   int pred_context;
 116   const MB_MODE_INFO *const above_mbmi = get_mbmi(get_above_mi(xd));
 117   const MB_MODE_INFO *const left_mbmi = get_mbmi(get_left_mi(xd));
 118   const int above_in_image = above_mbmi != NULL;
 119   const int left_in_image = left_mbmi != NULL;
 120
 121   // Note:
 122   // The mode info data structure has a one element border above and to the
 123   // left of the entries correpsonding to real macroblocks.
 124   // The prediction flags in these dummy entries are initialised to 0.
 125   const int fix_ref_idx = cm->ref_frame_sign_bias[cm->comp_fixed_ref];
 126   const int var_ref_idx = !fix_ref_idx;
 127
 128   if (above_in_image && left_in_image) {  // both edges available
 129     const int above_intra = !is_inter_block(above_mbmi);
 130     const int left_intra = !is_inter_block(left_mbmi);
 131
 132     if (above_intra && left_intra) {  // intra/intra (2)
 133       pred_context = 2;
 134     } else if (above_intra || left_intra) {  // intra/inter
 135       const MB_MODE_INFO *edge_mbmi = above_intra ? left_mbmi : above_mbmi;
 136
 137       if (!has_second_ref(edge_mbmi))  // single pred (1/3)
 138         pred_context = 1 + 2 * (edge_mbmi->ref_frame[0] != cm->comp_var_ref[1]);
 139       else  // comp pred (1/3)
 140         pred_context = 1 + 2 * (edge_mbmi->ref_frame[var_ref_idx]
 141                                     != cm->comp_var_ref[1]);
 142     } else {  // inter/inter
 143       const int l_sg = !has_second_ref(left_mbmi);
 144       const int a_sg = !has_second_ref(above_mbmi);
 145       const MV_REFERENCE_FRAME vrfa = a_sg ? above_mbmi->ref_frame[0]
 146                                            : above_mbmi->ref_frame[var_ref_idx];
 147       const MV_REFERENCE_FRAME vrfl = l_sg ? left_mbmi->ref_frame[0]
 148                                            : left_mbmi->ref_frame[var_ref_idx];
 149
 150       if (vrfa == vrfl && cm->comp_var_ref[1] == vrfa) {
 151         pred_context = 0;
 152       } else if (l_sg && a_sg) {  // single/single
 153         if ((vrfa == cm->comp_fixed_ref && vrfl == cm->comp_var_ref[0]) ||
 154             (vrfl == cm->comp_fixed_ref && vrfa == cm->comp_var_ref[0]))
 155           pred_context = 4;
 156         else if (vrfa == vrfl)
 157           pred_context = 3;
 158         else
 159           pred_context = 1;
 160       } else if (l_sg || a_sg) {  // single/comp
 161         const MV_REFERENCE_FRAME vrfc = l_sg ? vrfa : vrfl;
 162         const MV_REFERENCE_FRAME rfs = a_sg ? vrfa : vrfl;
 163         if (vrfc == cm->comp_var_ref[1] && rfs != cm->comp_var_ref[1])
 164           pred_context = 1;
 165         else if (rfs == cm->comp_var_ref[1] && vrfc != cm->comp_var_ref[1])
 166           pred_context = 2;
 167         else
 168           pred_context = 4;
 169       } else if (vrfa == vrfl) {  // comp/comp
 170         pred_context = 4;
 171       } else {
 172         pred_context = 2;
 173       }
 174     }
 175   } else if (above_in_image || left_in_image) {  // one edge available
 176     const MB_MODE_INFO *edge_mbmi = above_in_image ? above_mbmi : left_mbmi;
 177
 178     if (!is_inter_block(edge_mbmi)) {
 179       pred_context = 2;
 180     } else {
 181       if (has_second_ref(edge_mbmi))
 182         pred_context = 4 * (edge_mbmi->ref_frame[var_ref_idx]
 183                               != cm->comp_var_ref[1]);
 184       else
 185         pred_context = 3 * (edge_mbmi->ref_frame[0] != cm->comp_var_ref[1]);
 186     }
 187   } else {  // no edges available (2)
 188     pred_context = 2;
 189   }
 190   assert(pred_context >= 0 && pred_context < REF_CONTEXTS);
 191
 192   return pred_context;
 193 }
 194
 195 int vp9_get_pred_context_single_ref_p1(const MACROBLOCKD *xd) {
 196   int pred_context;
 197   const MB_MODE_INFO *const above_mbmi = get_mbmi(get_above_mi(xd));
 198   const MB_MODE_INFO *const left_mbmi = get_mbmi(get_left_mi(xd));
 199   const int has_above = above_mbmi != NULL;
 200   const int has_left = left_mbmi != NULL;
 201   // Note:
 202   // The mode info data structure has a one element border above and to the
 203   // left of the entries correpsonding to real macroblocks.
 204   // The prediction flags in these dummy entries are initialised to 0.
 205   if (has_above && has_left) {  // both edges available
 206     const int above_intra = !is_inter_block(above_mbmi);
 207     const int left_intra = !is_inter_block(left_mbmi);
 208
 209     if (above_intra && left_intra) {  // intra/intra
 210       pred_context = 2;
 211     } else if (above_intra || left_intra) {  // intra/inter or inter/intra
 212       const MB_MODE_INFO *edge_mbmi = above_intra ? left_mbmi : above_mbmi;
 213       if (!has_second_ref(edge_mbmi))
 214         pred_context = 4 * (edge_mbmi->ref_frame[0] == LAST_FRAME);
 215       else
 216         pred_context = 1 + (edge_mbmi->ref_frame[0] == LAST_FRAME ||
 217                             edge_mbmi->ref_frame[1] == LAST_FRAME);
 218     } else {  // inter/inter
 219       const int above_has_second = has_second_ref(above_mbmi);
 220       const int left_has_second = has_second_ref(left_mbmi);
 221       const MV_REFERENCE_FRAME above0 = above_mbmi->ref_frame[0];
 222       const MV_REFERENCE_FRAME above1 = above_mbmi->ref_frame[1];
 223       const MV_REFERENCE_FRAME left0 = left_mbmi->ref_frame[0];
 224       const MV_REFERENCE_FRAME left1 = left_mbmi->ref_frame[1];
 225
 226       if (above_has_second && left_has_second) {
 227         pred_context = 1 + (above0 == LAST_FRAME || above1 == LAST_FRAME ||
 228                             left0 == LAST_FRAME || left1 == LAST_FRAME);
 229       } else if (above_has_second || left_has_second) {
 230         const MV_REFERENCE_FRAME rfs = !above_has_second ? above0 : left0;
 231         const MV_REFERENCE_FRAME crf1 = above_has_second ? above0 : left0;
 232         const MV_REFERENCE_FRAME crf2 = above_has_second ? above1 : left1;
 233
 234         if (rfs == LAST_FRAME)
 235           pred_context = 3 + (crf1 == LAST_FRAME || crf2 == LAST_FRAME);
 236         else
 237           pred_context = (crf1 == LAST_FRAME || crf2 == LAST_FRAME);
 238       } else {
 239         pred_context = 2 * (above0 == LAST_FRAME) + 2 * (left0 == LAST_FRAME);
 240       }
 241     }
 242   } else if (has_above || has_left) {  // one edge available
 243     const MB_MODE_INFO *edge_mbmi = has_above ? above_mbmi : left_mbmi;
 244     if (!is_inter_block(edge_mbmi)) {  // intra
 245       pred_context = 2;
 246     } else {  // inter
 247       if (!has_second_ref(edge_mbmi))
 248         pred_context = 4 * (edge_mbmi->ref_frame[0] == LAST_FRAME);
 249       else
 250         pred_context = 1 + (edge_mbmi->ref_frame[0] == LAST_FRAME ||
 251                             edge_mbmi->ref_frame[1] == LAST_FRAME);
 252     }
 253   } else {  // no edges available
 254     pred_context = 2;
 255   }
 256
 257   assert(pred_context >= 0 && pred_context < REF_CONTEXTS);
 258   return pred_context;
 259 }
 260
 261 int vp9_get_pred_context_single_ref_p2(const MACROBLOCKD *xd) {
 262   int pred_context;
 263   const MB_MODE_INFO *const above_mbmi = get_mbmi(get_above_mi(xd));
 264   const MB_MODE_INFO *const left_mbmi = get_mbmi(get_left_mi(xd));
 265   const int has_above = above_mbmi != NULL;
 266   const int has_left = left_mbmi != NULL;
 267
 268   // Note:
 269   // The mode info data structure has a one element border above and to the
 270   // left of the entries correpsonding to real macroblocks.
 271   // The prediction flags in these dummy entries are initialised to 0.
 272   if (has_above && has_left) {  // both edges available
 273     const int above_intra = !is_inter_block(above_mbmi);
 274     const int left_intra = !is_inter_block(left_mbmi);
 275
 276     if (above_intra && left_intra) {  // intra/intra
 277       pred_context = 2;
 278     } else if (above_intra || left_intra) {  // intra/inter or inter/intra
 279       const MB_MODE_INFO *edge_mbmi = above_intra ? left_mbmi : above_mbmi;
 280       if (!has_second_ref(edge_mbmi)) {
 281         if (edge_mbmi->ref_frame[0] == LAST_FRAME)
 282           pred_context = 3;
 283         else
 284           pred_context = 4 * (edge_mbmi->ref_frame[0] == GOLDEN_FRAME);
 285       } else {
 286         pred_context = 1 + 2 * (edge_mbmi->ref_frame[0] == GOLDEN_FRAME ||
 287                                 edge_mbmi->ref_frame[1] == GOLDEN_FRAME);
 288       }
 289     } else {  // inter/inter
 290       const int above_has_second = has_second_ref(above_mbmi);
 291       const int left_has_second = has_second_ref(left_mbmi);
 292       const MV_REFERENCE_FRAME above0 = above_mbmi->ref_frame[0];
 293       const MV_REFERENCE_FRAME above1 = above_mbmi->ref_frame[1];
 294       const MV_REFERENCE_FRAME left0 = left_mbmi->ref_frame[0];
 295       const MV_REFERENCE_FRAME left1 = left_mbmi->ref_frame[1];
 296
 297       if (above_has_second && left_has_second) {
 298         if (above0 == left0 && above1 == left1)
 299           pred_context = 3 * (above0 == GOLDEN_FRAME ||
 300                               above1 == GOLDEN_FRAME ||
 301                               left0 == GOLDEN_FRAME ||
 302                               left1 == GOLDEN_FRAME);
 303         else
 304           pred_context = 2;
 305       } else if (above_has_second || left_has_second) {
 306         const MV_REFERENCE_FRAME rfs = !above_has_second ? above0 : left0;
 307         const MV_REFERENCE_FRAME crf1 = above_has_second ? above0 : left0;
 308         const MV_REFERENCE_FRAME crf2 = above_has_second ? above1 : left1;
 309
 310         if (rfs == GOLDEN_FRAME)
 311           pred_context = 3 + (crf1 == GOLDEN_FRAME || crf2 == GOLDEN_FRAME);
 312         else if (rfs == ALTREF_FRAME)
 313           pred_context = crf1 == GOLDEN_FRAME || crf2 == GOLDEN_FRAME;
 314         else
 315           pred_context = 1 + 2 * (crf1 == GOLDEN_FRAME || crf2 == GOLDEN_FRAME);
 316       } else {
 317         if (above0 == LAST_FRAME && left0 == LAST_FRAME) {
 318           pred_context = 3;
 319         } else if (above0 == LAST_FRAME || left0 == LAST_FRAME) {
 320           const MV_REFERENCE_FRAME edge0 = (above0 == LAST_FRAME) ? left0
 321                                                                   : above0;
 322           pred_context = 4 * (edge0 == GOLDEN_FRAME);
 323         } else {
 324           pred_context = 2 * (above0 == GOLDEN_FRAME) +
 325                              2 * (left0 == GOLDEN_FRAME);
 326         }
 327       }
 328     }
 329   } else if (has_above || has_left) {  // one edge available
 330     const MB_MODE_INFO *edge_mbmi = has_above ? above_mbmi : left_mbmi;
 331
 332     if (!is_inter_block(edge_mbmi) ||
 333         (edge_mbmi->ref_frame[0] == LAST_FRAME && !has_second_ref(edge_mbmi)))
 334       pred_context = 2;
 335     else if (!has_second_ref(edge_mbmi))
 336       pred_context = 4 * (edge_mbmi->ref_frame[0] == GOLDEN_FRAME);
 337     else
 338       pred_context = 3 * (edge_mbmi->ref_frame[0] == GOLDEN_FRAME ||
 339                           edge_mbmi->ref_frame[1] == GOLDEN_FRAME);
 340   } else {  // no edges available (2)
 341     pred_context = 2;
 342   }
 343   assert(pred_context >= 0 && pred_context < REF_CONTEXTS);
 344   return pred_context;
 345 }
 346 // Returns a context number for the given MB prediction signal
 347 // The mode info data structure has a one element border above and to the
 348 // left of the entries corresponding to real blocks.
 349 // The prediction flags in these dummy entries are initialized to 0.
 350 int vp9_get_tx_size_context(const MACROBLOCKD *xd) {
 351   const int max_tx_size = max_txsize_lookup[xd->mi_8x8[0]->mbmi.sb_type];
 352   const MB_MODE_INFO *const above_mbmi = get_mbmi(get_above_mi(xd));
 353   const MB_MODE_INFO *const left_mbmi = get_mbmi(get_left_mi(xd));
 354   const int has_above = above_mbmi != NULL;
 355   const int has_left = left_mbmi != NULL;
 356   int above_ctx = (has_above && !above_mbmi->skip) ? above_mbmi->tx_size
 357                                                    : max_tx_size;
 358   int left_ctx = (has_left && !left_mbmi->skip) ? left_mbmi->tx_size
 359                                                 : max_tx_size;
 360   if (!has_left)
 361     left_ctx = above_ctx;
 362
 363   if (!has_above)
 364     above_ctx = left_ctx;
 365
 366   return (above_ctx + left_ctx) > max_tx_size;
 367 }
 368
 369 int vp9_get_segment_id(VP9_COMMON *cm, const uint8_t *segment_ids,
 370                        BLOCK_SIZE bsize, int mi_row, int mi_col) {
 371   const int mi_offset = mi_row * cm->mi_cols + mi_col;
 372   const int bw = num_8x8_blocks_wide_lookup[bsize];
 373   const int bh = num_8x8_blocks_high_lookup[bsize];
 374   const int xmis = MIN(cm->mi_cols - mi_col, bw);
 375   const int ymis = MIN(cm->mi_rows - mi_row, bh);
 376   int x, y, segment_id = INT_MAX;
 377
 378   for (y = 0; y < ymis; y++)
 379     for (x = 0; x < xmis; x++)
 380       segment_id = MIN(segment_id,
 381                        segment_ids[mi_offset + y * cm->mi_cols + x]);
 382
 383   assert(segment_id >= 0 && segment_id < MAX_SEGMENTS);
 384   return segment_id;
 385 }