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


#include "vpx_ports/config.h"
13
#include "vp9/encoder/encodeframe.h"
John Koleszar's avatar
John Koleszar committed
14 15
#include "encodemb.h"
#include "encodemv.h"
16
#include "vp9/common/common.h"
John Koleszar's avatar
John Koleszar committed
17
#include "onyx_int.h"
18 19 20
#include "vp9/common/extend.h"
#include "vp9/common/entropymode.h"
#include "vp9/common/quant_common.h"
21
#include "segmentation.h"
22 23
#include "vp9/common/setupintrarecon.h"
#include "vp9/common/reconintra4x4.h"
John Koleszar's avatar
John Koleszar committed
24
#include "encodeintra.h"
25 26
#include "vp9/common/reconinter.h"
#include "vp9/common/invtrans.h"
John Koleszar's avatar
John Koleszar committed
27
#include "rdopt.h"
28 29 30
#include "vp9/common/findnearmv.h"
#include "vp9/common/reconintra.h"
#include "vp9/common/seg_common.h"
31
#include "vp9/encoder/tokenize.h"
32
#include "vpx_rtcd.h"
John Koleszar's avatar
John Koleszar committed
33
#include <stdio.h>
34
#include <math.h>
John Koleszar's avatar
John Koleszar committed
35
#include <limits.h>
36
#include "vp9/common/subpixel.h"
John Koleszar's avatar
John Koleszar committed
37
#include "vpx_ports/vpx_timer.h"
38
#include "vp9/common/pred_common.h"
John Koleszar's avatar
John Koleszar committed
39

40
#define DBG_PRNT_SEGMAP 0
41
#if CONFIG_NEWBESTREFMV
42
#include "vp9/common/mvref_common.h"
Paul Wilkins's avatar
Paul Wilkins committed
43 44
#endif

45

John Koleszar's avatar
John Koleszar committed
46 47 48 49 50 51 52
#if CONFIG_RUNTIME_CPU_DETECT
#define RTCD(x)     &cpi->common.rtcd.x
#define IF_RTCD(x)  (x)
#else
#define RTCD(x)     NULL
#define IF_RTCD(x)  NULL
#endif
53

54
#ifdef ENC_DEBUG
John Koleszar's avatar
John Koleszar committed
55
int enc_debug = 0;
56 57 58
int mb_row_debug, mb_col_debug;
#endif

59 60 61
static void encode_inter_macroblock(VP9_COMP *cpi, MACROBLOCK *x,
                                    TOKENEXTRA **t, int recon_yoffset,
                                    int recon_uvoffset, int output_enabled);
62

63 64 65
static void encode_inter_superblock(VP9_COMP *cpi, MACROBLOCK *x,
                                    TOKENEXTRA **t, int recon_yoffset,
                                    int recon_uvoffset, int mb_col, int mb_row);
66

67 68
static void encode_intra_macro_block(VP9_COMP *cpi, MACROBLOCK *x,
                                     TOKENEXTRA **t, int output_enabled);
69

70 71
static void encode_intra_super_block(VP9_COMP *cpi, MACROBLOCK *x,
                                     TOKENEXTRA **t, int mb_col);
72

73
static void adjust_act_zbin(VP9_COMP *cpi, MACROBLOCK *x);
74

John Koleszar's avatar
John Koleszar committed
75
#ifdef MODE_STATS
76
unsigned int inter_y_modes[MB_MODE_COUNT];
77
unsigned int inter_uv_modes[VP9_UV_MODES];
78
unsigned int inter_b_modes[B_MODE_COUNT];
79 80 81 82
unsigned int y_modes[VP9_YMODES];
unsigned int i8x8_modes[VP9_I8X8_MODES];
unsigned int uv_modes[VP9_UV_MODES];
unsigned int uv_modes_y[VP9_YMODES][VP9_UV_MODES];
83
unsigned int b_modes[B_MODE_COUNT];
John Koleszar's avatar
John Koleszar committed
84 85 86
#endif


87 88 89
/* activity_avg must be positive, or flat regions could get a zero weight
 *  (infinite lambda), which confounds analysis.
 * This also avoids the need for divide by zero checks in
90
 *  vp9_activity_masking().
91
 */
92
#define VP9_ACTIVITY_AVG_MIN (64)
93 94 95 96 97 98

/* This is used as a reference when computing the source variance for the
 *  purposes of activity masking.
 * Eventually this should be replaced by custom no-reference routines,
 *  which will be faster.
 */
99
static const unsigned char VP9_VAR_OFFS[16] = {
John Koleszar's avatar
John Koleszar committed
100
  128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128
101 102
};

103 104

// Original activity measure from Tim T's code.
105
static unsigned int tt_activity_measure(VP9_COMP *cpi, MACROBLOCK *x) {
John Koleszar's avatar
John Koleszar committed
106 107 108 109 110 111 112 113 114
  unsigned int act;
  unsigned int sse;
  /* TODO: This could also be done over smaller areas (8x8), but that would
   *  require extensive changes elsewhere, as lambda is assumed to be fixed
   *  over an entire MB in most of the code.
   * Another option is to compute four 8x8 variances, and pick a single
   *  lambda using a non-linear combination (e.g., the smallest, or second
   *  smallest, etc.).
   */
115
  act = vp9_variance16x16(x->src.y_buffer, x->src.y_stride, VP9_VAR_OFFS, 0,
116
                          &sse);
John Koleszar's avatar
John Koleszar committed
117 118 119 120 121 122 123
  act = act << 4;

  /* If the region is flat, lower the activity some more. */
  if (act < 8 << 12)
    act = act < 5 << 12 ? act : 5 << 12;

  return act;
124 125
}

126
// Stub for alternative experimental activity measures.
127
static unsigned int alt_activity_measure(VP9_COMP *cpi,
John Koleszar's avatar
John Koleszar committed
128
                                         MACROBLOCK *x, int use_dc_pred) {
129
  return vp9_encode_intra(cpi, x, use_dc_pred);
130 131 132 133 134
}


