encodeframe.c 78.4 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 "vp9_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 58 59
static void encode_macroblock(VP9_COMP *cpi, MACROBLOCK *x,
                              TOKENEXTRA **t, int recon_yoffset,
                              int recon_uvoffset, int output_enabled,
                              int mb_col, int mb_row);
60

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

65
static void adjust_act_zbin(VP9_COMP *cpi, MACROBLOCK *x);
66

John Koleszar's avatar
John Koleszar committed
67
#ifdef MODE_STATS
68
unsigned int inter_y_modes[MB_MODE_COUNT];
69
unsigned int inter_uv_modes[VP9_UV_MODES];
70
unsigned int inter_b_modes[B_MODE_COUNT];
71 72 73 74
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];
75
unsigned int b_modes[B_MODE_COUNT];
John Koleszar's avatar
John Koleszar committed
76 77 78
#endif


79 80 81
/* 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
82
 *  vp9_activity_masking().
83
 */
84
#define VP9_ACTIVITY_AVG_MIN (64)
85 86 87 88 89 90

/* 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.
 */
91
static const unsigned char VP9_VAR_OFFS[16] = {
John Koleszar's avatar
John Koleszar committed
92
  128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128
93 94
};

95 96

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

118
// Stub for alternative experimental activity measures.
119
static unsigned int alt_activity_measure(VP9_COMP *cpi,
John Koleszar's avatar
John Koleszar committed
120
                                         MACROBLOCK *x, int use_dc_pred) {
121
  return vp9_encode_intra(cpi, x, use_dc_pred);
122 123 124 125 126
}


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

John Koleszar's avatar
John Koleszar committed
132 133
  if (ALT_ACT_MEASURE) {
    int use_dc_pred = (mb_col || mb_row) && (!mb_col || !mb_row);
134

John Koleszar's avatar
John Koleszar committed
135 136 137 138 139 140
    // 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);
  }
141

142 143
  if (mb_activity < VP9_ACTIVITY_AVG_MIN)
    mb_activity = VP9_ACTIVITY_AVG_MIN;
144

John Koleszar's avatar
John Koleszar committed
145
  return mb_activity;
146 147 148
}

// Calculate an "average" mb activity value for the frame
149
#define ACT_MEDIAN 0
150
static void calc_av_activity(VP9_COMP *cpi, int64_t activity_sum) {
151
#if ACT_MEDIAN
John Koleszar's avatar
John Koleszar committed
152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180
  // 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;
      }
    }
181

John Koleszar's avatar
John Koleszar committed
182 183 184
    // 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;
185

John Koleszar's avatar
John Koleszar committed
186
    cpi->activity_avg = median;
187

John Koleszar's avatar
John Koleszar committed
188 189
    vpx_free(sortlist);
  }
190
#else
John Koleszar's avatar
John Koleszar committed
191 192
  // Simple mean for now
  cpi->activity_avg = (unsigned int)(activity_sum / cpi->common.MBs);
193 194
#endif

195 196
  if (cpi->activity_avg < VP9_ACTIVITY_AVG_MIN)
    cpi->activity_avg = VP9_ACTIVITY_AVG_MIN;
197

John Koleszar's avatar
John Koleszar committed
198 199 200
  // Experimental code: return fixed value normalized for several clips
  if (ALT_ACT_MEASURE)
    cpi->activity_avg = 100000;
201 202
}

203
#define USE_ACT_INDEX   0
204
#define OUTPUT_NORM_ACT_STATS   0
205 206 207

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

John Koleszar's avatar
John Koleszar committed
212 213 214
  int64_t act;
  int64_t a;
  int64_t b;
215 216

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

John Koleszar's avatar
John Koleszar committed
221 222
  // Reset pointers to start of activity map
  x->mb_activity_ptr = cpi->mb_activity_map;
223

John Koleszar's avatar
John Koleszar committed
224 225 226 227 228 229
  // 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);
230

