encodeframe.c 79.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 39
#include "vp9/common/pred_common.h"
#include "vp9/common/mvref_common.h"
Paul Wilkins's avatar
Paul Wilkins committed
40

Yaowu Xu's avatar
Yaowu Xu committed
41
#define DBG_PRNT_SEGMAP 0
42

John Koleszar's avatar
John Koleszar committed
43 44 45 46 47 48 49
#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
50

51
#ifdef ENC_DEBUG
John Koleszar's avatar
John Koleszar committed
52
int enc_debug = 0;
53 54 55
int mb_row_debug, mb_col_debug;
#endif

56 57
static void encode_inter_macroblock(VP9_COMP *cpi, MACROBLOCK *x,
                                    TOKENEXTRA **t, int recon_yoffset,
58 59
                                    int recon_uvoffset, int output_enabled,
                                    int mb_col, int mb_row);
60

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

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

68
static void encode_intra_super_block(VP9_COMP *cpi, MACROBLOCK *x,
69
                                     TOKENEXTRA **t, int mb_col, int mb_row);
70

71
static void adjust_act_zbin(VP9_COMP *cpi, MACROBLOCK *x);
72

John Koleszar's avatar
John Koleszar committed
73
#ifdef MODE_STATS
74
unsigned int inter_y_modes[MB_MODE_COUNT];
75
unsigned int inter_uv_modes[VP9_UV_MODES];
76
unsigned int inter_b_modes[B_MODE_COUNT];
77 78 79 80
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];
81
unsigned int b_modes[B_MODE_COUNT];
John Koleszar's avatar
John Koleszar committed
82 83 84
#endif


85 86 87
/* 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
88
 *  vp9_activity_masking().
89
 */
90
#define VP9_ACTIVITY_AVG_MIN (64)
91 92 93 94 95 96

/* 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.
 */
97
static const unsigned char VP9_VAR_OFFS[16] = {
John Koleszar's avatar
John Koleszar committed
98
  128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128
99 100
};

101 102

// Original activity measure from Tim T's code.
103
static unsigned int tt_activity_measure(VP9_COMP *cpi, MACROBLOCK *x) {
John Koleszar's avatar
John Koleszar committed
104 105 106 107 108 109 110 111 112
  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.).
   */
113
  act = vp9_variance16x16(x->src.y_buffer, x->src.y_stride, VP9_VAR_OFFS, 0,
114
                          &sse);
John Koleszar's avatar
John Koleszar committed
115 116 117 118 119 120 121
  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;
122 123
}

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


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

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

John Koleszar's avatar
John Koleszar committed
141 142 143 144 145 146
    // 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);
  }
147

148 149
  if (mb_activity < VP9_ACTIVITY_AVG_MIN)
    mb_activity = VP9_ACTIVITY_AVG_MIN;
150

John Koleszar's avatar
John Koleszar committed
151
  return mb_activity;
152 153 154
}

// Calculate an "average" mb activity value for the frame
155
#define ACT_MEDIAN 0
156
static void calc_av_activity(VP9_COMP *cpi, int64_t activity_sum) {
157
#if ACT_MEDIAN
John Koleszar's avatar
John Koleszar committed
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
  // 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;
      }
    }
187

John Koleszar's avatar
John Koleszar committed
188 189 190
    // 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;
191

John Koleszar's avatar
John Koleszar committed
192
    cpi->activity_avg = median;
193

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

201 202
  if (cpi->activity_avg < VP9_ACTIVITY_AVG_MIN)
    cpi->activity_avg = VP9_ACTIVITY_AVG_MIN;
203

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

209
#define USE_ACT_INDEX   0
210
#define OUTPUT_NORM_ACT_STATS   0
211 212 213

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

John Koleszar's avatar
John Koleszar committed
218 219 220
  int64_t act;
  int64_t a;
  int64_t b;
221 222

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

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

John Koleszar's avatar
John Koleszar committed
230 231 232 233 234 235
  // 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);
236

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

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

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

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

John Koleszar's avatar
John Koleszar committed
257
  }
258 259

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

}
264
#endif
265 266 267

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

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

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

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

    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;

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

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

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

    // 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
594
      if (xd->update_mb_segmentation_map)
Paul Wilkins's avatar
Paul Wilkins committed
595
        mbmi->segment_id = cpi->segmentation_map[map_index];
John Koleszar's avatar
John Koleszar committed
596
      else
Ronald S. Bultje's avatar
Ronald S. Bultje committed
597 598
        mbmi->segment_id = cm->last_frame_seg_map[map_index];
      if (mbmi->segment_id > 3)
Paul Wilkins's avatar
Paul Wilkins committed
599
        mbmi->segment_id = 0;
John Koleszar's avatar
John Koleszar committed
600

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

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

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

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

614
    vp9_intra_prediction_down_copy(xd);
615