// Measure the activity of the current macroblock
// What we measure here is TBD so abstracted to this function
135
#define ALT_ACT_MEASURE 1
136
static unsigned int mb_activity_measure(VP9_COMP *cpi, MACROBLOCK *x,
John Koleszar's avatar
John Koleszar committed
137 138
                                        int mb_row, int mb_col) {
  unsigned int mb_activity;
139

John Koleszar's avatar
John Koleszar committed
140 141
  if (ALT_ACT_MEASURE) {
    int use_dc_pred = (mb_col || mb_row) && (!mb_col || !mb_row);
142

John Koleszar's avatar
John Koleszar committed
143 144 145 146 147 148
    // Or use and alternative.
    mb_activity = alt_activity_measure(cpi, x, use_dc_pred);
  } else {
    // Original activity measure from Tim T's code.
    mb_activity = tt_activity_measure(cpi, x);
  }
149

150 151
  if (mb_activity < VP9_ACTIVITY_AVG_MIN)
    mb_activity = VP9_ACTIVITY_AVG_MIN;
152

John Koleszar's avatar
John Koleszar committed
153
  return mb_activity;
154 155 156
}

// Calculate an "average" mb activity value for the frame
157
#define ACT_MEDIAN 0
158
static void calc_av_activity(VP9_COMP *cpi, int64_t activity_sum) {
159
#if ACT_MEDIAN
John Koleszar's avatar
John Koleszar committed
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
  // Find median: Simple n^2 algorithm for experimentation
  {
    unsigned int median;
    unsigned int i, j;
    unsigned int *sortlist;
    unsigned int tmp;

    // Create a list to sort to
    CHECK_MEM_ERROR(sortlist,
    vpx_calloc(sizeof(unsigned int),
    cpi->common.MBs));

    // Copy map to sort list
    vpx_memcpy(sortlist, cpi->mb_activity_map,
    sizeof(unsigned int) * cpi->common.MBs);


    // Ripple each value down to its correct position
    for (i = 1; i < cpi->common.MBs; i ++) {
      for (j = i; j > 0; j --) {
        if (sortlist[j] < sortlist[j - 1]) {
          // Swap values
          tmp = sortlist[j - 1];
          sortlist[j - 1] = sortlist[j];
          sortlist[j] = tmp;
        } else
          break;
      }
    }
189

John Koleszar's avatar
John Koleszar committed
190 191 192
    // Even number MBs so estimate median as mean of two either side.
    median = (1 + sortlist[cpi->common.MBs >> 1] +
              sortlist[(cpi->common.MBs >> 1) + 1]) >> 1;
193

John Koleszar's avatar
John Koleszar committed
194
    cpi->activity_avg = median;
195

John Koleszar's avatar
John Koleszar committed
196 197
    vpx_free(sortlist);
  }
198
#else
John Koleszar's avatar
John Koleszar committed
199 200
  // Simple mean for now
  cpi->activity_avg = (unsigned int)(activity_sum / cpi->common.MBs);
201 202
#endif

203 204
  if (cpi->activity_avg < VP9_ACTIVITY_AVG_MIN)
    cpi->activity_avg = VP9_ACTIVITY_AVG_MIN;
205

John Koleszar's avatar
John Koleszar committed
206 207 208
  // Experimental code: return fixed value normalized for several clips
  if (ALT_ACT_MEASURE)
    cpi->activity_avg = 100000;
209 210
}

211
#define USE_ACT_INDEX   0
212
#define OUTPUT_NORM_ACT_STATS   0
213 214 215

#if USE_ACT_INDEX
// Calculate and activity index for each mb
216 217
static void calc_activity_index(VP9_COMP *cpi, MACROBLOCK *x) {
  VP9_COMMON *const cm = &cpi->common;
John Koleszar's avatar
John Koleszar committed
218
  int mb_row, mb_col;
219

John Koleszar's avatar
John Koleszar committed
220 221 222
  int64_t act;
  int64_t a;
  int64_t b;
223 224

#if OUTPUT_NORM_ACT_STATS
John Koleszar's avatar
John Koleszar committed
225 226
  FILE *f = fopen("norm_act.stt", "a");
  fprintf(f, "\n%12d\n", cpi->activity_avg);
227 228
#endif

John Koleszar's avatar
John Koleszar committed
229 230
  // Reset pointers to start of activity map
  x->mb_activity_ptr = cpi->mb_activity_map;
231

John Koleszar's avatar
John Koleszar committed
232 233 234 235 236 237
  // Calculate normalized mb activity number.
  for (mb_row = 0; mb_row < cm->mb_rows; mb_row++) {
    // for each macroblock col in image
    for (mb_col = 0; mb_col < cm->mb_cols; mb_col++) {
      // Read activity from the map
      act = *(x->mb_activity_ptr);
238

John Koleszar's avatar
John Koleszar committed
239 240 241
      // Calculate a normalized activity number
      a = act + 4 * cpi->activity_avg;
      b = 4 * act + cpi->activity_avg;
242

John Koleszar's avatar
John Koleszar committed
243 244 245 246
      if (b >= a)
        *(x->activity_ptr) = (int)((b + (a >> 1)) / a) - 1;
      else
        *(x->activity_ptr) = 1 - (int)((a + (b >> 1)) / b);
247 248

#if OUTPUT_NORM_ACT_STATS
John Koleszar's avatar
John Koleszar committed
249
      fprintf(f, " %6d", *(x->mb_activity_ptr));
250
#endif
John Koleszar's avatar
John Koleszar committed
251 252 253
      // Increment activity map pointers
      x->mb_activity_ptr++;
    }
254 255

#if OUTPUT_NORM_ACT_STATS
John Koleszar's avatar
John Koleszar committed
256
    fprintf(f, "\n");
257 258
#endif

John Koleszar's avatar
John Koleszar committed
259
  }
260 261

#if OUTPUT_NORM_ACT_STATS
John Koleszar's avatar
John Koleszar committed
262
  fclose(f);
263 264 265
#endif

}
266
#endif
267 268 269

