vp9_encodeframe.c 90.5 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
#include "./vpx_config.h"
Jim Bankoski's avatar
Jim Bankoski committed
12
#include "./vp9_rtcd.h"
13
#include "vp9/encoder/vp9_encodeframe.h"
14
15
#include "vp9/encoder/vp9_encodemb.h"
#include "vp9/encoder/vp9_encodemv.h"
16
#include "vp9/common/vp9_common.h"
17
#include "vp9/encoder/vp9_onyx_int.h"
18
#include "vp9/common/vp9_extend.h"
Yaowu Xu's avatar
Yaowu Xu committed
19
#include "vp9/common/vp9_entropy.h"
20
21
#include "vp9/common/vp9_entropymode.h"
#include "vp9/common/vp9_quant_common.h"
22
23
#include "vp9/encoder/vp9_segmentation.h"
#include "vp9/encoder/vp9_encodeintra.h"
24
#include "vp9/common/vp9_reconinter.h"
25
#include "vp9/encoder/vp9_rdopt.h"
26
27
28
#include "vp9/common/vp9_findnearmv.h"
#include "vp9/common/vp9_reconintra.h"
#include "vp9/common/vp9_seg_common.h"
29
#include "vp9/common/vp9_tile_common.h"
30
#include "vp9/encoder/vp9_tokenize.h"
Yaowu Xu's avatar
Yaowu Xu committed
31
#include "./vp9_rtcd.h"
John Koleszar's avatar
John Koleszar committed
32
#include <stdio.h>
33
#include <math.h>
John Koleszar's avatar
John Koleszar committed
34
35
#include <limits.h>
#include "vpx_ports/vpx_timer.h"
36
37
#include "vp9/common/vp9_pred_common.h"
#include "vp9/common/vp9_mvref_common.h"
Paul Wilkins's avatar
Paul Wilkins committed
38

Yaowu Xu's avatar
Yaowu Xu committed
39
#define DBG_PRNT_SEGMAP 0
40

41
// #define ENC_DEBUG
42
#ifdef ENC_DEBUG
John Koleszar's avatar
John Koleszar committed
43
int enc_debug = 0;
44
45
#endif

Jim Bankoski's avatar
Jim Bankoski committed
46
47
static void encode_superblock(VP9_COMP *cpi, TOKENEXTRA **t, int output_enabled,
                              int mi_row, int mi_col, BLOCK_SIZE_TYPE bsize);
48

49
static void adjust_act_zbin(VP9_COMP *cpi, MACROBLOCK *x);
50

51
52
53
/* 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
54
 *  vp9_activity_masking().
55
 */
56
#define VP9_ACTIVITY_AVG_MIN (64)
57
58
59
60
61
62

/* 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.
 */
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
static const uint8_t VP9_VAR_OFFS[64] = {
  128, 128, 128, 128, 128, 128, 128, 128,
  128, 128, 128, 128, 128, 128, 128, 128,
  128, 128, 128, 128, 128, 128, 128, 128,
  128, 128, 128, 128, 128, 128, 128, 128,
  128, 128, 128, 128, 128, 128, 128, 128,
  128, 128, 128, 128, 128, 128, 128, 128,
  128, 128, 128, 128, 128, 128, 128, 128,
  128, 128, 128, 128, 128, 128, 128, 128
};

static unsigned int get_sb_variance(VP9_COMP *cpi, MACROBLOCK *x,
                                    BLOCK_SIZE_TYPE bs) {
  unsigned int var, sse;
  var = cpi->fn_ptr[bs].vf(x->plane[0].src.buf,
                           x->plane[0].src.stride,
                           VP9_VAR_OFFS, 0, &sse);
  return var >> num_pels_log2_lookup[bs];
}
82
83

// Original activity measure from Tim T's code.
84
static unsigned int tt_activity_measure(MACROBLOCK *x) {
John Koleszar's avatar
John Koleszar committed
85
86
87
88
89
90
91
92
93
  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.).
   */
John Koleszar's avatar
John Koleszar committed
94
95
  act = vp9_variance16x16(x->plane[0].src.buf, x->plane[0].src.stride,
                          VP9_VAR_OFFS, 0, &sse);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
96
  act <<= 4;
John Koleszar's avatar
John Koleszar committed
97
98
99
100
101
102

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

  return act;
103
104
}

105
// Stub for alternative experimental activity measures.
Jim Bankoski's avatar
Jim Bankoski committed
106
107
static unsigned int alt_activity_measure(VP9_COMP *cpi, MACROBLOCK *x,
                                         int use_dc_pred) {
108
  return vp9_encode_intra(cpi, x, use_dc_pred);
109
}
Jim Bankoski's avatar
Jim Bankoski committed
110
DECLARE_ALIGNED(16, static const uint8_t, vp9_64x64_zeros[64*64]) = {0};
111
112
113

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

John Koleszar's avatar
John Koleszar committed
119
120
  if (ALT_ACT_MEASURE) {
    int use_dc_pred = (mb_col || mb_row) && (!mb_col || !mb_row);
121

John Koleszar's avatar
John Koleszar committed
122
123
124
125
    // Or use and alternative.
    mb_activity = alt_activity_measure(cpi, x, use_dc_pred);
  } else {
    // Original activity measure from Tim T's code.
126
    mb_activity = tt_activity_measure(x);
John Koleszar's avatar
John Koleszar committed
127
  }
128

129
130
  if (mb_activity < VP9_ACTIVITY_AVG_MIN)
    mb_activity = VP9_ACTIVITY_AVG_MIN;
131

John Koleszar's avatar
John Koleszar committed
132
  return mb_activity;
133
134
135
}