John Koleszar's avatar
John Koleszar committed
231 232 233
      // Calculate a normalized activity number
      a = act + 4 * cpi->activity_avg;
      b = 4 * act + cpi->activity_avg;
234

John Koleszar's avatar
John Koleszar committed
235 236 237 238
      if (b >= a)
        *(x->activity_ptr) = (int)((b + (a >> 1)) / a) - 1;
      else
        *(x->activity_ptr) = 1 - (int)((a + (b >> 1)) / b);
239 240

#if OUTPUT_NORM_ACT_STATS
John Koleszar's avatar
John Koleszar committed
241
      fprintf(f, " %6d", *(x->mb_activity_ptr));
242
#endif
John Koleszar's avatar
John Koleszar committed
243 244 245
      // Increment activity map pointers
      x->mb_activity_ptr++;
    }
246 247

#if OUTPUT_NORM_ACT_STATS
John Koleszar's avatar
John Koleszar committed
248
    fprintf(f, "\n");
249 250
#endif

John Koleszar's avatar
John Koleszar committed
251
  }
252 253

#if OUTPUT_NORM_ACT_STATS
John Koleszar's avatar
John Koleszar committed
254
  fclose(f);
255 256 257
#endif

}
258
#endif
259 260 261

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

267
#if ALT_ACT_MEASURE
John Koleszar's avatar
John Koleszar committed
268 269 270
  YV12_BUFFER_CONFIG *new_yv12 = &cm->yv12_fb[cm->new_fb_idx];
  int recon_yoffset;
  int recon_y_stride = new_yv12->y_stride;
271 272
#endif

John Koleszar's avatar
John Koleszar committed
273 274 275
  int mb_row, mb_col;
  unsigned int mb_activity;
  int64_t activity_sum = 0;
276

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

John Koleszar's avatar
John Koleszar committed
296 297
      // measure activity
      mb_activity = mb_activity_measure(cpi, x, mb_row, mb_col);
298

John Koleszar's avatar
John Koleszar committed
299 300
      // Keep frame sum
      activity_sum += mb_activity;
301

John Koleszar's avatar
John Koleszar committed
302 303
      // Store MB level activity details.
      *x->mb_activity_ptr = mb_activity;
304

John Koleszar's avatar
John Koleszar committed
305 306
      // Increment activity map pointer
      x->mb_activity_ptr++;
307

John Koleszar's avatar
John Koleszar committed
308 309 310
      // adjust to the next column of source macroblocks
      x->src.y_buffer += 16;
    }
311

312

John Koleszar's avatar
John Koleszar committed
313 314
    // adjust to the next row of mbs
    x->src.y_buffer += 16 * x->src.y_stride - 16 * cm->mb_cols;
315 316

#if ALT_ACT_MEASURE
John Koleszar's avatar
John Koleszar committed
317
    // extend the recon for intra prediction
318
    vp9_extend_mb_row(new_yv12, xd->dst.y_buffer + 16,
John Koleszar's avatar
John Koleszar committed
319
                      xd->dst.u_buffer + 8, xd->dst.v_buffer + 8);
320 321
#endif

John Koleszar's avatar
John Koleszar committed
322
  }
323

John Koleszar's avatar
John Koleszar committed
324 325
  // Calculate an "average" MB activity
  calc_av_activity(cpi, activity_sum);
326

327
#if USE_ACT_INDEX
John Koleszar's avatar
John Koleszar committed
328 329
  // Calculate an activity index number of each mb
  calc_activity_index(cpi, x);
330 331
#endif

332 333
}

334
// Macroblock activity masking
335
void vp9_activity_masking(VP9_COMP *cpi, MACROBLOCK *x) {
336
#if USE_ACT_INDEX
John Koleszar's avatar
John Koleszar committed
337 338 339
  x->rdmult += *(x->mb_activity_ptr) * (x->rdmult >> 2);
  x->errorperbit = x->rdmult * 100 / (110 * x->rddiv);
  x->errorperbit += (x->errorperbit == 0);
340
#else
John Koleszar's avatar
John Koleszar committed
341 342 343
  int64_t a;
  int64_t b;
  int64_t act = *(x->mb_activity_ptr);
344

John Koleszar's avatar
John Koleszar committed
345 346 347
  // Apply the masking to the RD multiplier.
  a = act + (2 * cpi->activity_avg);
  b = (2 * act) + cpi->activity_avg;
348

John Koleszar's avatar
John Koleszar committed
349 350 351
  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);