// Loop through all MBs. Note activity of each, average activity and
// calculate a normalized activity for each
270
static void build_activity_map(VP9_COMP *cpi) {
John Koleszar's avatar
John Koleszar committed
271
  MACROBLOCK *const x = &cpi->mb;
John Koleszar's avatar
John Koleszar committed
272
  MACROBLOCKD *xd = &x->e_mbd;
273
  VP9_COMMON *const cm = &cpi->common;
274

275
#if ALT_ACT_MEASURE
John Koleszar's avatar
John Koleszar committed
276 277 278
  YV12_BUFFER_CONFIG *new_yv12 = &cm->yv12_fb[cm->new_fb_idx];
  int recon_yoffset;
  int recon_y_stride = new_yv12->y_stride;
279 280
#endif

John Koleszar's avatar
John Koleszar committed
281 282 283
  int mb_row, mb_col;
  unsigned int mb_activity;
  int64_t activity_sum = 0;
284

John Koleszar's avatar
John Koleszar committed
285 286
  // for each macroblock row in image
  for (mb_row = 0; mb_row < cm->mb_rows; mb_row++) {
287
#if ALT_ACT_MEASURE
John Koleszar's avatar
John Koleszar committed
288 289 290
    // reset above block coeffs
    xd->up_available = (mb_row != 0);
    recon_yoffset = (mb_row * recon_y_stride * 16);
291
#endif
John Koleszar's avatar
John Koleszar committed
292 293
    // for each macroblock col in image
    for (mb_col = 0; mb_col < cm->mb_cols; mb_col++) {
294
#if ALT_ACT_MEASURE
John Koleszar's avatar
John Koleszar committed
295 296 297
      xd->dst.y_buffer = new_yv12->y_buffer + recon_yoffset;
      xd->left_available = (mb_col != 0);
      recon_yoffset += 16;
298
#endif
John Koleszar's avatar
John Koleszar committed
299
      // Copy current mb to a buffer
300
      vp9_copy_mem16x16(x->src.y_buffer, x->src.y_stride, x->thismb, 16);
301

John Koleszar's avatar
John Koleszar committed
302 303
      // measure activity
      mb_activity = mb_activity_measure(cpi, x, mb_row, mb_col);
304

John Koleszar's avatar
John Koleszar committed
305 306
      // Keep frame sum
      activity_sum += mb_activity;
307

John Koleszar's avatar
John Koleszar committed
308 309
      // Store MB level activity details.
      *x->mb_activity_ptr = mb_activity;
310

John Koleszar's avatar
John Koleszar committed
311 312
      // Increment activity map pointer
      x->mb_activity_ptr++;
313

John Koleszar's avatar
John Koleszar committed
314 315 316
      // adjust to the next column of source macroblocks
      x->src.y_buffer += 16;
    }
317

318

John Koleszar's avatar
John Koleszar committed
319 320
    // adjust to the next row of mbs
    x->src.y_buffer += 16 * x->src.y_stride - 16 * cm->mb_cols;
321 322

#if ALT_ACT_MEASURE
John Koleszar's avatar
John Koleszar committed
323
    // extend the recon for intra prediction
324
    vp9_extend_mb_row(new_yv12, xd->dst.y_buffer + 16,
John Koleszar's avatar
John Koleszar committed
325
                      xd->dst.u_buffer + 8, xd->dst.v_buffer + 8);
326 327
#endif

John Koleszar's avatar
John Koleszar committed
328
  }
329

John Koleszar's avatar
John Koleszar committed
330 331
  // Calculate an "average" MB activity
  calc_av_activity(cpi, activity_sum);
332

333
#if USE_ACT_INDEX
John Koleszar's avatar
John Koleszar committed
334 335
  // Calculate an activity index number of each mb
  calc_activity_index(cpi, x);
336 337
#endif

338 339
}

340
// Macroblock activity masking
341
void vp9_activity_masking(VP9_COMP *cpi, MACROBLOCK *x) {
342
#if USE_ACT_INDEX
John Koleszar's avatar
John Koleszar committed
343 344 345
  x->rdmult += *(x->mb_activity_ptr) * (x->rdmult >> 2);
  x->errorperbit = x->rdmult * 100 / (110 * x->rddiv);
  x->errorperbit += (x->errorperbit == 0);
346
#else
John Koleszar's avatar
John Koleszar committed
347 348 349
  int64_t a;
  int64_t b;
  int64_t act = *(x->mb_activity_ptr);
350

John Koleszar's avatar
John Koleszar committed
351 352 353
  // Apply the masking to the RD multiplier.
  a = act + (2 * cpi->activity_avg);
  b = (2 * act) + cpi->activity_avg;
354

John Koleszar's avatar
John Koleszar committed
355 356 357
  x->rdmult = (unsigned int)(((int64_t)x->rdmult * b + (a >> 1)) / a);
  x->errorperbit = x->rdmult * 100 / (110 * x->rddiv);
  x->errorperbit += (x->errorperbit == 0);
358
#endif
359

John Koleszar's avatar
John Koleszar committed
360 361
  // Activity based Zbin adjustment
  adjust_act_zbin(cpi, x);
362
}
John Koleszar's avatar
John Koleszar committed
363