// Calculate an "average" mb activity value for the frame
136
#define ACT_MEDIAN 0
137
static void calc_av_activity(VP9_COMP *cpi, int64_t activity_sum) {
138
#if ACT_MEDIAN
John Koleszar's avatar
John Koleszar committed
139
140
141
142
143
144
145
146
  // 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
147
148
    CHECK_MEM_ERROR(&cpi->common, sortlist, vpx_calloc(sizeof(unsigned int),
                    cpi->common.MBs));
John Koleszar's avatar
John Koleszar committed
149
150
151

    // Copy map to sort list
    vpx_memcpy(sortlist, cpi->mb_activity_map,
Jim Bankoski's avatar
Jim Bankoski committed
152
        sizeof(unsigned int) * cpi->common.MBs);
John Koleszar's avatar
John Koleszar committed
153
154
155
156
157
158
159
160
161
162

    // 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
Jim Bankoski's avatar
Jim Bankoski committed
163
        break;
John Koleszar's avatar
John Koleszar committed
164
165
      }
    }
166

John Koleszar's avatar
John Koleszar committed
167
168
    // Even number MBs so estimate median as mean of two either side.
    median = (1 + sortlist[cpi->common.MBs >> 1] +
Jim Bankoski's avatar
Jim Bankoski committed
169
        sortlist[(cpi->common.MBs >> 1) + 1]) >> 1;
170

John Koleszar's avatar
John Koleszar committed
171
    cpi->activity_avg = median;
172

John Koleszar's avatar
John Koleszar committed
173
174
    vpx_free(sortlist);
  }
175
#else
John Koleszar's avatar
John Koleszar committed
176
  // Simple mean for now
Jim Bankoski's avatar
Jim Bankoski committed
177
  cpi->activity_avg = (unsigned int) (activity_sum / cpi->common.MBs);
178
179
#endif

180
181
  if (cpi->activity_avg < VP9_ACTIVITY_AVG_MIN)
    cpi->activity_avg = VP9_ACTIVITY_AVG_MIN;
182

John Koleszar's avatar
John Koleszar committed
183
184
185
  // Experimental code: return fixed value normalized for several clips
  if (ALT_ACT_MEASURE)
    cpi->activity_avg = 100000;
186
187
}

188
#define USE_ACT_INDEX   0
189
#define OUTPUT_NORM_ACT_STATS   0
190
191

#if USE_ACT_INDEX
192
// Calculate an activity index for each mb
193
194
static void calc_activity_index(VP9_COMP *cpi, MACROBLOCK *x) {
  VP9_COMMON *const cm = &cpi->common;
John Koleszar's avatar
John Koleszar committed
195
  int mb_row, mb_col;
196

John Koleszar's avatar
John Koleszar committed
197
198
199
  int64_t act;
  int64_t a;
  int64_t b;
200
201

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

John Koleszar's avatar
John Koleszar committed
206
207
  // Reset pointers to start of activity map
  x->mb_activity_ptr = cpi->mb_activity_map;
208

John Koleszar's avatar
John Koleszar committed
209
210
211
212
213
214
  // 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);
215

John Koleszar's avatar
John Koleszar committed
216
217
218
      // Calculate a normalized activity number
      a = act + 4 * cpi->activity_avg;
      b = 4 * act + cpi->activity_avg;
219

John Koleszar's avatar
John Koleszar committed
220
      if (b >= a)
Jim Bankoski's avatar
Jim Bankoski committed
221
      *(x->activity_ptr) = (int)((b + (a >> 1)) / a) - 1;
John Koleszar's avatar
John Koleszar committed
222
      else
Jim Bankoski's avatar
Jim Bankoski committed
223
      *(x->activity_ptr) = 1 - (int)((a + (b >> 1)) / b);
224
225

#if OUTPUT_NORM_ACT_STATS
John Koleszar's avatar
John Koleszar committed
226
      fprintf(f, " %6d", *(x->mb_activity_ptr));
227
#endif
John Koleszar's avatar
John Koleszar committed
228
229
230
      // Increment activity map pointers
      x->mb_activity_ptr++;
    }
231
232

#if OUTPUT_NORM_ACT_STATS
John Koleszar's avatar
John Koleszar committed
233
    fprintf(f, "\n");
234
235
#endif

John Koleszar's avatar
John Koleszar committed
236
  }
237
238

#if OUTPUT_NORM_ACT_STATS
John Koleszar's avatar
John Koleszar committed
239
  fclose(f);
240
241
242
#endif

}
243
#endif
244
245
246

// Loop through all MBs. Note activity of each, average activity and
// calculate a normalized activity for each
247
static void build_activity_map(VP9_COMP *cpi) {
Jim Bankoski's avatar
Jim Bankoski committed
248
  MACROBLOCK * const x = &cpi->mb;
John Koleszar's avatar
John Koleszar committed
249
  MACROBLOCKD *xd = &x->e_mbd;
Jim Bankoski's avatar
Jim Bankoski committed
250
  VP9_COMMON * const cm = &cpi->common;
251

252
#if ALT_ACT_MEASURE
John Koleszar's avatar
John Koleszar committed
253
254
255
  YV12_BUFFER_CONFIG *new_yv12 = &cm->yv12_fb[cm->new_fb_idx];
  int recon_yoffset;
  int recon_y_stride = new_yv12->y_stride;
256
257
#endif

John Koleszar's avatar
John Koleszar committed
258
259
260
  int mb_row, mb_col;
  unsigned int mb_activity;
  int64_t activity_sum = 0;
261

262
263
  x->mb_activity_ptr = cpi->mb_activity_map;

John Koleszar's avatar
John Koleszar committed
264
265
  // for each macroblock row in image
  for (mb_row = 0; mb_row < cm->mb_rows; mb_row++) {
266
#if ALT_ACT_MEASURE
John Koleszar's avatar
John Koleszar committed
267
268
269
    // reset above block coeffs
    xd->up_available = (mb_row != 0);
    recon_yoffset = (mb_row * recon_y_stride * 16);
270
#endif
John Koleszar's avatar
John Koleszar committed
271
272
    // for each macroblock col in image
    for (mb_col = 0; mb_col < cm->mb_cols; mb_col++) {
273
#if ALT_ACT_MEASURE
274
      xd->plane[0].dst.buf = new_yv12->y_buffer + recon_yoffset;
John Koleszar's avatar
John Koleszar committed
275
276
      xd->left_available = (mb_col != 0);
      recon_yoffset += 16;
277
#endif
278

John Koleszar's avatar
John Koleszar committed
279
280
      // measure activity
      mb_activity = mb_activity_measure(cpi, x, mb_row, mb_col);
281

John Koleszar's avatar
John Koleszar committed
282
283
      // Keep frame sum
      activity_sum += mb_activity;
284

John Koleszar's avatar
John Koleszar committed
285
286
      // Store MB level activity details.
      *x->mb_activity_ptr = mb_activity;
287

John Koleszar's avatar
John Koleszar committed
288
289
      // Increment activity map pointer
      x->mb_activity_ptr++;
290

John Koleszar's avatar
John Koleszar committed
291
      // adjust to the next column of source macroblocks
John Koleszar's avatar
John Koleszar committed
292
      x->plane[0].src.buf += 16;
John Koleszar's avatar
John Koleszar committed
293
    }
294

John Koleszar's avatar
John Koleszar committed
295
    // adjust to the next row of mbs
John Koleszar's avatar
John Koleszar committed
296
    x->plane[0].src.buf += 16 * x->plane[0].src.stride - 16 * cm->mb_cols;
John Koleszar's avatar
John Koleszar committed
297
  }
298

John Koleszar's avatar
John Koleszar committed
299
300
  // Calculate an "average" MB activity
  calc_av_activity(cpi, activity_sum);
301

302
#if USE_ACT_INDEX
John Koleszar's avatar
John Koleszar committed
303
304
  // Calculate an activity index number of each mb
  calc_activity_index(cpi, x);
305
306
#endif

307
308
}