352
#endif
353

John Koleszar's avatar
John Koleszar committed
354 355
  // Activity based Zbin adjustment
  adjust_act_zbin(cpi, x);
356
}
John Koleszar's avatar
John Koleszar committed
357

Deb Mukherjee's avatar
Deb Mukherjee committed
358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441
#if CONFIG_NEW_MVREF
static int vp9_cost_mv_ref_id(vp9_prob * ref_id_probs, int mv_ref_id) {
  int cost;

  // Encode the index for the MV reference.
  switch (mv_ref_id) {
    case 0:
      cost = vp9_cost_zero(ref_id_probs[0]);
      break;
    case 1:
      cost = vp9_cost_one(ref_id_probs[0]);
      cost += vp9_cost_zero(ref_id_probs[1]);
      break;
    case 2:
      cost = vp9_cost_one(ref_id_probs[0]);
      cost += vp9_cost_one(ref_id_probs[1]);
      cost += vp9_cost_zero(ref_id_probs[2]);
      break;
    case 3:
      cost = vp9_cost_one(ref_id_probs[0]);
      cost += vp9_cost_one(ref_id_probs[1]);
      cost += vp9_cost_one(ref_id_probs[2]);
      break;

      // TRAP.. This should not happen
    default:
      assert(0);
      break;
  }
  return cost;
}

// Estimate the cost of each coding the vector using each reference candidate
static unsigned int pick_best_mv_ref(MACROBLOCK *x,
                                     MV_REFERENCE_FRAME ref_frame,
                                     int_mv target_mv,
                                     int_mv * mv_ref_list,
                                     int_mv * best_ref) {
  int i;
  int best_index = 0;
  int cost, cost2;
  int zero_seen = (mv_ref_list[0].as_int) ? FALSE : TRUE;
  MACROBLOCKD *xd = &x->e_mbd;
  int max_mv = MV_MAX;

  cost = vp9_cost_mv_ref_id(xd->mb_mv_ref_id_probs[ref_frame], 0) +
         vp9_mv_bit_cost(&target_mv, &mv_ref_list[0], x->nmvjointcost,
                         x->mvcost, 96, xd->allow_high_precision_mv);

  // Use 4 for now : for (i = 1; i < MAX_MV_REFS; ++i ) {
  for (i = 1; i < 4; ++i) {
    // If we see a 0,0 reference vector for a second time we have reached
    // the end of the list of valid candidate vectors.
    if (!mv_ref_list[i].as_int)
      if (zero_seen)
        break;
      else
        zero_seen = TRUE;

    // Check for cases where the reference choice would give rise to an
    // uncodable/out of range residual for row or col.
    if ((abs(target_mv.as_mv.row - mv_ref_list[i].as_mv.row) > max_mv) ||
        (abs(target_mv.as_mv.col - mv_ref_list[i].as_mv.col) > max_mv)) {
      continue;
    }

    cost2 = vp9_cost_mv_ref_id(xd->mb_mv_ref_id_probs[ref_frame], i) +
            vp9_mv_bit_cost(&target_mv, &mv_ref_list[i], x->nmvjointcost,
                            x->mvcost, 96, xd->allow_high_precision_mv);

    if (cost2 < cost) {
      cost = cost2;
      best_index = i;
    }
  }

  best_ref->as_int = mv_ref_list[best_index].as_int;

  return best_index;
}
#endif