364
static void update_state(VP9_COMP *cpi, MACROBLOCK *x, PICK_MODE_CONTEXT *ctx) {
John Koleszar's avatar
John Koleszar committed
365 366 367
  int i;
  MACROBLOCKD *xd = &x->e_mbd;
  MODE_INFO *mi = &ctx->mic;
Paul Wilkins's avatar
Paul Wilkins committed
368
  MB_MODE_INFO * mbmi = &xd->mode_info_context->mbmi;
John Koleszar's avatar
John Koleszar committed
369 370
  int mb_mode = mi->mbmi.mode;
  int mb_mode_index = ctx->best_mode_index;
Adrian Grange's avatar
Adrian Grange committed
371 372

#if CONFIG_DEBUG
John Koleszar's avatar
John Koleszar committed
373 374 375
  assert(mb_mode < MB_MODE_COUNT);
  assert(mb_mode_index < MAX_MODES);
  assert(mi->mbmi.ref_frame < MAX_REF_FRAMES);
Adrian Grange's avatar
Adrian Grange committed
376 377
#endif

John Koleszar's avatar
John Koleszar committed
378 379 380
  // Restore the coding context of the MB to that that was in place
  // when the mode was picked for it
  vpx_memcpy(xd->mode_info_context, mi, sizeof(MODE_INFO));
Ronald S. Bultje's avatar
Ronald S. Bultje committed
381 382
#if CONFIG_SUPERBLOCKS
  if (mi->mbmi.encoded_as_sb) {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
383 384 385 386 387 388 389 390
    const int mis = cpi->common.mode_info_stride;
    if (xd->mb_to_right_edge > 0)
      vpx_memcpy(xd->mode_info_context + 1, mi, sizeof(MODE_INFO));
    if (xd->mb_to_bottom_edge > 0) {
      vpx_memcpy(xd->mode_info_context + mis, mi, sizeof(MODE_INFO));
      if (xd->mb_to_right_edge > 0)
        vpx_memcpy(xd->mode_info_context + mis + 1, mi, sizeof(MODE_INFO));
    }
Ronald S. Bultje's avatar
Ronald S. Bultje committed
391 392
  }
#endif
Adrian Grange's avatar
Adrian Grange committed
393

John Koleszar's avatar
John Koleszar committed
394 395 396 397
  if (mb_mode == B_PRED) {
    for (i = 0; i < 16; i++) {
      xd->block[i].bmi.as_mode = xd->mode_info_context->bmi[i].as_mode;
      assert(xd->block[i].bmi.as_mode.first < MB_MODE_COUNT);
Adrian Grange's avatar
Adrian Grange committed
398
    }
John Koleszar's avatar
John Koleszar committed
399 400 401
  } else if (mb_mode == I8X8_PRED) {
    for (i = 0; i < 16; i++) {
      xd->block[i].bmi = xd->mode_info_context->bmi[i];
Adrian Grange's avatar
Adrian Grange committed
402
    }
John Koleszar's avatar
John Koleszar committed
403 404 405 406
  } else if (mb_mode == SPLITMV) {
    vpx_memcpy(x->partition_info, &ctx->partition_info,
               sizeof(PARTITION_INFO));

407 408
    mbmi->mv[0].as_int = x->partition_info->bmi[15].mv.as_int;
    mbmi->mv[1].as_int = x->partition_info->bmi[15].second_mv.as_int;
John Koleszar's avatar
John Koleszar committed
409 410
  }

411 412
  {
    int segment_id = mbmi->segment_id;
413 414
    if (!vp9_segfeature_active(xd, segment_id, SEG_LVL_EOB) ||
        vp9_get_segdata(xd, segment_id, SEG_LVL_EOB)) {
415 416 417 418 419 420
      for (i = 0; i < NB_TXFM_MODES; i++) {
        cpi->rd_tx_select_diff[i] += ctx->txfm_rd_diff[i];
      }
    }
  }

John Koleszar's avatar
John Koleszar committed
421 422 423 424 425 426 427 428 429
  if (cpi->common.frame_type == KEY_FRAME) {
    // Restore the coding modes to that held in the coding context
    // if (mb_mode == B_PRED)
    //    for (i = 0; i < 16; i++)
    //    {
    //        xd->block[i].bmi.as_mode =
    //                          xd->mode_info_context->bmi[i].as_mode;
    //        assert(xd->mode_info_context->bmi[i].as_mode < MB_MODE_COUNT);
    //    }
430
#if CONFIG_INTERNAL_STATS
John Koleszar's avatar
John Koleszar committed
431 432 433 434 435 436 437 438 439 440 441 442 443 444 445
    static const int kf_mode_index[] = {
      THR_DC /*DC_PRED*/,
      THR_V_PRED /*V_PRED*/,
      THR_H_PRED /*H_PRED*/,
      THR_D45_PRED /*D45_PRED*/,
      THR_D135_PRED /*D135_PRED*/,
      THR_D117_PRED /*D117_PRED*/,
      THR_D153_PRED /*D153_PRED*/,
      THR_D27_PRED /*D27_PRED*/,
      THR_D63_PRED /*D63_PRED*/,
      THR_TM /*TM_PRED*/,
      THR_I8X8_PRED /*I8X8_PRED*/,
      THR_B_PRED /*B_PRED*/,
    };
    cpi->mode_chosen_counts[kf_mode_index[mb_mode]]++;
446
#endif
John Koleszar's avatar
John Koleszar committed
447 448 449 450 451 452 453
  } else {
    /*
            // Reduce the activation RD thresholds for the best choice mode
            if ((cpi->rd_baseline_thresh[mb_mode_index] > 0) &&
                (cpi->rd_baseline_thresh[mb_mode_index] < (INT_MAX >> 2)))
            {
                int best_adjustment = (cpi->rd_thresh_mult[mb_mode_index] >> 2);
Adrian Grange's avatar
Adrian Grange committed
454

John Koleszar's avatar
John Koleszar committed
455 456 457 458 459 460 461 462
                cpi->rd_thresh_mult[mb_mode_index] =
                        (cpi->rd_thresh_mult[mb_mode_index]
                         >= (MIN_THRESHMULT + best_adjustment)) ?
                                cpi->rd_thresh_mult[mb_mode_index] - best_adjustment :
                                MIN_THRESHMULT;
                cpi->rd_threshes[mb_mode_index] =
                        (cpi->rd_baseline_thresh[mb_mode_index] >> 7)
                        * cpi->rd_thresh_mult[mb_mode_index];
Adrian Grange's avatar
Adrian Grange committed
463

John Koleszar's avatar
John Koleszar committed
464 465 466 467
            }
    */
    // Note how often each mode chosen as best
    cpi->mode_chosen_counts[mb_mode_index]++;
Adrian Grange's avatar
Adrian Grange committed
468

John Koleszar's avatar
John Koleszar committed
469 470
    cpi->prediction_error += ctx->distortion;
    cpi->intra_error += ctx->intra_error;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
471 472 473 474

    cpi->rd_comp_pred_diff[0] += ctx->single_pred_diff;
    cpi->rd_comp_pred_diff[1] += ctx->comp_pred_diff;
    cpi->rd_comp_pred_diff[2] += ctx->hybrid_pred_diff;
John Koleszar's avatar
John Koleszar committed
475
  }
Adrian Grange's avatar
Adrian Grange committed
476 477
}