John Koleszar's avatar
John Koleszar committed
616 617 618
    // 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
619
      int r, d;
620
      vp9_rd_pick_intra_mode(cpi, x, &r, &d);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
621 622
      *totalrate += r;
      *totaldist += d;
John Koleszar's avatar
John Koleszar committed
623 624

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

      // 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
631
    } else {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
632
      int seg_id, r, d;
John Koleszar's avatar
John Koleszar committed
633 634

      if (xd->segmentation_enabled && cpi->seg0_cnt > 0 &&
635 636 637 638 639 640
          !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
641 642 643 644 645
        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;
      }

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

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

Paul Wilkins's avatar
Paul Wilkins committed
655
      seg_id = mbmi->segment_id;
John Koleszar's avatar
John Koleszar committed
656 657 658 659
      if (cpi->mb.e_mbd.segmentation_enabled && seg_id == 0) {
        cpi->seg0_idx++;
      }
      if (!xd->segmentation_enabled ||
660 661 662 663 664
          !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
665
        // Get the prediction context and status
Paul Wilkins's avatar
Paul Wilkins committed
666 667
        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
668 669 670 671 672

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

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

John Koleszar's avatar
John Koleszar committed
678 679 680
    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
681

John Koleszar's avatar
John Koleszar committed
682 683 684 685
    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
686 687

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

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

Ronald S. Bultje's avatar
Ronald S. Bultje committed
702
#if CONFIG_SUPERBLOCKS
703 704
static void pick_sb_modes (VP9_COMP *cpi,
                           VP9_COMMON *cm,
Ronald S. Bultje's avatar
Ronald S. Bultje committed
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 748 749
                           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
750 751
  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
752
  x->mv_row_max = ((cm->mb_rows - mb_row) * 16 +
John Koleszar's avatar
John Koleszar committed
753
                   (VP9BORDERINPIXELS - 32 - VP9_INTERP_EXTEND));
Ronald S. Bultje's avatar
Ronald S. Bultje committed
754
  x->mv_col_max = ((cm->mb_cols - mb_col) * 16 +
John Koleszar's avatar
John Koleszar committed
755
                   (VP9BORDERINPIXELS - 32 - VP9_INTERP_EXTEND));
Ronald S. Bultje's avatar
Ronald S. Bultje committed
756 757 758 759 760 761 762 763 764 765 766 767

  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 */
768
  vp9_copy_mem16x16(x->src.y_buffer, x->src.y_stride, x->thismb, 16);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
769 770 771 772
#endif
  x->rddiv = cpi->RDDIV;
  x->rdmult = cpi->RDMULT;
  if(cpi->oxcf.tuning == VP8_TUNE_SSIM)
773
    vp9_activity_masking(cpi, x);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792
  /* 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;

793
    vp9_mb_init_quantizer(cpi, x);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
794 795 796 797 798 799 800 801 802 803 804 805 806
  }
  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)
  {
807
    vp9_rd_pick_intra_mode_sb(cpi, x,
Ronald S. Bultje's avatar
Ronald S. Bultje committed
808 809 810 811 812 813
                              totalrate,
                              totaldist);

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

828
    vp9_rd_pick_inter_mode_sb(cpi, x,
Ronald S. Bultje's avatar
Ronald S. Bultje committed
829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844
                              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

845 846
static void encode_sb(VP9_COMP *cpi,
                      VP9_COMMON *cm,
John Koleszar's avatar
John Koleszar committed
847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871
                      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
872
    MB_MODE_INFO * mbmi = &xd->mode_info_context->mbmi;
John Koleszar's avatar
John Koleszar committed
873 874 875 876 877 878 879 880 881 882 883 884 885 886

    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
887 888

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

John Koleszar's avatar
John Koleszar committed
895
    xd->mb_index = i;
Adrian Grange's avatar
Adrian Grange committed
896

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

John Koleszar's avatar
John Koleszar committed
904
    // Restore MB state to that when it was picked
Adrian Grange's avatar
Adrian Grange committed
905
#if CONFIG_SUPERBLOCKS
Ronald S. Bultje's avatar
Ronald S. Bultje committed
906
    if (xd->mode_info_context->mbmi.encoded_as_sb) {
John Koleszar's avatar
John Koleszar committed
907
      update_state(cpi, x, &x->sb_context[i]);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
908 909
      cpi->sb_count++;
    } else
Adrian Grange's avatar
Adrian Grange committed
910
#endif
John Koleszar's avatar
John Koleszar committed
911 912 913 914 915 916 917
      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
918
    xd->left_context  = cm->left_context + (i >> 1);
John Koleszar's avatar
John Koleszar committed
919 920 921 922 923 924 925

    // 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
926
#if CONFIG_SUPERBLOCKS
Ronald S. Bultje's avatar
Ronald S. Bultje committed
927 928 929
    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