static void update_state(VP9_COMP *cpi, MACROBLOCK *x,
                         PICK_MODE_CONTEXT *ctx) {
John Koleszar's avatar
John Koleszar committed
442 443 444
  int i;
  MACROBLOCKD *xd = &x->e_mbd;
  MODE_INFO *mi = &ctx->mic;
Paul Wilkins's avatar
Paul Wilkins committed
445
  MB_MODE_INFO * mbmi = &xd->mode_info_context->mbmi;
John Koleszar's avatar
John Koleszar committed
446 447
  int mb_mode = mi->mbmi.mode;
  int mb_mode_index = ctx->best_mode_index;
Adrian Grange's avatar
Adrian Grange committed
448 449

#if CONFIG_DEBUG
John Koleszar's avatar
John Koleszar committed
450 451 452
  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
453 454
#endif

John Koleszar's avatar
John Koleszar committed
455 456 457
  // 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
458 459
#if CONFIG_SUPERBLOCKS
  if (mi->mbmi.encoded_as_sb) {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
460
    const int mis = cpi->common.mode_info_stride;
461
    if (xd->mb_to_right_edge >= 0)
Ronald S. Bultje's avatar
Ronald S. Bultje committed
462
      vpx_memcpy(xd->mode_info_context + 1, mi, sizeof(MODE_INFO));
463
    if (xd->mb_to_bottom_edge >= 0) {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
464
      vpx_memcpy(xd->mode_info_context + mis, mi, sizeof(MODE_INFO));
465
      if (xd->mb_to_right_edge >= 0)
Ronald S. Bultje's avatar
Ronald S. Bultje committed
466 467
        vpx_memcpy(xd->mode_info_context + mis + 1, mi, sizeof(MODE_INFO));
    }
Ronald S. Bultje's avatar
Ronald S. Bultje committed
468 469
  }
#endif
Adrian Grange's avatar
Adrian Grange committed
470

John Koleszar's avatar
John Koleszar committed
471 472 473 474
  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
475
    }
John Koleszar's avatar
John Koleszar committed
476 477 478
  } 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
479
    }
John Koleszar's avatar
John Koleszar committed
480 481 482 483
  } else if (mb_mode == SPLITMV) {
    vpx_memcpy(x->partition_info, &ctx->partition_info,
               sizeof(PARTITION_INFO));

484 485
    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
486 487
  }

488 489
  {
    int segment_id = mbmi->segment_id;
490 491
    if (!vp9_segfeature_active(xd, segment_id, SEG_LVL_EOB) ||
        vp9_get_segdata(xd, segment_id, SEG_LVL_EOB)) {
492 493 494 495 496 497
      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
498 499 500 501 502 503 504 505 506
  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);
    //    }
507
#if CONFIG_INTERNAL_STATS
John Koleszar's avatar
John Koleszar committed
508 509 510 511 512 513 514 515 516 517 518 519 520 521 522
    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]]++;
523
#endif
John Koleszar's avatar
John Koleszar committed
524 525 526 527 528 529 530
  } 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
531

John Koleszar's avatar
John Koleszar committed
532 533 534 535 536 537 538 539
                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
540

John Koleszar's avatar
John Koleszar committed
541 542 543 544
            }
    */
    // Note how often each mode chosen as best
    cpi->mode_chosen_counts[mb_mode_index]++;
Deb Mukherjee's avatar
Deb Mukherjee committed
545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574
    if (mbmi->mode == SPLITMV || mbmi->mode == NEWMV) {
      static int testcount = 0;
      int_mv best_mv, best_second_mv;
      unsigned int best_index;
      MV_REFERENCE_FRAME rf = mbmi->ref_frame;
      MV_REFERENCE_FRAME sec_ref_frame = mbmi->second_ref_frame;
      best_mv.as_int = ctx->best_ref_mv.as_int;
      best_second_mv.as_int = ctx->second_best_ref_mv.as_int;
      if (mbmi->mode == NEWMV) {
        best_mv.as_int = mbmi->ref_mvs[rf][0].as_int;
        best_second_mv.as_int = mbmi->ref_mvs[mbmi->second_ref_frame][0].as_int;
#if CONFIG_NEW_MVREF
        best_index = pick_best_mv_ref(x, rf, mbmi->mv[0],
                                      mbmi->ref_mvs[rf], &best_mv);
        mbmi->best_index = best_index;

        if (mbmi->second_ref_frame) {
          unsigned int best_index;
          best_index =
              pick_best_mv_ref(x, sec_ref_frame, mbmi->mv[1],
                               mbmi->ref_mvs[sec_ref_frame],
                               &best_second_mv);
          mbmi->best_second_index = best_index;
        }
#endif
      }
      mbmi->best_mv.as_int = best_mv.as_int;
      mbmi->best_second_mv.as_int = best_second_mv.as_int;
      vp9_update_nmv_count(cpi, x, &best_mv, &best_second_mv);
    }