478 479
static void pick_mb_modes(VP9_COMP *cpi,
                          VP9_COMMON *cm,
John Koleszar's avatar
John Koleszar committed
480 481 482 483 484
                          int mb_row,
                          int mb_col,
                          MACROBLOCK  *x,
                          MACROBLOCKD *xd,
                          TOKENEXTRA **tp,
Ronald S. Bultje's avatar
Ronald S. Bultje committed
485 486
                          int *totalrate,
                          int *totaldist) {
John Koleszar's avatar
John Koleszar committed
487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504
  int i;
  int map_index;
  int recon_yoffset, recon_uvoffset;
  int ref_fb_idx = cm->lst_fb_idx;
  int dst_fb_idx = cm->new_fb_idx;
  int recon_y_stride = cm->yv12_fb[ref_fb_idx].y_stride;
  int recon_uv_stride = cm->yv12_fb[ref_fb_idx].uv_stride;
  ENTROPY_CONTEXT_PLANES left_context[2];
  ENTROPY_CONTEXT_PLANES above_context[2];
  ENTROPY_CONTEXT_PLANES *initial_above_context_ptr = cm->above_context
                                                      + mb_col;

  // Offsets to move pointers from MB to MB within a SB in raster order
  int row_delta[4] = { 0, +1,  0, -1};
  int col_delta[4] = { +1, -1, +1, +1};

  /* Function should not modify L & A contexts; save and restore on exit */
  vpx_memcpy(left_context,
Ronald S. Bultje's avatar
Ronald S. Bultje committed
505
             cm->left_context,
John Koleszar's avatar
John Koleszar committed
506 507 508 509 510 511 512 513 514 515 516
             sizeof(left_context));
  vpx_memcpy(above_context,
             initial_above_context_ptr,
             sizeof(above_context));

  /* Encode MBs in raster order within the SB */
  for (i = 0; i < 4; i++) {
    int dy = row_delta[i];
    int dx = col_delta[i];
    int offset_unextended = dy * cm->mb_cols + dx;
    int offset_extended   = dy * xd->mode_info_stride + dx;
Paul Wilkins's avatar
Paul Wilkins committed
517
    MB_MODE_INFO * mbmi = &xd->mode_info_context->mbmi;
John Koleszar's avatar
John Koleszar committed
518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534

    // TODO Many of the index items here can be computed more efficiently!

    if ((mb_row >= cm->mb_rows) || (mb_col >= cm->mb_cols)) {
      // MB lies outside frame, move on
      mb_row += dy;
      mb_col += dx;

      // Update pointers
      x->src.y_buffer += 16 * (dx + dy * x->src.y_stride);
      x->src.u_buffer += 8  * (dx + dy * x->src.uv_stride);
      x->src.v_buffer += 8  * (dx + dy * x->src.uv_stride);

      x->gf_active_ptr += offset_unextended;
      x->partition_info += offset_extended;
      xd->mode_info_context += offset_extended;
      xd->prev_mode_info_context += offset_extended;
Adrian Grange's avatar
Adrian Grange committed
535
#if CONFIG_DEBUG
John Koleszar's avatar
John Koleszar committed
536 537
      assert((xd->prev_mode_info_context - cpi->common.prev_mip) ==
             (xd->mode_info_context - cpi->common.mip));
Adrian Grange's avatar
Adrian Grange committed
538
#endif
John Koleszar's avatar
John Koleszar committed
539 540
      continue;
    }
541

John Koleszar's avatar
John Koleszar committed
542 543 544 545 546 547 548 549 550 551 552
    // Index of the MB in the SB 0..3
    xd->mb_index = i;

    map_index = (mb_row * cpi->common.mb_cols) + mb_col;
    x->mb_activity_ptr = &cpi->mb_activity_map[map_index];

    // set above context pointer
    xd->above_context = cm->above_context + mb_col;

    // Restore the appropriate left context depending on which
    // row in the SB the MB is situated
Ronald S. Bultje's avatar
Ronald S. Bultje committed
553
    xd->left_context = cm->left_context + (i >> 1);
John Koleszar's avatar
John Koleszar committed
554 555 556 557 558 559 560 561 562

    // Set up distance of MB to edge of frame in 1/8th pel units
    xd->mb_to_top_edge    = -((mb_row * 16) << 3);
    xd->mb_to_left_edge   = -((mb_col * 16) << 3);
    xd->mb_to_bottom_edge = ((cm->mb_rows - 1 - mb_row) * 16) << 3;
    xd->mb_to_right_edge  = ((cm->mb_cols - 1 - mb_col) * 16) << 3;

    // Set up limit values for MV components to prevent them from
    // extending beyond the UMV borders assuming 16x16 block size
John Koleszar's avatar
John Koleszar committed
563 564
    x->mv_row_min = -((mb_row * 16) + VP9BORDERINPIXELS - VP9_INTERP_EXTEND);
    x->mv_col_min = -((mb_col * 16) + VP9BORDERINPIXELS - VP9_INTERP_EXTEND);
John Koleszar's avatar
John Koleszar committed
565
    x->mv_row_max = ((cm->mb_rows - mb_row) * 16 +
John Koleszar's avatar
John Koleszar committed
566
                     (VP9BORDERINPIXELS - 16 - VP9_INTERP_EXTEND));
John Koleszar's avatar
John Koleszar committed
567
    x->mv_col_max = ((cm->mb_cols - mb_col) * 16 +
John Koleszar's avatar
John Koleszar committed
568
                     (VP9BORDERINPIXELS - 16 - VP9_INTERP_EXTEND));
John Koleszar's avatar
John Koleszar committed
569 570 571 572 573 574 575 576 577 578 579 580

    xd->up_available   = (mb_row != 0);
    xd->left_available = (mb_col != 0);

    recon_yoffset  = (mb_row * recon_y_stride * 16) + (mb_col * 16);
    recon_uvoffset = (mb_row * recon_uv_stride * 8) + (mb_col *  8);

    xd->dst.y_buffer = cm->yv12_fb[dst_fb_idx].y_buffer + recon_yoffset;
    xd->dst.u_buffer = cm->yv12_fb[dst_fb_idx].u_buffer + recon_uvoffset;
    xd->dst.v_buffer = cm->yv12_fb[dst_fb_idx].v_buffer + recon_uvoffset;

    // Copy current MB to a work buffer
581
    vp9_copy_mem16x16(x->src.y_buffer, x->src.y_stride, x->thismb, 16);
John Koleszar's avatar
John Koleszar committed
582 583 584 585 586

    x->rddiv = cpi->RDDIV;
    x->rdmult = cpi->RDMULT;

    if (cpi->oxcf.tuning == VP8_TUNE_SSIM)
587
      vp9_activity_masking(cpi, x);
John Koleszar's avatar
John Koleszar committed
588 589 590 591

    // Is segmentation enabled
    if (xd->segmentation_enabled) {
      // Code to set segment id in xd->mbmi.segment_id
Ronald S. Bultje's avatar
Ronald S. Bultje committed
592
      if (xd->update_mb_segmentation_map)
Paul Wilkins's avatar
Paul Wilkins committed
593
        mbmi->segment_id = cpi->segmentation_map[map_index];
John Koleszar's avatar
John Koleszar committed
594
      else
Ronald S. Bultje's avatar
Ronald S. Bultje committed
595 596
        mbmi->segment_id = cm->last_frame_seg_map[map_index];
      if (mbmi->segment_id > 3)
Paul Wilkins's avatar
Paul Wilkins committed
597
        mbmi->segment_id = 0;
John Koleszar's avatar
John Koleszar committed
598

599
      vp9_mb_init_quantizer(cpi, x);
John Koleszar's avatar
John Koleszar committed
600 601
    } else
      // Set to Segment 0 by default
Paul Wilkins's avatar
Paul Wilkins committed
602
      mbmi->segment_id = 0;
John Koleszar's avatar
John Koleszar committed
603 604 605

    x->active_ptr = cpi->active_map + map_index;

Ronald S. Bultje's avatar
Ronald S. Bultje committed
606 607 608 609
#if CONFIG_SUPERBLOCKS
    xd->mode_info_context->mbmi.encoded_as_sb = 0;
#endif

John Koleszar's avatar
John Koleszar committed
610 611
    cpi->update_context = 0;    // TODO Do we need this now??

612
    vp9_intra_prediction_down_copy(xd);
613

John Koleszar's avatar
John Koleszar committed
614 615 616
    // Find best coding mode & reconstruct the MB so it is available
    // as a predictor for MBs that follow in the SB
    if (cm->frame_type == KEY_FRAME) {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
617
      int r, d;
618
      vp9_rd_pick_intra_mode(cpi, x, &r, &d);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
619 620
      *totalrate += r;
      *totaldist += d;
John Koleszar's avatar
John Koleszar committed
621 622

      // Dummy encode, do not do the tokenization
623
      encode_intra_macro_block(cpi, x, tp, 0);
John Koleszar's avatar
John Koleszar committed
624
      // Note the encoder may have changed the segment_id
Ronald S. Bultje's avatar
Ronald S. Bultje committed
625 626 627 628

      // Save the coding context
      vpx_memcpy(&x->mb_context[i].mic, xd->mode_info_context,
                 sizeof(MODE_INFO));
John Koleszar's avatar
John Koleszar committed
629
    } else {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
630
      int seg_id, r, d;
John Koleszar's avatar
John Koleszar committed
631 632

      if (xd->segmentation_enabled && cpi->seg0_cnt > 0 &&
633 634 635 636 637 638
          !vp9_segfeature_active(xd, 0, SEG_LVL_REF_FRAME) &&
          vp9_segfeature_active(xd, 1, SEG_LVL_REF_FRAME) &&
          vp9_check_segref(xd, 1, INTRA_FRAME)  +
          vp9_check_segref(xd, 1, LAST_FRAME)   +
          vp9_check_segref(xd, 1, GOLDEN_FRAME) +
          vp9_check_segref(xd, 1, ALTREF_FRAME) == 1) {
John Koleszar's avatar
John Koleszar committed
639 640 641 642 643
        cpi->seg0_progress = (cpi->seg0_idx << 16) / cpi->seg0_cnt;
      } else {
        cpi->seg0_progress = (((mb_col & ~1) * 2 + (mb_row & ~1) * cm->mb_cols + i) << 16) / cm->MBs;
      }

644 645
      vp9_pick_mode_inter_macroblock(cpi, x, recon_yoffset,
                                     recon_uvoffset, &r, &d);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
646 647
      *totalrate += r;
      *totaldist += d;
John Koleszar's avatar
John Koleszar committed
648 649

      // Dummy encode, do not do the tokenization
650 651
      encode_inter_macroblock(cpi, x, tp,
                              recon_yoffset, recon_uvoffset, 0);
John Koleszar's avatar
John Koleszar committed
652

Paul Wilkins's avatar
Paul Wilkins committed
653
      seg_id = mbmi->segment_id;
John Koleszar's avatar
John Koleszar committed
654 655 656 657
      if (cpi->mb.e_mbd.segmentation_enabled && seg_id == 0) {
        cpi->seg0_idx++;
      }
      if (!xd->segmentation_enabled ||
658 659 660 661 662
          !vp9_segfeature_active(xd, seg_id, SEG_LVL_REF_FRAME) ||
          vp9_check_segref(xd, seg_id, INTRA_FRAME)  +
          vp9_check_segref(xd, seg_id, LAST_FRAME)   +
          vp9_check_segref(xd, seg_id, GOLDEN_FRAME) +
          vp9_check_segref(xd, seg_id, ALTREF_FRAME) > 1) {
John Koleszar's avatar
John Koleszar committed
663
        // Get the prediction context and status
Paul Wilkins's avatar
Paul Wilkins committed
664 665
        int pred_flag = vp9_get_pred_flag(xd, PRED_REF);
        int pred_context = vp9_get_pred_context(cm, xd, PRED_REF);
John Koleszar's avatar
John Koleszar committed
666 667 668 669 670

        // Count prediction success
        cpi->ref_pred_count[pred_context][pred_flag]++;
      }
    }
Adrian Grange's avatar
Adrian Grange committed
671

John Koleszar's avatar
John Koleszar committed
672 673 674
    // Next MB
    mb_row += dy;
    mb_col += dx;
Adrian Grange's avatar
Adrian Grange committed
675

John Koleszar's avatar
John Koleszar committed
676 677 678
    x->src.y_buffer += 16 * (dx + dy * x->src.y_stride);
    x->src.u_buffer += 8  * (dx + dy * x->src.uv_stride);
    x->src.v_buffer += 8  * (dx + dy * x->src.uv_stride);
Adrian Grange's avatar
Adrian Grange committed
679

John Koleszar's avatar
John Koleszar committed
680 681 682 683
    x->gf_active_ptr += offset_unextended;
    x->partition_info += offset_extended;
    xd->mode_info_context += offset_extended;
    xd->prev_mode_info_context += offset_extended;
Adrian Grange's avatar
Adrian Grange committed
684 685

#if CONFIG_DEBUG
John Koleszar's avatar
John Koleszar committed
686 687
    assert((xd->prev_mode_info_context - cpi->common.prev_mip) ==
           (xd->mode_info_context - cpi->common.mip));
Adrian Grange's avatar
Adrian Grange committed
688
#endif
John Koleszar's avatar
John Koleszar committed
689 690 691
  }

  /* Restore L & A coding context to those in place on entry */
Ronald S. Bultje's avatar
Ronald S. Bultje committed
692
  vpx_memcpy(cm->left_context,
John Koleszar's avatar
John Koleszar committed
693 694 695 696 697
             left_context,
             sizeof(left_context));
  vpx_memcpy(initial_above_context_ptr,
             above_context,
             sizeof(above_context));
Adrian Grange's avatar
Adrian Grange committed
698 699
}