309
// Macroblock activity masking
310
void vp9_activity_masking(VP9_COMP *cpi, MACROBLOCK *x) {
311
#if USE_ACT_INDEX
John Koleszar's avatar
John Koleszar committed
312
313
314
  x->rdmult += *(x->mb_activity_ptr) * (x->rdmult >> 2);
  x->errorperbit = x->rdmult * 100 / (110 * x->rddiv);
  x->errorperbit += (x->errorperbit == 0);
315
#else
John Koleszar's avatar
John Koleszar committed
316
317
318
  int64_t a;
  int64_t b;
  int64_t act = *(x->mb_activity_ptr);
319

John Koleszar's avatar
John Koleszar committed
320
321
322
  // Apply the masking to the RD multiplier.
  a = act + (2 * cpi->activity_avg);
  b = (2 * act) + cpi->activity_avg;
323

Jim Bankoski's avatar
Jim Bankoski committed
324
  x->rdmult = (unsigned int) (((int64_t) x->rdmult * b + (a >> 1)) / a);
John Koleszar's avatar
John Koleszar committed
325
326
  x->errorperbit = x->rdmult * 100 / (110 * x->rddiv);
  x->errorperbit += (x->errorperbit == 0);
327
#endif
328

John Koleszar's avatar
John Koleszar committed
329
330
  // Activity based Zbin adjustment
  adjust_act_zbin(cpi, x);
331
}
John Koleszar's avatar
John Koleszar committed
332

Jim Bankoski's avatar
Jim Bankoski committed
333
334
static void update_state(VP9_COMP *cpi, PICK_MODE_CONTEXT *ctx,
                         BLOCK_SIZE_TYPE bsize, int output_enabled) {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
335
  int i, x_idx, y;
Jim Bankoski's avatar
Jim Bankoski committed
336
337
  MACROBLOCK * const x = &cpi->mb;
  MACROBLOCKD * const xd = &x->e_mbd;
John Koleszar's avatar
John Koleszar committed
338
  MODE_INFO *mi = &ctx->mic;
Jim Bankoski's avatar
Jim Bankoski committed
339
  MB_MODE_INFO * const mbmi = &xd->mode_info_context->mbmi;
340

John Koleszar's avatar
John Koleszar committed
341
  int mb_mode_index = ctx->best_mode_index;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
342
  const int mis = cpi->common.mode_info_stride;
Jim Bankoski's avatar
Jim Bankoski committed
343
344
  const int mi_height = num_8x8_blocks_high_lookup[bsize];
  const int mi_width = num_8x8_blocks_wide_lookup[bsize];
Adrian Grange's avatar
Adrian Grange committed
345

346
  assert(mi->mbmi.mode < MB_MODE_COUNT);
John Koleszar's avatar
John Koleszar committed
347
  assert(mb_mode_index < MAX_MODES);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
348
349
  assert(mi->mbmi.ref_frame[0] < MAX_REF_FRAMES);
  assert(mi->mbmi.ref_frame[1] < MAX_REF_FRAMES);
350
  assert(mi->mbmi.sb_type == bsize);
351

John Koleszar's avatar
John Koleszar committed
352
353
  // Restore the coding context of the MB to that that was in place
  // when the mode was picked for it
Jim Bankoski's avatar
Jim Bankoski committed
354
355
356
357
  for (y = 0; y < mi_height; y++) {
    for (x_idx = 0; x_idx < mi_width; x_idx++) {
      if ((xd->mb_to_right_edge >> (3 + LOG2_MI_SIZE)) + mi_width > x_idx
          && (xd->mb_to_bottom_edge >> (3 + LOG2_MI_SIZE)) + mi_height > y) {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
358
        MODE_INFO *mi_addr = xd->mode_info_context + x_idx + y * mis;
359
        *mi_addr = *mi;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
360
      }
Ronald S. Bultje's avatar
Ronald S. Bultje committed
361
    }
Ronald S. Bultje's avatar
Ronald S. Bultje committed
362
  }
363
364
  // FIXME(rbultje) I'm pretty sure this should go to the end of this block
  // (i.e. after the output_enabled)
365
  if (bsize < BLOCK_SIZE_SB32X32) {
366
367
    if (bsize < BLOCK_SIZE_MB16X16)
      ctx->txfm_rd_diff[ALLOW_16X16] = ctx->txfm_rd_diff[ALLOW_8X8];
368
    ctx->txfm_rd_diff[ALLOW_32X32] = ctx->txfm_rd_diff[ALLOW_16X16];
Ronald S. Bultje's avatar
Ronald S. Bultje committed
369
  }
Adrian Grange's avatar
Adrian Grange committed
370

Ronald S. Bultje's avatar
Ronald S. Bultje committed
371
  if (mbmi->ref_frame[0] != INTRA_FRAME && mbmi->sb_type < BLOCK_SIZE_SB8X8) {
372
    *x->partition_info = ctx->partition_info;
373
374
    mbmi->mv[0].as_int = mi->bmi[3].as_mv[0].as_int;
    mbmi->mv[1].as_int = mi->bmi[3].as_mv[1].as_int;
John Koleszar's avatar
John Koleszar committed
375
376
  }

377
  x->skip = ctx->skip;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
378
379
380
  if (!output_enabled)
    return;

381
  if (!vp9_segfeature_active(&xd->seg, mbmi->segment_id, SEG_LVL_SKIP)) {
382
    for (i = 0; i < TX_MODES; i++)
Ronald S. Bultje's avatar
Ronald S. Bultje committed
383
      cpi->rd_tx_select_diff[i] += ctx->txfm_rd_diff[i];
384
385
  }

John Koleszar's avatar
John Koleszar committed
386
387
  if (cpi->common.frame_type == KEY_FRAME) {
    // Restore the coding modes to that held in the coding context
Yaowu Xu's avatar
Yaowu Xu committed
388
    // if (mb_mode == I4X4_PRED)
John Koleszar's avatar
John Koleszar committed
389
390
391
392
393
394
    //    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);
    //    }
395
#if CONFIG_INTERNAL_STATS
John Koleszar's avatar
John Koleszar committed
396
397
398
399
400
401
402
403
404
405
406
    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*/,
Yaowu Xu's avatar
Yaowu Xu committed
407
      THR_B_PRED /*I4X4_PRED*/,
John Koleszar's avatar
John Koleszar committed
408
    };
409
    cpi->mode_chosen_counts[kf_mode_index[mi->mbmi.mode]]++;
410
#endif
John Koleszar's avatar
John Koleszar committed
411
412
413
  } else {
    // Note how often each mode chosen as best
    cpi->mode_chosen_counts[mb_mode_index]++;
Jim Bankoski's avatar
Jim Bankoski committed
414
415
    if (mbmi->ref_frame[0] != INTRA_FRAME
        && (mbmi->sb_type < BLOCK_SIZE_SB8X8 || mbmi->mode == NEWMV)) {
Deb Mukherjee's avatar
Deb Mukherjee committed
416
      int_mv best_mv, best_second_mv;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
417
418
      const MV_REFERENCE_FRAME rf1 = mbmi->ref_frame[0];
      const MV_REFERENCE_FRAME rf2 = mbmi->ref_frame[1];
Deb Mukherjee's avatar
Deb Mukherjee committed
419
420
421
      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) {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
422
423
        best_mv.as_int = mbmi->ref_mvs[rf1][0].as_int;
        best_second_mv.as_int = mbmi->ref_mvs[rf2][0].as_int;
Deb Mukherjee's avatar
Deb Mukherjee committed
424
425
426
427
      }
      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);