575 576 577 578 579 580 581 582 583 584 585 586 587 588
#if CONFIG_COMP_INTERINTRA_PRED
    if (mbmi->mode >= NEARESTMV && mbmi->mode < SPLITMV &&
        mbmi->second_ref_frame <= INTRA_FRAME) {
      if (mbmi->second_ref_frame == INTRA_FRAME) {
        ++cpi->interintra_count[1];
        ++cpi->ymode_count[mbmi->interintra_mode];
#if SEPARATE_INTERINTRA_UV
        ++cpi->y_uv_mode_count[mbmi->interintra_mode][mbmi->interintra_uv_mode];
#endif
      } else {
        ++cpi->interintra_count[0];
      }
    }
#endif
Adrian Grange's avatar
Adrian Grange committed
589

John Koleszar's avatar
John Koleszar committed
590 591
    cpi->prediction_error += ctx->distortion;
    cpi->intra_error += ctx->intra_error;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
592

593 594 595
    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
596
  }
Adrian Grange's avatar
Adrian Grange committed
597 598
}

599 600
static void pick_mb_modes(VP9_COMP *cpi,
                          VP9_COMMON *cm,
John Koleszar's avatar
John Koleszar committed
601 602 603 604 605
                          int mb_row,
                          int mb_col,
                          MACROBLOCK  *x,
                          MACROBLOCKD *xd,
                          TOKENEXTRA **tp,
Ronald S. Bultje's avatar
Ronald S. Bultje committed
606 607
                          int *totalrate,
                          int *totaldist) {
John Koleszar's avatar
John Koleszar committed
608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625
  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
626
             cm->left_context,
John Koleszar's avatar
John Koleszar committed
627 628 629 630 631 632 633 634 635 636 637
             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
638
    MB_MODE_INFO * mbmi = &xd->mode_info_context->mbmi;
John Koleszar's avatar
John Koleszar committed
639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655

    // 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
656
#if CONFIG_DEBUG
John Koleszar's avatar
John Koleszar committed
657 658
      assert((xd->prev_mode_info_context - cpi->common.prev_mip) ==
             (xd->mode_info_context - cpi->common.mip));
Adrian Grange's avatar
Adrian Grange committed
659
#endif
John Koleszar's avatar
John Koleszar committed
660 661
      continue;
    }
662

John Koleszar's avatar
John Koleszar committed
663 664 665 666 667 668 669 670 671 672 673
    // 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
674
    xd->left_context = cm->left_context + (i >> 1);
John Koleszar's avatar
John Koleszar committed
675 676 677 678 679 680 681 682 683

    // 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
684 685
    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
686
    x->mv_row_max = ((cm->mb_rows - mb_row) * 16 +
John Koleszar's avatar
John Koleszar committed
687
                     (VP9BORDERINPIXELS - 16 - VP9_INTERP_EXTEND));
John Koleszar's avatar
John Koleszar committed
688
    x->mv_col_max = ((cm->mb_cols - mb_col) * 16 +
John Koleszar's avatar
John Koleszar committed
689
                     (VP9BORDERINPIXELS - 16 - VP9_INTERP_EXTEND));
John Koleszar's avatar
John Koleszar committed
690 691 692 693 694 695 696 697 698 699 700

    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;

701
#if !CONFIG_SUPERBLOCKS
John Koleszar's avatar
John Koleszar committed
702
    // Copy current MB to a work buffer