Ronald S. Bultje's avatar
Ronald S. Bultje committed
700
#if CONFIG_SUPERBLOCKS
701 702
static void pick_sb_modes (VP9_COMP *cpi,
                           VP9_COMMON *cm,
Ronald S. Bultje's avatar
Ronald S. Bultje committed
703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747
                           int mb_row,
                           int mb_col,
                           MACROBLOCK  *x,
                           MACROBLOCKD *xd,
                           TOKENEXTRA **tp,
                           int *totalrate,
                           int *totaldist)
{
  int map_index;
  int recon_yoffset, recon_uvoffset;
  int ref_fb_idx = cm->lst_fb_idx;
  int dst_fb_idx = cm->new_fb_idx;
  int recon_y_stride = cm->yv12_fb[ref_fb_idx].y_stride;
  int recon_uv_stride = cm->yv12_fb[ref_fb_idx].uv_stride;
  ENTROPY_CONTEXT_PLANES left_context[2];
  ENTROPY_CONTEXT_PLANES above_context[2];
  ENTROPY_CONTEXT_PLANES *initial_above_context_ptr = cm->above_context
    + mb_col;

  /* Function should not modify L & A contexts; save and restore on exit */
  vpx_memcpy (left_context,
              cm->left_context,
              sizeof(left_context));
  vpx_memcpy (above_context,
              initial_above_context_ptr,
              sizeof(above_context));

  map_index = (mb_row * cpi->common.mb_cols) + mb_col;
  x->mb_activity_ptr = &cpi->mb_activity_map[map_index];

  /* set above context pointer */
  xd->above_context = cm->above_context + mb_col;

  /* Restore the appropriate left context depending on which
   * row in the SB the MB is situated */
  xd->left_context = cm->left_context;

  // Set up distance of MB to edge of frame in 1/8th pel units
  xd->mb_to_top_edge    = -((mb_row * 16) << 3);
  xd->mb_to_left_edge   = -((mb_col * 16) << 3);
  xd->mb_to_bottom_edge = ((cm->mb_rows - 1 - mb_row) * 16) << 3;
  xd->mb_to_right_edge  = ((cm->mb_cols - 1 - mb_col) * 16) << 3;

  /* Set up limit values for MV components to prevent them from
   * extending beyond the UMV borders assuming 16x16 block size */
John Koleszar's avatar
John Koleszar committed
748 749
  x->mv_row_min = -((mb_row * 16) + VP9BORDERINPIXELS - VP9_INTERP_EXTEND);
  x->mv_col_min = -((mb_col * 16) + VP9BORDERINPIXELS - VP9_INTERP_EXTEND);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
750
  x->mv_row_max = ((cm->mb_rows - mb_row) * 16 +
John Koleszar's avatar
John Koleszar committed
751
                   (VP9BORDERINPIXELS - 32 - VP9_INTERP_EXTEND));
Ronald S. Bultje's avatar
Ronald S. Bultje committed
752
  x->mv_col_max = ((cm->mb_cols - mb_col) * 16 +
John Koleszar's avatar
John Koleszar committed
753
                   (VP9BORDERINPIXELS - 32 - VP9_INTERP_EXTEND));
Ronald S. Bultje's avatar
Ronald S. Bultje committed
754 755 756 757 758 759 760 761 762 763 764 765

  xd->up_available   = (mb_row != 0);
  xd->left_available = (mb_col != 0);

  recon_yoffset  = (mb_row * recon_y_stride * 16) + (mb_col * 16);
  recon_uvoffset = (mb_row * recon_uv_stride * 8) + (mb_col *  8);

  xd->dst.y_buffer = cm->yv12_fb[dst_fb_idx].y_buffer + recon_yoffset;
  xd->dst.u_buffer = cm->yv12_fb[dst_fb_idx].u_buffer + recon_uvoffset;
  xd->dst.v_buffer = cm->yv12_fb[dst_fb_idx].v_buffer + recon_uvoffset;
#if 0 // FIXME
  /* Copy current MB to a work buffer */
766
  vp9_copy_mem16x16(x->src.y_buffer, x->src.y_stride, x->thismb, 16);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
767 768 769 770
#endif
  x->rddiv = cpi->RDDIV;
  x->rdmult = cpi->RDMULT;
  if(cpi->oxcf.tuning == VP8_TUNE_SSIM)
771
    vp9_activity_masking(cpi, x);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790
  /* Is segmentation enabled */
  if (xd->segmentation_enabled)
  {
    /* Code to set segment id in xd->mbmi.segment_id */
    if (xd->update_mb_segmentation_map)
      xd->mode_info_context->mbmi.segment_id =
            cpi->segmentation_map[map_index] &&
            cpi->segmentation_map[map_index + 1] &&
            cpi->segmentation_map[map_index + cm->mb_cols] &&
            cpi->segmentation_map[map_index + cm->mb_cols + 1];
    else
      xd->mode_info_context->mbmi.segment_id =
            cm->last_frame_seg_map[map_index] &&
            cm->last_frame_seg_map[map_index + 1] &&
            cm->last_frame_seg_map[map_index + cm->mb_cols] &&
            cm->last_frame_seg_map[map_index + cm->mb_cols + 1];
    if (xd->mode_info_context->mbmi.segment_id > 3)
      xd->mode_info_context->mbmi.segment_id = 0;

791
    vp9_mb_init_quantizer(cpi, x);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
792 793 794 795 796 797 798 799 800 801 802 803 804
  }
  else
    /* Set to Segment 0 by default */
    xd->mode_info_context->mbmi.segment_id = 0;

  x->active_ptr = cpi->active_map + map_index;
  
  cpi->update_context = 0;    // TODO Do we need this now??

  /* Find best coding mode & reconstruct the MB so it is available
   * as a predictor for MBs that follow in the SB */
  if (cm->frame_type == KEY_FRAME)
  {
805
    vp9_rd_pick_intra_mode_sb(cpi, x,
Ronald S. Bultje's avatar
Ronald S. Bultje committed
806 807 808 809 810 811
                              totalrate,
                              totaldist);

    /* Save the coding context */
    vpx_memcpy(&x->sb_context[0].mic, xd->mode_info_context,
               sizeof(MODE_INFO));
812
  } else {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
813
    if (xd->segmentation_enabled && cpi->seg0_cnt > 0 &&
814 815 816 817 818 819
        !vp9_segfeature_active(xd, 0, SEG_LVL_REF_FRAME) &&
        vp9_segfeature_active(xd, 1, SEG_LVL_REF_FRAME) &&
        vp9_check_segref(xd, 1, INTRA_FRAME)  +
        vp9_check_segref(xd, 1, LAST_FRAME)   +
        vp9_check_segref(xd, 1, GOLDEN_FRAME) +
        vp9_check_segref(xd, 1, ALTREF_FRAME) == 1) {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
820
      cpi->seg0_progress = (cpi->seg0_idx << 16) / cpi->seg0_cnt;
821
    } else {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
822 823 824 825
      cpi->seg0_progress =
        (((mb_col & ~1) * 2 + (mb_row & ~1) * cm->mb_cols) << 16) / cm->MBs;
    }

826
    vp9_rd_pick_inter_mode_sb(cpi, x,
Ronald S. Bultje's avatar
Ronald S. Bultje committed
827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842
                              recon_yoffset,
                              recon_uvoffset,
                              totalrate,
                              totaldist);
  }

  /* Restore L & A coding context to those in place on entry */
  vpx_memcpy (cm->left_context,
              left_context,
              sizeof(left_context));
  vpx_memcpy (initial_above_context_ptr,
              above_context,
              sizeof(above_context));
}
#endif