428
    }
Jingning Han's avatar
Jingning Han committed
429

430
431
    if (bsize > BLOCK_SIZE_SB8X8 && mbmi->mode == NEWMV) {
      int i, j;
Jim Bankoski's avatar
Jim Bankoski committed
432
433
434
435
      for (j = 0; j < mi_height; ++j)
        for (i = 0; i < mi_width; ++i)
          if ((xd->mb_to_right_edge >> (3 + LOG2_MI_SIZE)) + mi_width > i
              && (xd->mb_to_bottom_edge >> (3 + LOG2_MI_SIZE)) + mi_height > j)
436
            xd->mode_info_context[mis * j + i].mbmi = *mbmi;
Deb Mukherjee's avatar
Deb Mukherjee committed
437
    }
438

Jim Bankoski's avatar
Jim Bankoski committed
439
440
    if (cpi->common.mcomp_filter_type == SWITCHABLE
        && is_inter_mode(mbmi->mode)) {
441
      ++cpi->common.counts.switchable_interp[
442
          vp9_get_pred_context_switchable_interp(xd)]
443
            [vp9_switchable_interp_map[mbmi->interp_filter]];
444
    }
Adrian Grange's avatar
Adrian Grange committed
445

446
    cpi->rd_comp_pred_diff[SINGLE_PREDICTION_ONLY] += ctx->single_pred_diff;
Jim Bankoski's avatar
Jim Bankoski committed
447
448
    cpi->rd_comp_pred_diff[COMP_PREDICTION_ONLY] += ctx->comp_pred_diff;
    cpi->rd_comp_pred_diff[HYBRID_PREDICTION] += ctx->hybrid_pred_diff;
449
450
451
452

    for (i = 0; i <= VP9_SWITCHABLE_FILTERS; i++) {
      cpi->rd_filter_diff[i] += ctx->best_filter_diff[i];
    }
John Koleszar's avatar
John Koleszar committed
453
  }
Adrian Grange's avatar
Adrian Grange committed
454
455
}

Jim Bankoski's avatar
Jim Bankoski committed
456
void vp9_setup_src_planes(MACROBLOCK *x, const YV12_BUFFER_CONFIG *src,
John Koleszar's avatar
John Koleszar committed
457
                          int mb_row, int mb_col) {
Jim Bankoski's avatar
Jim Bankoski committed
458
459
460
461
  uint8_t *buffers[4] = {src->y_buffer, src->u_buffer, src->v_buffer, src
      ->alpha_buffer};
  int strides[4] = {src->y_stride, src->uv_stride, src->uv_stride, src
      ->alpha_stride};
462
463
464
  int i;

  for (i = 0; i < MAX_MB_PLANE; i++) {
Jim Bankoski's avatar
Jim Bankoski committed
465
466
    setup_pred_plane(&x->plane[i].src, buffers[i], strides[i], mb_row, mb_col,
                     NULL, x->e_mbd.plane[i].subsampling_x,
467
468
                     x->e_mbd.plane[i].subsampling_y);
  }
John Koleszar's avatar
John Koleszar committed
469
470
}