703
    vp9_copy_mem16x16(x->src.y_buffer, x->src.y_stride, x->thismb, 16);
704
#endif
John Koleszar's avatar
John Koleszar committed
705 706 707 708 709

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

    if (cpi->oxcf.tuning == VP8_TUNE_SSIM)
710
      vp9_activity_masking(cpi, x);
John Koleszar's avatar
John Koleszar committed
711 712 713 714

    // 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
715
      if (xd->update_mb_segmentation_map)
Paul Wilkins's avatar
Paul Wilkins committed
716
        mbmi->segment_id = cpi->segmentation_map[map_index];
John Koleszar's avatar
John Koleszar committed
717
      else
Ronald S. Bultje's avatar
Ronald S. Bultje committed
718 719
        mbmi->segment_id = cm->last_frame_seg_map[map_index];
      if (mbmi->segment_id > 3)
Paul Wilkins's avatar
Paul Wilkins committed
720
        mbmi->segment_id = 0;
John Koleszar's avatar
John Koleszar committed
721

722
      vp9_mb_init_quantizer(cpi, x);
John Koleszar's avatar
John Koleszar committed
723 724
    } else
      // Set to Segment 0 by default
Paul Wilkins's avatar
Paul Wilkins committed
725
      mbmi->segment_id = 0;
John Koleszar's avatar
John Koleszar committed
726 727 728

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

Ronald S. Bultje's avatar
Ronald S. Bultje committed
729 730 731 732
#if CONFIG_SUPERBLOCKS
    xd->mode_info_context->mbmi.encoded_as_sb = 0;
#endif

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

735
    vp9_intra_prediction_down_copy(xd);
736

John Koleszar's avatar
John Koleszar committed
737 738 739
    // 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
740
      int r, d;
741
      vp9_rd_pick_intra_mode(cpi, x, &r, &d);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
742 743
      *totalrate += r;
      *totaldist += d;
John Koleszar's avatar
John Koleszar committed
744 745

      // Dummy encode, do not do the tokenization
746 747
      encode_macroblock(cpi, x, tp,
                        recon_yoffset, recon_uvoffset, 0, mb_col, mb_row);
John Koleszar's avatar
John Koleszar committed
748
      // Note the encoder may have changed the segment_id
Ronald S. Bultje's avatar
Ronald S. Bultje committed
749 750 751 752

      // 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
753
    } else {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
754
      int seg_id, r, d;
John Koleszar's avatar
John Koleszar committed
755 756

      if (xd->segmentation_enabled && cpi->seg0_cnt > 0 &&
757 758 759 760 761 762
          !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
763 764 765 766 767
        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;
      }

768 769
      vp9_pick_mode_inter_macroblock(cpi, x, recon_yoffset,
                                     recon_uvoffset, &r, &d);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
770 771
      *totalrate += r;
      *totaldist += d;
John Koleszar's avatar
John Koleszar committed
772 773

      // Dummy encode, do not do the tokenization
774 775
      encode_macroblock(cpi, x, tp,
                        recon_yoffset, recon_uvoffset, 0, mb_col, mb_row);
John Koleszar's avatar
John Koleszar committed
776

Paul Wilkins's avatar
Paul Wilkins committed
777
      seg_id = mbmi->segment_id;
John Koleszar's avatar
John Koleszar committed
778 779 780 781
      if (cpi->mb.e_mbd.segmentation_enabled && seg_id == 0) {
        cpi->seg0_idx++;
      }
      if (!xd->segmentation_enabled ||
782 783 784 785 786
          !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
787
        // Get the prediction context and status
Paul Wilkins's avatar
Paul Wilkins committed
788 789
        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
790 791 792 793 794

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

John Koleszar's avatar
John Koleszar committed
796 797 798
    // Next MB
    mb_row += dy;
    mb_col += dx;
Adrian Grange's avatar
Adrian Grange committed
799

John Koleszar's avatar
John Koleszar committed
800 801 802
    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
803

John Koleszar's avatar
John Koleszar committed
804 805 806 807
    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
808 809

#if CONFIG_DEBUG
John Koleszar's avatar
John Koleszar committed
810 811
    assert((xd->prev_mode_info_context - cpi->common.prev_mip) ==
           (xd->mode_info_context - cpi->common.mip));
Adrian Grange's avatar
Adrian Grange committed
812
#endif
John Koleszar's avatar
John Koleszar committed
813 814 815
  }

  /* Restore L & A coding context to those in place on entry */
Ronald S. Bultje's avatar
Ronald S. Bultje committed
816
  vpx_memcpy(cm->left_context,
John Koleszar's avatar
John Koleszar committed
817 818 819 820 821
             left_context,
             sizeof(left_context));
  vpx_memcpy(initial_above_context_ptr,
             above_context,
             sizeof(above_context));
Adrian Grange's avatar
Adrian Grange committed
822 823
}