843 844
static void encode_sb(VP9_COMP *cpi,
                      VP9_COMMON *cm,
John Koleszar's avatar
John Koleszar committed
845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869
                      int mbrow,
                      int mbcol,
                      MACROBLOCK  *x,
                      MACROBLOCKD *xd,
                      TOKENEXTRA **tp) {
  int i;
  int map_index;
  int mb_row, mb_col;
  int recon_yoffset, recon_uvoffset;
  int ref_fb_idx = cm->lst_fb_idx;
  int dst_fb_idx = cm->new_fb_idx;
  int recon_y_stride = cm->yv12_fb[ref_fb_idx].y_stride;
  int recon_uv_stride = cm->yv12_fb[ref_fb_idx].uv_stride;
  int row_delta[4] = { 0, +1,  0, -1};
  int col_delta[4] = { +1, -1, +1, +1};

  mb_row = mbrow;
  mb_col = mbcol;

  /* Encode MBs in raster order within the SB */
  for (i = 0; i < 4; i++) {
    int dy = row_delta[i];
    int dx = col_delta[i];
    int offset_extended   = dy * xd->mode_info_stride + dx;
    int offset_unextended = dy * cm->mb_cols + dx;
Paul Wilkins's avatar
Paul Wilkins committed
870
    MB_MODE_INFO * mbmi = &xd->mode_info_context->mbmi;
John Koleszar's avatar
John Koleszar committed
871 872 873 874 875 876 877 878 879 880 881 882 883 884

    if ((mb_row >= cm->mb_rows) || (mb_col >= cm->mb_cols)) {
      // MB lies outside frame, move on
      mb_row += dy;
      mb_col += dx;

      x->src.y_buffer += 16 * (dx + dy * x->src.y_stride);
      x->src.u_buffer += 8  * (dx + dy * x->src.uv_stride);
      x->src.v_buffer += 8  * (dx + dy * x->src.uv_stride);

      x->gf_active_ptr      += offset_unextended;
      x->partition_info     += offset_extended;
      xd->mode_info_context += offset_extended;
      xd->prev_mode_info_context += offset_extended;
Adrian Grange's avatar
Adrian Grange committed
885 886

#if CONFIG_DEBUG
John Koleszar's avatar
John Koleszar committed
887 888
      assert((xd->prev_mode_info_context - cpi->common.prev_mip) ==
             (xd->mode_info_context - cpi->common.mip));
Adrian Grange's avatar
Adrian Grange committed
889
#endif
John Koleszar's avatar
John Koleszar committed
890 891
      continue;
    }
Adrian Grange's avatar
Adrian Grange committed
892

John Koleszar's avatar
John Koleszar committed
893
    xd->mb_index = i;
Adrian Grange's avatar
Adrian Grange committed
894

895
#ifdef ENC_DEBUG
John Koleszar's avatar
John Koleszar committed
896 897 898 899
    enc_debug = (cpi->common.current_video_frame == 0 &&
                 mb_row == 0 && mb_col == 0);
    mb_col_debug = mb_col;
    mb_row_debug = mb_row;
900
#endif
Adrian Grange's avatar
Adrian Grange committed
901

John Koleszar's avatar
John Koleszar committed
902
    // Restore MB state to that when it was picked
Adrian Grange's avatar
Adrian Grange committed
903
#if CONFIG_SUPERBLOCKS
Ronald S. Bultje's avatar
Ronald S. Bultje committed
904
    if (xd->mode_info_context->mbmi.encoded_as_sb) {
John Koleszar's avatar
John Koleszar committed
905
      update_state(cpi, x, &x->sb_context[i]);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
906 907
      cpi->sb_count++;
    } else
Adrian Grange's avatar
Adrian Grange committed
908
#endif
John Koleszar's avatar
John Koleszar committed
909 910 911 912 913 914 915
      update_state(cpi, x, &x->mb_context[i]);

    map_index = (mb_row * cpi->common.mb_cols) + mb_col;
    x->mb_activity_ptr = &cpi->mb_activity_map[map_index];

    // reset above block coeffs
    xd->above_context = cm->above_context + mb_col;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
916
    xd->left_context  = cm->left_context + (i >> 1);
John Koleszar's avatar
John Koleszar committed
917 918 919 920 921 922 923

    // Set up distance of MB to edge of the frame in 1/8th pel units
    xd->mb_to_top_edge    = -((mb_row * 16) << 3);
    xd->mb_to_left_edge   = -((mb_col * 16) << 3);
    xd->mb_to_bottom_edge = ((cm->mb_rows - 1 - mb_row) * 16) << 3;
    xd->mb_to_right_edge  = ((cm->mb_cols - 1 - mb_col) * 16) << 3;

Adrian Grange's avatar
Adrian Grange committed
924
#if CONFIG_SUPERBLOCKS
Ronald S. Bultje's avatar
Ronald S. Bultje committed
925 926 927
    if (xd->mode_info_context->mbmi.encoded_as_sb) {
      // Set up limit values for MV components to prevent them from
      // extending beyond the UMV borders assuming 32x32 block size
John Koleszar's avatar
John Koleszar committed
928 929
      x->mv_row_min = -((mb_row * 16) + VP9BORDERINPIXELS - VP9_INTERP_EXTEND);
      x->mv_col_min = -((mb_col * 16) + VP9BORDERINPIXELS - VP9_INTERP_EXTEND);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
930
      x->mv_row_max = ((cm->mb_rows - mb_row) * 16 +
John Koleszar's avatar
John Koleszar committed
931
                       (VP9BORDERINPIXELS - 32 - VP9_INTERP_EXTEND));
Ronald S. Bultje's avatar
Ronald S. Bultje committed
932
      x->mv_col_max = ((cm->mb_cols - mb_col) * 16 +
John Koleszar's avatar
John Koleszar committed
933
                       (VP9BORDERINPIXELS - 32 - VP9_INTERP_EXTEND));