Jim Bankoski's avatar
Jim Bankoski committed
471
472
473
474
475
static void set_offsets(VP9_COMP *cpi, int mi_row, int mi_col,
                        BLOCK_SIZE_TYPE bsize) {
  MACROBLOCK * const x = &cpi->mb;
  VP9_COMMON * const cm = &cpi->common;
  MACROBLOCKD * const xd = &x->e_mbd;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
476
477
  MB_MODE_INFO *mbmi;
  const int dst_fb_idx = cm->new_fb_idx;
478
  const int idx_str = xd->mode_info_stride * mi_row + mi_col;
Jim Bankoski's avatar
Jim Bankoski committed
479
480
  const int mi_width = num_8x8_blocks_wide_lookup[bsize];
  const int mi_height = num_8x8_blocks_high_lookup[bsize];
Jingning Han's avatar
Jingning Han committed
481
482
  const int mb_row = mi_row >> 1;
  const int mb_col = mi_col >> 1;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
483
  const int idx_map = mb_row * cm->mb_cols + mb_col;
484
  const struct segmentation *const seg = &xd->seg;
485
  int i;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
486
487

  // entropy context structures
488
  for (i = 0; i < MAX_MB_PLANE; i++) {
Jim Bankoski's avatar
Jim Bankoski committed
489
490
491
492
    xd->plane[i].above_context = cm->above_context[i]
        + (mi_col * 2 >> xd->plane[i].subsampling_x);
    xd->plane[i].left_context = cm->left_context[i]
        + (((mi_row * 2) & 15) >> xd->plane[i].subsampling_y);
493
  }
Ronald S. Bultje's avatar
Ronald S. Bultje committed
494

495
  // partition contexts
496
  set_partition_seg_context(cm, xd, mi_row, mi_col);
497

Ronald S. Bultje's avatar
Ronald S. Bultje committed
498
499
500
501
502
  // Activity map pointer
  x->mb_activity_ptr = &cpi->mb_activity_map[idx_map];
  x->active_ptr = cpi->active_map + idx_map;

  /* pointers to mode info contexts */
Jim Bankoski's avatar
Jim Bankoski committed
503
504
  x->partition_info = x->pi + idx_str;
  xd->mode_info_context = cm->mi + idx_str;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
505
  mbmi = &xd->mode_info_context->mbmi;
506
507
  // Special case: if prev_mi is NULL, the previous mode info context
  // cannot be used.
Jim Bankoski's avatar
Jim Bankoski committed
508
  xd->prev_mode_info_context = cm->prev_mi ? cm->prev_mi + idx_str : NULL;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
509
510

  // Set up destination pointers
511
  setup_dst_planes(xd, &cm->yv12_fb[dst_fb_idx], mi_row, mi_col);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
512
513
514

  /* Set up limit values for MV components to prevent them from
   * extending beyond the UMV borders assuming 16x16 block size */
Jim Bankoski's avatar
Jim Bankoski committed
515
516
517
  x->mv_row_min = -((mi_row * MI_SIZE)+ VP9BORDERINPIXELS - VP9_INTERP_EXTEND);
  x->mv_col_min = -((mi_col * MI_SIZE)+ VP9BORDERINPIXELS - VP9_INTERP_EXTEND);
  x->mv_row_max = ((cm->mi_rows - mi_row) * MI_SIZE
Jim Bankoski's avatar
Jim Bankoski committed
518
      + (VP9BORDERINPIXELS - MI_SIZE * mi_height - VP9_INTERP_EXTEND));
Jim Bankoski's avatar
Jim Bankoski committed
519
  x->mv_col_max = ((cm->mi_cols - mi_col) * MI_SIZE
Jim Bankoski's avatar
Jim Bankoski committed
520
      + (VP9BORDERINPIXELS - MI_SIZE * mi_width - VP9_INTERP_EXTEND));
Ronald S. Bultje's avatar
Ronald S. Bultje committed
521
522

  // Set up distance of MB to edge of frame in 1/8th pel units
Jim Bankoski's avatar
Jim Bankoski committed
523
524
  assert(!(mi_col & (mi_width - 1)) && !(mi_row & (mi_height - 1)));
  set_mi_row_col(cm, xd, mi_row, mi_height, mi_col, mi_width);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
525
526

  /* set up source buffers */
527
  vp9_setup_src_planes(x, cpi->Source, mi_row, mi_col);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
528
529
530
531
532
533

  /* R/D setup */
  x->rddiv = cpi->RDDIV;
  x->rdmult = cpi->RDMULT;

  /* segment ID */
534
535
536
  if (seg->enabled) {
    uint8_t *map = seg->update_map ? cpi->segmentation_map
                                   : cm->last_frame_seg_map;
537
    mbmi->segment_id = vp9_get_segment_id(cm, map, bsize, mi_row, mi_col);
538

Ronald S. Bultje's avatar
Ronald S. Bultje committed
539
540
    vp9_mb_init_quantizer(cpi, x);

541
542
543
    if (seg->enabled && cpi->seg0_cnt > 0
        && !vp9_segfeature_active(seg, 0, SEG_LVL_REF_FRAME)
        && vp9_segfeature_active(seg, 1, SEG_LVL_REF_FRAME)) {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
544
545
546
547
      cpi->seg0_progress = (cpi->seg0_idx << 16) / cpi->seg0_cnt;
    } else {
      const int y = mb_row & ~3;
      const int x = mb_col & ~3;
Jim Bankoski's avatar
Jim Bankoski committed
548
      const int p16 = ((mb_row & 1) << 1) + (mb_col & 1);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
549
      const int p32 = ((mb_row & 2) << 2) + ((mb_col & 2) << 1);
Jim Bankoski's avatar
Jim Bankoski committed
550
551
552
      const int tile_progress = cm->cur_tile_mi_col_start * cm->mb_rows >> 1;
      const int mb_cols = (cm->cur_tile_mi_col_end - cm->cur_tile_mi_col_start)
          >> 1;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
553

Jim Bankoski's avatar
Jim Bankoski committed
554
555
      cpi->seg0_progress = ((y * mb_cols + x * 4 + p32 + p16 + tile_progress)
          << 16) / cm->MBs;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
556
    }
557
558

    x->encode_breakout = cpi->segment_encode_breakout[mbmi->segment_id];
Ronald S. Bultje's avatar
Ronald S. Bultje committed
559
560
  } else {
    mbmi->segment_id = 0;
561
    x->encode_breakout = cpi->oxcf.encode_breakout;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
562
563
564
  }
}

