vp9_encodeframe.c 90.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
#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
  int i;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
485
486

  // entropy context structures
487
  for (i = 0; i < MAX_MB_PLANE; i++) {
Jim Bankoski's avatar
Jim Bankoski committed
488
489
490
491
    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);
492
  }
Ronald S. Bultje's avatar
Ronald S. Bultje committed
493

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

Ronald S. Bultje's avatar
Ronald S. Bultje committed
497
498
499
500
501
  // 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
502
503
  x->partition_info = x->pi + idx_str;
  xd->mode_info_context = cm->mi + idx_str;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
504
  mbmi = &xd->mode_info_context->mbmi;
505
506
  // Special case: if prev_mi is NULL, the previous mode info context
  // cannot be used.
Jim Bankoski's avatar
Jim Bankoski committed
507
  xd->prev_mode_info_context = cm->prev_mi ? cm->prev_mi + idx_str : NULL;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
508
509

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

  /* 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
514
515
516
  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
517
      + (VP9BORDERINPIXELS - MI_SIZE * mi_height - VP9_INTERP_EXTEND));
Jim Bankoski's avatar
Jim Bankoski committed
518
  x->mv_col_max = ((cm->mi_cols - mi_col) * MI_SIZE
Jim Bankoski's avatar
Jim Bankoski committed
519
      + (VP9BORDERINPIXELS - MI_SIZE * mi_width - VP9_INTERP_EXTEND));
Ronald S. Bultje's avatar
Ronald S. Bultje committed
520
521

  // Set up distance of MB to edge of frame in 1/8th pel units
Jim Bankoski's avatar
Jim Bankoski committed
522
523
  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
524
525

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

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

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

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

540
541
542
    if (xd->seg.enabled && cpi->seg0_cnt > 0
        && !vp9_segfeature_active(&xd->seg, 0, SEG_LVL_REF_FRAME)
        && vp9_segfeature_active(&xd->seg, 1, SEG_LVL_REF_FRAME)) {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
543
544
545
546
      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
547
      const int p16 = ((mb_row & 1) << 1) + (mb_col & 1);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
548
      const int p32 = ((mb_row & 2) << 2) + ((mb_col & 2) << 1);
Jim Bankoski's avatar
Jim Bankoski committed
549
550
551
      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
552

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

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

564
static void pick_sb_modes(VP9_COMP *cpi, int mi_row, int mi_col,
565
                          int *totalrate, int64_t *totaldist,
566
567
                          BLOCK_SIZE_TYPE bsize, PICK_MODE_CONTEXT *ctx,
                          int64_t best_rd) {
568
569
570
  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
571

572
573
  x->rd_search = 1;

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

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

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

593
594
595
596
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
597
  MODE_INFO *mi = xd->mode_info_context;
598
  MB_MODE_INFO *const mbmi = &mi->mbmi;
Adrian Grange's avatar
Adrian Grange committed
599

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

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

608
609
610
611
    // 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
612
      if (cm->comp_pred_mode == HYBRID_PREDICTION)
613
614
        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
615
616

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

633
634
635
// 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.
636
637
static PICK_MODE_CONTEXT *get_block_context(MACROBLOCK *x,
                                            BLOCK_SIZE_TYPE bsize) {
Jim Bankoski's avatar
Jim Bankoski committed
638
  MACROBLOCKD * const xd = &x->e_mbd;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
639

640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
  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];
655
656
657
658
659
    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:
660
661
662
663
664
665
666
      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];
667
668
    default:
      assert(0);
Jim Bankoski's avatar
Jim Bankoski committed
669
      return NULL ;
670
671
  }
}
Ronald S. Bultje's avatar
Ronald S. Bultje committed
672

673
674
675
676
677
678
679
680
681
682
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];
683
684
    case BLOCK_SIZE_SB8X8:
      return &x->b_partitioning[xd->sb_index][xd->mb_index][xd->b_index];
685
686
    default:
      assert(0);
Jim Bankoski's avatar
Jim Bankoski committed
687
      return NULL ;
688
689
690
691
692
693
  }
}

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

  // 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
738
    vpx_memcpy(
Jim Bankoski's avatar
Jim Bankoski committed
739
        a + num_4x4_blocks_wide * p,
Jim Bankoski's avatar
Jim Bankoski committed
740
        cm->above_context[p] + (mi_col * 2 >> xd->plane[p].subsampling_x),
Jim Bankoski's avatar
Jim Bankoski committed
741
742
        (sizeof(ENTROPY_CONTEXT) * num_4x4_blocks_wide) >>
        xd->plane[p].subsampling_x);
Jim Bankoski's avatar
Jim Bankoski committed
743
    vpx_memcpy(
Jim Bankoski's avatar
Jim Bankoski committed
744
        l + num_4x4_blocks_high * p,
Jim Bankoski's avatar
Jim Bankoski committed
745
        cm->left_context[p]
Jim Bankoski's avatar
Jim Bankoski committed
746
747
748
749
            + ((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
750
  vpx_memcpy(sa, cm->above_seg_context + mi_col,
Jim Bankoski's avatar
Jim Bankoski committed
751
             sizeof(PARTITION_CONTEXT) * mi_width);
Jim Bankoski's avatar
Jim Bankoski committed
752
  vpx_memcpy(sl, cm->left_seg_context + (mi_row & MI_MASK),
Jim Bankoski's avatar
Jim Bankoski committed
753
754
             sizeof(PARTITION_CONTEXT) * mi_height);
}
755

Jim Bankoski's avatar
Jim Bankoski committed
756
757
758
759
760
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
761

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

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

  if (bsize < BLOCK_SIZE_SB8X8)
    if (xd->ab_index > 0)
      return;
771
772
  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
773
  encode_superblock(cpi, tp, output_enabled, mi_row, mi_col, bsize);
John Koleszar's avatar
John Koleszar committed
774

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

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

Jim Bankoski's avatar
Jim Bankoski committed
783
784
785
786
787
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;
788
  BLOCK_SIZE_TYPE c1 = BLOCK_SIZE_SB8X8;
789
  const int bsl = b_width_log2(bsize), bs = (1 << bsl) / 4;
790
  int UNINITIALIZED_IS_SAFE(pl);
Jim Bankoski's avatar
Jim Bankoski committed
791
792
793
  PARTITION_TYPE partition;
  BLOCK_SIZE_TYPE subsize;
  int i;
794

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

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

Jim Bankoski's avatar
Jim Bankoski committed
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
  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);
826

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

Jim Bankoski's avatar
Jim Bankoski committed
830
831
      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
832