Ronald S. Bultje's avatar
Ronald S. Bultje committed
824
#if CONFIG_SUPERBLOCKS
825 826
static void pick_sb_modes (VP9_COMP *cpi,
                           VP9_COMMON *cm,
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 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866
                           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);
867 868
  xd->mb_to_bottom_edge = ((cm->mb_rows - 2 - mb_row) * 16) << 3;
  xd->mb_to_right_edge  = ((cm->mb_cols - 2 - mb_col) * 16) << 3;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
869 870 871

  /* 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
872 873
  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
874
  x->mv_row_max = ((cm->mb_rows - mb_row) * 16 +
John Koleszar's avatar
John Koleszar committed
875
                   (VP9BORDERINPIXELS - 32 - VP9_INTERP_EXTEND));
Ronald S. Bultje's avatar
Ronald S. Bultje committed
876
  x->mv_col_max = ((cm->mb_cols - mb_col) * 16 +
John Koleszar's avatar
John Koleszar committed
877
                   (VP9BORDERINPIXELS - 32 - VP9_INTERP_EXTEND));
Ronald S. Bultje's avatar
Ronald S. Bultje committed
878 879 880 881 882 883 884 885 886 887 888 889

  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 */
890
  vp9_copy_mem16x16(x->src.y_buffer, x->src.y_stride, x->thismb, 16);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
891 892 893 894
#endif
  x->rddiv = cpi->RDDIV;
  x->rdmult = cpi->RDMULT;
  if(cpi->oxcf.tuning == VP8_TUNE_SSIM)
895
    vp9_activity_masking(cpi, x);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914
  /* 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;

915
    vp9_mb_init_quantizer(cpi, x);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
916 917 918 919 920 921 922 923 924 925 926 927 928
  }
  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)
  {
929
    vp9_rd_pick_intra_mode_sb(cpi, x,
Ronald S. Bultje's avatar
Ronald S. Bultje committed
930 931 932 933 934 935
                              totalrate,
                              totaldist);

    /* Save the coding context */
    vpx_memcpy(&x->sb_context[0].mic, xd->mode_info_context,
               sizeof(MODE_INFO));
936
  } else {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
937
    if (xd->segmentation_enabled && cpi->seg0_cnt > 0 &&
938 939 940 941 942 943
        !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
944
      cpi->seg0_progress = (cpi->seg0_idx << 16) / cpi->seg0_cnt;
945
    } else {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
946 947 948 949
      cpi->seg0_progress =
        (((mb_col & ~1) * 2 + (mb_row & ~1) * cm->mb_cols) << 16) / cm->MBs;
    }

950
    vp9_rd_pick_inter_mode_sb(cpi, x,
Ronald S. Bultje's avatar
Ronald S. Bultje committed
951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966
                              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

967 968
static void encode_sb(VP9_COMP *cpi,
                      VP9_COMMON *cm,
John Koleszar's avatar
John Koleszar committed
969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993
                      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
994
    MB_MODE_INFO * mbmi = &xd->mode_info_context->mbmi;
John Koleszar's avatar
John Koleszar committed
995 996