565
static void pick_sb_modes(VP9_COMP *cpi, int mi_row, int mi_col,
566
                          int *totalrate, int64_t *totaldist,
567
568
                          BLOCK_SIZE_TYPE bsize, PICK_MODE_CONTEXT *ctx,
                          int64_t best_rd) {
569
570
571
  VP9_COMMON *const cm = &cpi->common;
  MACROBLOCK *const x = &cpi->mb;
  MACROBLOCKD *const xd = &x->e_mbd;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
572

573
574
  x->rd_search = 1;

575
576
577
578
  if (bsize < BLOCK_SIZE_SB8X8)
    if (xd->ab_index != 0)
      return;

579
  set_offsets(cpi, mi_row, mi_col, bsize);
580
  xd->mode_info_context->mbmi.sb_type = bsize;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
581
  if (cpi->oxcf.tuning == VP8_TUNE_SSIM)
582
    vp9_activity_masking(cpi, x);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
583

584
585
586
  // 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)
587
588
    vp9_rd_pick_intra_mode_sb(cpi, x, totalrate, totaldist, bsize, ctx,
                              best_rd);
589
  else
590
    vp9_rd_pick_inter_mode_sb(cpi, x, mi_row, mi_col, totalrate, totaldist,
591
                              bsize, ctx, best_rd);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
592
}
Adrian Grange's avatar
Adrian Grange committed
593

594
595
596
597
static void update_stats(VP9_COMP *cpi) {
  VP9_COMMON *const cm = &cpi->common;
  MACROBLOCK *const x = &cpi->mb;
  MACROBLOCKD *const xd = &x->e_mbd;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
598
  MODE_INFO *mi = xd->mode_info_context;
599
  MB_MODE_INFO *const mbmi = &mi->mbmi;
Adrian Grange's avatar
Adrian Grange committed
600

Paul Wilkins's avatar
Paul Wilkins committed
601
  if (cm->frame_type != KEY_FRAME) {
602
603
    const int seg_ref_active = vp9_segfeature_active(&xd->seg, mbmi->segment_id,
                                                     SEG_LVL_REF_FRAME);
604
605

    if (!seg_ref_active)
606
      cpi->intra_inter_count[vp9_get_pred_context_intra_inter(xd)][mbmi
Jim Bankoski's avatar
Jim Bankoski committed
607
          ->ref_frame[0] > INTRA_FRAME]++;
Adrian Grange's avatar
Adrian Grange committed
608

609
610
611
612
    // If the segment reference feature is enabled we have only a single
    // reference frame allowed for the segment so exclude it from
    // the reference frame counts used to work out probabilities.
    if ((mbmi->ref_frame[0] > INTRA_FRAME) && !seg_ref_active) {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
613
      if (cm->comp_pred_mode == HYBRID_PREDICTION)
614
615
        cpi->comp_inter_count[vp9_get_pred_context_comp_inter_inter(cm, xd)]
                              [mbmi->ref_frame[1] > INTRA_FRAME]++;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
616
617

      if (mbmi->ref_frame[1] > INTRA_FRAME) {
618
        cpi->comp_ref_count[vp9_get_pred_context_comp_ref_p(cm, xd)][mbmi
Jim Bankoski's avatar
Jim Bankoski committed
619
            ->ref_frame[0] == GOLDEN_FRAME]++;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
620
      } else {
621
        cpi->single_ref_count[vp9_get_pred_context_single_ref_p1(xd)]
622
                              [0][mbmi->ref_frame[0] != LAST_FRAME]++;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
623
        if (mbmi->ref_frame[0] != LAST_FRAME)
624
          cpi->single_ref_count[vp9_get_pred_context_single_ref_p2(xd)][1]
625
              [mbmi->ref_frame[0] != GOLDEN_FRAME]++;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
626
      }
Ronald S. Bultje's avatar
Ronald S. Bultje committed
627
    }
Ronald S. Bultje's avatar
Ronald S. Bultje committed
628
    // Count of last ref frame 0,0 usage
Ronald S. Bultje's avatar
Ronald S. Bultje committed
629
    if ((mbmi->mode == ZEROMV) && (mbmi->ref_frame[0] == LAST_FRAME))
Ronald S. Bultje's avatar
Ronald S. Bultje committed
630
631
632
      cpi->inter_zz_count++;
  }
}
John Koleszar's avatar
John Koleszar committed
633

634
635
636
// TODO(jingning): the variables used here are little complicated. need further
// refactoring on organizing the the temporary buffers, when recursive
// partition down to 4x4 block size is enabled.
637
638
static PICK_MODE_CONTEXT *get_block_context(MACROBLOCK *x,
                                            BLOCK_SIZE_TYPE bsize) {
Jim Bankoski's avatar
Jim Bankoski committed
639
  MACROBLOCKD * const xd = &x->e_mbd;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
640

641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
  switch (bsize) {
    case BLOCK_SIZE_SB64X64:
      return &x->sb64_context;
    case BLOCK_SIZE_SB64X32:
      return &x->sb64x32_context[xd->sb_index];
    case BLOCK_SIZE_SB32X64:
      return &x->sb32x64_context[xd->sb_index];
    case BLOCK_SIZE_SB32X32:
      return &x->sb32_context[xd->sb_index];
    case BLOCK_SIZE_SB32X16:
      return &x->sb32x16_context[xd->sb_index][xd->mb_index];
    case BLOCK_SIZE_SB16X32:
      return &x->sb16x32_context[xd->sb_index][xd->mb_index];
    case BLOCK_SIZE_MB16X16:
      return &x->mb_context[xd->sb_index][xd->mb_index];
656
657
658
659
660
    case BLOCK_SIZE_SB16X8:
      return &x->sb16x8_context[xd->sb_index][xd->mb_index][xd->b_index];
    case BLOCK_SIZE_SB8X16:
      return &x->sb8x16_context[xd->sb_index][xd->mb_index][xd->b_index];
    case BLOCK_SIZE_SB8X8:
661
662
663
664
665
666
667
      return &x->sb8x8_context[xd->sb_index][xd->mb_index][xd->b_index];
    case BLOCK_SIZE_SB8X4:
      return &x->sb8x4_context[xd->sb_index][xd->mb_index][xd->b_index];
    case BLOCK_SIZE_SB4X8:
      return &x->sb4x8_context[xd->sb_index][xd->mb_index][xd->b_index];
    case BLOCK_SIZE_AB4X4:
      return &x->ab4x4_context[xd->sb_index][xd->mb_index][xd->b_index];
668
669
    default:
      assert(0);
Jim Bankoski's avatar
Jim Bankoski committed
670
      return NULL ;
671
672
  }
}
Ronald S. Bultje's avatar
Ronald S. Bultje committed
673

674
675
676
677
678
679
680
681
682
683
static BLOCK_SIZE_TYPE *get_sb_partitioning(MACROBLOCK *x,
                                            BLOCK_SIZE_TYPE bsize) {
  MACROBLOCKD *xd = &x->e_mbd;
  switch (bsize) {
    case BLOCK_SIZE_SB64X64:
      return &x->sb64_partitioning;
    case BLOCK_SIZE_SB32X32:
      return &x->sb_partitioning[xd->sb_index];
    case BLOCK_SIZE_MB16X16:
      return &x->mb_partitioning[xd->sb_index][xd->mb_index];
684
685
    case BLOCK_SIZE_SB8X8:
      return &x->b_partitioning[xd->sb_index][xd->mb_index][xd->b_index];
686
687
    default:
      assert(0);
Jim Bankoski's avatar
Jim Bankoski committed
688
      return NULL ;
689
690
691
692
693
694
  }
}

static void restore_context(VP9_COMP *cpi, int mi_row, int mi_col,
                            ENTROPY_CONTEXT a[16 * MAX_MB_PLANE],
                            ENTROPY_CONTEXT l[16 * MAX_MB_PLANE],
Jim Bankoski's avatar
Jim Bankoski committed
695
                            PARTITION_CONTEXT sa[8], PARTITION_CONTEXT sl[8],
696
                            BLOCK_SIZE_TYPE bsize) {
Jim Bankoski's avatar
Jim Bankoski committed
697
698
699
  VP9_COMMON * const cm = &cpi->common;
  MACROBLOCK * const x = &cpi->mb;
  MACROBLOCKD * const xd = &x->e_mbd;
700
  int p;
Jim Bankoski's avatar
Jim Bankoski committed
701
702
703
704
  int num_4x4_blocks_wide = num_4x4_blocks_wide_lookup[bsize];
  int num_4x4_blocks_high = num_4x4_blocks_high_lookup[bsize];
  int mi_width = num_8x8_blocks_wide_lookup[bsize];
  int mi_height = num_8x8_blocks_high_lookup[bsize];
705
  for (p = 0; p < MAX_MB_PLANE; p++) {
Jim Bankoski's avatar
Jim Bankoski committed
706
707
    vpx_memcpy(
        cm->above_context[p] + ((mi_col * 2) >> xd->plane[p].subsampling_x),
Jim Bankoski's avatar
Jim Bankoski committed
708
709
710
        a + num_4x4_blocks_wide * p,
        (sizeof(ENTROPY_CONTEXT) * num_4x4_blocks_wide) >>
        xd->plane[p].subsampling_x);
Jim Bankoski's avatar
Jim Bankoski committed
711
712
    vpx_memcpy(
        cm->left_context[p]
Jim Bankoski's avatar
Jim Bankoski committed
713
714
715
716
717
            + ((mi_row & MI_MASK) * 2 >> xd->plane[p].subsampling_y),
        l + num_4x4_blocks_high * p,
        (sizeof(ENTROPY_CONTEXT) * num_4x4_blocks_high) >>
        xd->plane[p].subsampling_y);
  }
718
  vpx_memcpy(cm->above_seg_context + mi_col, sa,
Jim Bankoski's avatar
Jim Bankoski committed
719
             sizeof(PARTITION_CONTEXT) * mi_width);
720
  vpx_memcpy(cm->left_seg_context + (mi_row & MI_MASK), sl,
Jim Bankoski's avatar
Jim Bankoski committed
721
             sizeof(PARTITION_CONTEXT) * mi_height);
722
}
Jim Bankoski's avatar
Jim Bankoski committed
723
static void save_context(VP9_COMP *cpi, int mi_row, int mi_col,
Jim Bankoski's avatar
Jim Bankoski committed
724
725
726
727
728
729
730
                         ENTROPY_CONTEXT a[16 * MAX_MB_PLANE],
                         ENTROPY_CONTEXT l[16 * MAX_MB_PLANE],
                         PARTITION_CONTEXT sa[8], PARTITION_CONTEXT sl[8],
                         BLOCK_SIZE_TYPE bsize) {
  VP9_COMMON * const cm = &cpi->common;
  MACROBLOCK * const x = &cpi->mb;
  MACROBLOCKD * const xd = &x->e_mbd;
Jim Bankoski's avatar
Jim Bankoski committed
731
  int p;
Jim Bankoski's avatar
Jim Bankoski committed
732
733
734
735
  int num_4x4_blocks_wide = num_4x4_blocks_wide_lookup[bsize];
  int num_4x4_blocks_high = num_4x4_blocks_high_lookup[bsize];
  int mi_width = num_8x8_blocks_wide_lookup[bsize];
  int mi_height = num_8x8_blocks_high_lookup[bsize];
Jim Bankoski's avatar
Jim Bankoski committed
736
737
738

  // buffer the above/left context information of the block in search.
  for (p = 0; p < MAX_MB_PLANE; ++p) {
Jim Bankoski's avatar
Jim Bankoski committed
739
    vpx_memcpy(
Jim Bankoski's avatar
Jim Bankoski committed
740
        a + num_4x4_blocks_wide * p,
Jim Bankoski's avatar
Jim Bankoski committed
741
        cm->above_context[p] + (mi_col * 2 >> xd->plane[p].subsampling_x),
Jim Bankoski's avatar
Jim Bankoski committed
742
743
        (sizeof(ENTROPY_CONTEXT) * num_4x4_blocks_wide) >>
        xd->plane[p].subsampling_x);
Jim Bankoski's avatar
Jim Bankoski committed
744
    vpx_memcpy(
Jim Bankoski's avatar
Jim Bankoski committed
745
        l + num_4x4_blocks_high * p,
Jim Bankoski's avatar
Jim Bankoski committed
746
        cm->left_context[p]
Jim Bankoski's avatar
Jim Bankoski committed
747
748
749
750
            + ((mi_row & MI_MASK) * 2 >> xd->plane[p].subsampling_y),
        (sizeof(ENTROPY_CONTEXT) * num_4x4_blocks_high) >>
        xd->plane[p].subsampling_y);
  }
Jim Bankoski's avatar
Jim Bankoski committed
751
  vpx_memcpy(sa, cm->above_seg_context + mi_col,
Jim Bankoski's avatar
Jim Bankoski committed
752
             sizeof(PARTITION_CONTEXT) * mi_width);
Jim Bankoski's avatar
Jim Bankoski committed
753
  vpx_memcpy(sl, cm->left_seg_context + (mi_row & MI_MASK),
Jim Bankoski's avatar
Jim Bankoski committed
754
755
             sizeof(PARTITION_CONTEXT) * mi_height);
}
756

Jim Bankoski's avatar
Jim Bankoski committed
757
758
759
760
761
static void encode_b(VP9_COMP *cpi, TOKENEXTRA **tp, int mi_row, int mi_col,
                     int output_enabled, BLOCK_SIZE_TYPE bsize, int sub_index) {
  VP9_COMMON * const cm = &cpi->common;
  MACROBLOCK * const x = &cpi->mb;
  MACROBLOCKD * const xd = &x->e_mbd;
John Koleszar's avatar
John Koleszar committed
762

763
764
  if (mi_row >= cm->mi_rows || mi_col >= cm->mi_cols)
    return;
John Koleszar's avatar
John Koleszar committed
765

766
  if (sub_index != -1)
767
    *(get_sb_index(xd, bsize)) = sub_index;
768
769
770
771

  if (bsize < BLOCK_SIZE_SB8X8)
    if (xd->ab_index > 0)
      return;
772
773
  set_offsets(cpi, mi_row, mi_col, bsize);
  update_state(cpi, get_block_context(x, bsize), bsize, output_enabled);
Jingning Han's avatar
Jingning Han committed
774
  encode_superblock(cpi, tp, output_enabled, mi_row, mi_col, bsize);
John Koleszar's avatar
John Koleszar committed
775

776
  if (output_enabled) {
777
    update_stats(cpi);
778

779
780
    (*tp)->token = EOSB_TOKEN;
    (*tp)++;
John Koleszar's avatar
John Koleszar committed
781
  }
Ronald S. Bultje's avatar
Ronald S. Bultje committed
782
783
}

Jim Bankoski's avatar
Jim Bankoski committed
784
785
786
787
788
static void encode_sb(VP9_COMP *cpi, TOKENEXTRA **tp, int mi_row, int mi_col,
                      int output_enabled, BLOCK_SIZE_TYPE bsize) {
  VP9_COMMON * const cm = &cpi->common;
  MACROBLOCK * const x = &cpi->mb;
  MACROBLOCKD * const xd = &x->e_mbd;
789
  BLOCK_SIZE_TYPE c1 = BLOCK_SIZE_SB8X8;
790
  const int bsl = b_width_log2(bsize), bs = (1 << bsl) / 4;
791
  int UNINITIALIZED_IS_SAFE(pl);
Jim Bankoski's avatar
Jim Bankoski committed
792
793
794
  PARTITION_TYPE partition;
  BLOCK_SIZE_TYPE subsize;
  int i;
795

796
797
  if (mi_row >= cm->mi_rows || mi_col >= cm->mi_cols)
    return;
798

799
  c1 = BLOCK_SIZE_AB4X4;
800
  if (bsize >= BLOCK_SIZE_SB8X8) {
801
    set_partition_seg_context(cm, xd, mi_row, mi_col);
802
803
    pl = partition_plane_context(xd, bsize);
    c1 = *(get_sb_partitioning(x, bsize));
804
  }
Jim Bankoski's avatar
Jim Bankoski committed
805
  partition = partition_lookup[bsl][c1];
Ronald S. Bultje's avatar
Ronald S. Bultje committed
806

Jim Bankoski's avatar
Jim Bankoski committed
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
  switch (partition) {
    case PARTITION_NONE:
      if (output_enabled && bsize >= BLOCK_SIZE_SB8X8)
        cpi->partition_count[pl][PARTITION_NONE]++;
      encode_b(cpi, tp, mi_row, mi_col, output_enabled, c1, -1);
      break;
    case PARTITION_VERT:
      if (output_enabled)
        cpi->partition_count[pl][PARTITION_VERT]++;
      encode_b(cpi, tp, mi_row, mi_col, output_enabled, c1, 0);
      encode_b(cpi, tp, mi_row, mi_col + bs, output_enabled, c1, 1);
      break;
    case PARTITION_HORZ:
      if (output_enabled)
        cpi->partition_count[pl][PARTITION_HORZ]++;
      encode_b(cpi, tp, mi_row, mi_col, output_enabled, c1, 0);
      encode_b(cpi, tp, mi_row + bs, mi_col, output_enabled, c1, 1);
      break;
    case PARTITION_SPLIT:
      subsize = get_subsize(bsize, PARTITION_SPLIT);
827

Jim Bankoski's avatar
Jim Bankoski committed
828
829
      if (output_enabled)
        cpi->partition_count[pl][PARTITION_SPLIT]++;
830

Jim Bankoski's avatar
Jim Bankoski committed
831
832
      for (i = 0; i < 4; i++) {
        const int x_idx = i & 1, y_idx = i >> 1;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
833