encodeframe.c 72.9 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
13
14
 */


#include "vpx_ports/config.h"
#include "encodemb.h"
#include "encodemv.h"
John Koleszar's avatar
John Koleszar committed
15
#include "vp8/common/common.h"
John Koleszar's avatar
John Koleszar committed
16
#include "onyx_int.h"
John Koleszar's avatar
John Koleszar committed
17
18
19
#include "vp8/common/extend.h"
#include "vp8/common/entropymode.h"
#include "vp8/common/quant_common.h"
20
#include "segmentation.h"
John Koleszar's avatar
John Koleszar committed
21
#include "vp8/common/setupintrarecon.h"
John Koleszar's avatar
John Koleszar committed
22
#include "encodeintra.h"
John Koleszar's avatar
John Koleszar committed
23
#include "vp8/common/reconinter.h"
Ronald S. Bultje's avatar
Ronald S. Bultje committed
24
#include "vp8/common/invtrans.h"
John Koleszar's avatar
John Koleszar committed
25
#include "rdopt.h"
John Koleszar's avatar
John Koleszar committed
26
27
#include "vp8/common/findnearmv.h"
#include "vp8/common/reconintra.h"
Christian Duvivier's avatar
Christian Duvivier committed
28
#include "vp8/common/seg_common.h"
John Koleszar's avatar
John Koleszar committed
29
#include <stdio.h>
30
#include <math.h>
John Koleszar's avatar
John Koleszar committed
31
#include <limits.h>
John Koleszar's avatar
John Koleszar committed
32
#include "vp8/common/subpixel.h"
John Koleszar's avatar
John Koleszar committed
33
#include "vpx_ports/vpx_timer.h"
34
#include "vp8/common/pred_common.h"
John Koleszar's avatar
John Koleszar committed
35

36
#define DBG_PRNT_SEGMAP 0
Paul Wilkins's avatar
Paul Wilkins committed
37
38
39
40
#if CONFIG_NEW_MVREF
#include "vp8/common/mvref_common.h"
#endif

41

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

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

Paul Wilkins's avatar
Paul Wilkins committed
55
extern void vp8_stuff_mb(VP8_COMP *cpi, MACROBLOCKD *xd,
56
                         TOKENEXTRA **t, int dry_run);
John Koleszar's avatar
John Koleszar committed
57
58
59
60
61
62
63
64

extern void vp8cx_initialize_me_consts(VP8_COMP *cpi, int QIndex);
extern void vp8_auto_select_speed(VP8_COMP *cpi);
extern void vp8cx_init_mbrthread_data(VP8_COMP *cpi,
                                      MACROBLOCK *x,
                                      MB_ROW_COMP *mbr_ei,
                                      int mb_row,
                                      int count);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
65
66
67
68
int64_t vp8_rd_pick_inter_mode_sb(VP8_COMP *cpi, MACROBLOCK *x,
                              int recon_yoffset, int recon_uvoffset,
                              int *returnrate, int *returndistortion);
extern void vp8cx_pick_mode_inter_macroblock(VP8_COMP *cpi, MACROBLOCK *x,
Adrian Grange's avatar
Adrian Grange committed
69
                                            int recon_yoffset,
Ronald S. Bultje's avatar
Ronald S. Bultje committed
70
                                            int recon_uvoffset, int *r, int *d);
John Koleszar's avatar
John Koleszar committed
71
72
void vp8_build_block_offsets(MACROBLOCK *x);
void vp8_setup_block_ptrs(MACROBLOCK *x);
Adrian Grange's avatar
Adrian Grange committed
73
74
75
void vp8cx_encode_inter_macroblock(VP8_COMP *cpi, MACROBLOCK *x, TOKENEXTRA **t,
                                   int recon_yoffset, int recon_uvoffset,
                                   int output_enabled);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
76
77
void vp8cx_encode_inter_superblock(VP8_COMP *cpi, MACROBLOCK *x, TOKENEXTRA **t,
                                   int recon_yoffset, int recon_uvoffset, int mb_col, int mb_row);
Adrian Grange's avatar
Adrian Grange committed
78
79
void vp8cx_encode_intra_macro_block(VP8_COMP *cpi, MACROBLOCK *x,
                                    TOKENEXTRA **t, int output_enabled);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
80
81
82
void vp8cx_encode_intra_super_block(VP8_COMP *cpi,
                                    MACROBLOCK *x,
                                    TOKENEXTRA **t, int mb_col);
John Koleszar's avatar
John Koleszar committed
83
static void adjust_act_zbin(VP8_COMP *cpi, MACROBLOCK *x);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
84
85
extern void vp8_stuff_mb_8x8(VP8_COMP *cpi,
                             MACROBLOCKD *xd, TOKENEXTRA **t, int dry_run);
86

John Koleszar's avatar
John Koleszar committed
87
#ifdef MODE_STATS
88
89
90
91
92
93
94
95
unsigned int inter_y_modes[MB_MODE_COUNT];
unsigned int inter_uv_modes[VP8_UV_MODES];
unsigned int inter_b_modes[B_MODE_COUNT];
unsigned int y_modes[VP8_YMODES];
unsigned int i8x8_modes[VP8_I8X8_MODES];
unsigned int uv_modes[VP8_UV_MODES];
unsigned int uv_modes_y[VP8_YMODES][VP8_UV_MODES];
unsigned int b_modes[B_MODE_COUNT];
John Koleszar's avatar
John Koleszar committed
96
97
98
#endif


99
100
101
102
103
104
105
106
107
108
109
110
/* 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
 *  vp8_activity_masking().
 */
#define VP8_ACTIVITY_AVG_MIN (64)

/* 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.
 */
John Koleszar's avatar
John Koleszar committed
111
112
static const unsigned char VP8_VAR_OFFS[16] = {
  128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128
113
114
};

115
116

// Original activity measure from Tim T's code.
John Koleszar's avatar
John Koleszar committed
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
static unsigned int tt_activity_measure(VP8_COMP *cpi, MACROBLOCK *x) {
  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.).
   */
  act =     VARIANCE_INVOKE(&cpi->rtcd.variance, var16x16)(x->src.y_buffer,
                                                           x->src.y_stride, VP8_VAR_OFFS, 0, &sse);
  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;
136
137
}

138
// Stub for alternative experimental activity measures.
John Koleszar's avatar
John Koleszar committed
139
140
141
static unsigned int alt_activity_measure(VP8_COMP *cpi,
                                         MACROBLOCK *x, int use_dc_pred) {
  return vp8_encode_intra(cpi, x, use_dc_pred);
142
143
144
145
146
}


// Measure the activity of the current macroblock
// What we measure here is TBD so abstracted to this function
147
#define ALT_ACT_MEASURE 1
John Koleszar's avatar
John Koleszar committed
148
149
150
static unsigned int mb_activity_measure(VP8_COMP *cpi, MACROBLOCK *x,
                                        int mb_row, int mb_col) {
  unsigned int mb_activity;
151

John Koleszar's avatar
John Koleszar committed
152
153
  if (ALT_ACT_MEASURE) {
    int use_dc_pred = (mb_col || mb_row) && (!mb_col || !mb_row);
154

John Koleszar's avatar
John Koleszar committed
155
156
157
158
159
160
    // 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);
  }
161

John Koleszar's avatar
John Koleszar committed
162
163
  if (mb_activity < VP8_ACTIVITY_AVG_MIN)
    mb_activity = VP8_ACTIVITY_AVG_MIN;
164

John Koleszar's avatar
John Koleszar committed
165
  return mb_activity;
166
167
168
}

// Calculate an "average" mb activity value for the frame
169
#define ACT_MEDIAN 0
John Koleszar's avatar
John Koleszar committed
170
static void calc_av_activity(VP8_COMP *cpi, int64_t activity_sum) {
171
#if ACT_MEDIAN
John Koleszar's avatar
John Koleszar committed
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
  // 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;
      }
    }
201

John Koleszar's avatar
John Koleszar committed
202
203
204
    // 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;
205

John Koleszar's avatar
John Koleszar committed
206
    cpi->activity_avg = median;
207

John Koleszar's avatar
John Koleszar committed
208
209
    vpx_free(sortlist);
  }
210
#else
John Koleszar's avatar
John Koleszar committed
211
212
  // Simple mean for now
  cpi->activity_avg = (unsigned int)(activity_sum / cpi->common.MBs);
213
214
#endif

John Koleszar's avatar
John Koleszar committed
215
216
  if (cpi->activity_avg < VP8_ACTIVITY_AVG_MIN)
    cpi->activity_avg = VP8_ACTIVITY_AVG_MIN;
217

John Koleszar's avatar
John Koleszar committed
218
219
220
  // Experimental code: return fixed value normalized for several clips
  if (ALT_ACT_MEASURE)
    cpi->activity_avg = 100000;
221
222
}

223
#define USE_ACT_INDEX   0
224
#define OUTPUT_NORM_ACT_STATS   0
225
226
227

#if USE_ACT_INDEX
// Calculate and activity index for each mb
John Koleszar's avatar
John Koleszar committed
228
229
230
static void calc_activity_index(VP8_COMP *cpi, MACROBLOCK *x) {
  VP8_COMMON *const cm = & cpi->common;
  int mb_row, mb_col;
231

John Koleszar's avatar
John Koleszar committed
232
233
234
  int64_t act;
  int64_t a;
  int64_t b;
235
236

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

John Koleszar's avatar
John Koleszar committed
241
242
  // Reset pointers to start of activity map
  x->mb_activity_ptr = cpi->mb_activity_map;
243

John Koleszar's avatar
John Koleszar committed
244
245
246
247
248
249
  // 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);
250

John Koleszar's avatar
John Koleszar committed
251
252
253
      // Calculate a normalized activity number
      a = act + 4 * cpi->activity_avg;
      b = 4 * act + cpi->activity_avg;
254

John Koleszar's avatar
John Koleszar committed
255
256
257
258
      if (b >= a)
        *(x->activity_ptr) = (int)((b + (a >> 1)) / a) - 1;
      else
        *(x->activity_ptr) = 1 - (int)((a + (b >> 1)) / b);
259
260

#if OUTPUT_NORM_ACT_STATS
John Koleszar's avatar
John Koleszar committed
261
      fprintf(f, " %6d", *(x->mb_activity_ptr));
262
#endif
John Koleszar's avatar
John Koleszar committed
263
264
265
      // Increment activity map pointers
      x->mb_activity_ptr++;
    }
266
267

#if OUTPUT_NORM_ACT_STATS
John Koleszar's avatar
John Koleszar committed
268
    fprintf(f, "\n");
269
270
#endif

John Koleszar's avatar
John Koleszar committed
271
  }
272
273

#if OUTPUT_NORM_ACT_STATS
John Koleszar's avatar
John Koleszar committed
274
  fclose(f);
275
276
277
#endif

}
278
#endif
279
280
281

// Loop through all MBs. Note activity of each, average activity and
// calculate a normalized activity for each
John Koleszar's avatar
John Koleszar committed
282
283
284
285
static void build_activity_map(VP8_COMP *cpi) {
  MACROBLOCK *const x = & cpi->mb;
  MACROBLOCKD *xd = &x->e_mbd;
  VP8_COMMON *const cm = & cpi->common;
286

287
#if ALT_ACT_MEASURE
John Koleszar's avatar
John Koleszar committed
288
289
290
  YV12_BUFFER_CONFIG *new_yv12 = &cm->yv12_fb[cm->new_fb_idx];
  int recon_yoffset;
  int recon_y_stride = new_yv12->y_stride;
291
292
#endif

John Koleszar's avatar
John Koleszar committed
293
294
295
  int mb_row, mb_col;
  unsigned int mb_activity;
  int64_t activity_sum = 0;
296

John Koleszar's avatar
John Koleszar committed
297
298
  // for each macroblock row in image
  for (mb_row = 0; mb_row < cm->mb_rows; mb_row++) {
299
#if ALT_ACT_MEASURE
John Koleszar's avatar
John Koleszar committed
300
301
302
    // reset above block coeffs
    xd->up_available = (mb_row != 0);
    recon_yoffset = (mb_row * recon_y_stride * 16);
303
#endif
John Koleszar's avatar
John Koleszar committed
304
305
    // for each macroblock col in image
    for (mb_col = 0; mb_col < cm->mb_cols; mb_col++) {
306
#if ALT_ACT_MEASURE
John Koleszar's avatar
John Koleszar committed
307
308
309
      xd->dst.y_buffer = new_yv12->y_buffer + recon_yoffset;
      xd->left_available = (mb_col != 0);
      recon_yoffset += 16;
310
#endif
John Koleszar's avatar
John Koleszar committed
311
312
313
314
      // Copy current mb to a buffer
      RECON_INVOKE(&xd->rtcd->recon, copy16x16)(x->src.y_buffer,
                                                x->src.y_stride,
                                                x->thismb, 16);
315

John Koleszar's avatar
John Koleszar committed
316
317
      // measure activity
      mb_activity = mb_activity_measure(cpi, x, mb_row, mb_col);
318

John Koleszar's avatar
John Koleszar committed
319
320
      // Keep frame sum
      activity_sum += mb_activity;
321

John Koleszar's avatar
John Koleszar committed
322
323
      // Store MB level activity details.
      *x->mb_activity_ptr = mb_activity;
324

John Koleszar's avatar
John Koleszar committed
325
326
      // Increment activity map pointer
      x->mb_activity_ptr++;
327

John Koleszar's avatar
John Koleszar committed
328
329
330
      // adjust to the next column of source macroblocks
      x->src.y_buffer += 16;
    }
331

332

John Koleszar's avatar
John Koleszar committed
333
334
    // adjust to the next row of mbs
    x->src.y_buffer += 16 * x->src.y_stride - 16 * cm->mb_cols;
335
336

#if ALT_ACT_MEASURE
John Koleszar's avatar
John Koleszar committed
337
338
339
    // extend the recon for intra prediction
    vp8_extend_mb_row(new_yv12, xd->dst.y_buffer + 16,
                      xd->dst.u_buffer + 8, xd->dst.v_buffer + 8);
340
341
#endif

John Koleszar's avatar
John Koleszar committed
342
  }
343

John Koleszar's avatar
John Koleszar committed
344
345
  // Calculate an "average" MB activity
  calc_av_activity(cpi, activity_sum);
346

347
#if USE_ACT_INDEX
John Koleszar's avatar
John Koleszar committed
348
349
  // Calculate an activity index number of each mb
  calc_activity_index(cpi, x);
350
351
#endif

352
353
}

354
// Macroblock activity masking
John Koleszar's avatar
John Koleszar committed
355
void vp8_activity_masking(VP8_COMP *cpi, MACROBLOCK *x) {
356
#if USE_ACT_INDEX
John Koleszar's avatar
John Koleszar committed
357
358
359
  x->rdmult += *(x->mb_activity_ptr) * (x->rdmult >> 2);
  x->errorperbit = x->rdmult * 100 / (110 * x->rddiv);
  x->errorperbit += (x->errorperbit == 0);
360
#else
John Koleszar's avatar
John Koleszar committed
361
362
363
  int64_t a;
  int64_t b;
  int64_t act = *(x->mb_activity_ptr);
364

John Koleszar's avatar
John Koleszar committed
365
366
367
  // Apply the masking to the RD multiplier.
  a = act + (2 * cpi->activity_avg);
  b = (2 * act) + cpi->activity_avg;
368

John Koleszar's avatar
John Koleszar committed
369
370
371
  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);
372
#endif
373

John Koleszar's avatar
John Koleszar committed
374
375
  // Activity based Zbin adjustment
  adjust_act_zbin(cpi, x);
376
}
John Koleszar's avatar
John Koleszar committed
377

John Koleszar's avatar
John Koleszar committed
378
379
380
381
static void update_state(VP8_COMP *cpi, MACROBLOCK *x, PICK_MODE_CONTEXT *ctx) {
  int i;
  MACROBLOCKD *xd = &x->e_mbd;
  MODE_INFO *mi = &ctx->mic;
Paul Wilkins's avatar
Paul Wilkins committed
382
  MB_MODE_INFO * mbmi = &xd->mode_info_context->mbmi;
John Koleszar's avatar
John Koleszar committed
383
384
  int mb_mode = mi->mbmi.mode;
  int mb_mode_index = ctx->best_mode_index;
Adrian Grange's avatar
Adrian Grange committed
385
386

#if CONFIG_DEBUG
John Koleszar's avatar
John Koleszar committed
387
388
389
  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
390
391
#endif

John Koleszar's avatar
John Koleszar committed
392
393
394
  // 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
395
396
397
398
399
400
401
#if CONFIG_SUPERBLOCKS
  if (mi->mbmi.encoded_as_sb) {
    vpx_memcpy(xd->mode_info_context + 1, mi, sizeof(MODE_INFO));
    vpx_memcpy(xd->mode_info_context + cpi->common.mode_info_stride, mi, sizeof(MODE_INFO));
    vpx_memcpy(xd->mode_info_context + cpi->common.mode_info_stride + 1, mi, sizeof(MODE_INFO));
  }
#endif
Adrian Grange's avatar
Adrian Grange committed
402

John Koleszar's avatar
John Koleszar committed
403
404
405
406
  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
407
    }
John Koleszar's avatar
John Koleszar committed
408
409
410
  } 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
411
    }
John Koleszar's avatar
John Koleszar committed
412
413
414
415
  } else if (mb_mode == SPLITMV) {
    vpx_memcpy(x->partition_info, &ctx->partition_info,
               sizeof(PARTITION_INFO));

416
417
    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
418
419
420
421
422
423
424
425
426
427
428
  }

  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);
    //    }
429
#if CONFIG_INTERNAL_STATS
John Koleszar's avatar
John Koleszar committed
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
    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]]++;
445
#endif
John Koleszar's avatar
John Koleszar committed
446
447
448
449
450
451
452
  } 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
453

John Koleszar's avatar
John Koleszar committed
454
455
456
457
458
459
460
461
                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
462

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

John Koleszar's avatar
John Koleszar committed
468
    rd_update_mvcount(cpi, x, &ctx->best_ref_mv, &ctx->second_best_ref_mv);
Adrian Grange's avatar
Adrian Grange committed
469

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

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

John Koleszar's avatar
John Koleszar committed
479
480
481
482
483
484
485
static void pick_mb_modes(VP8_COMP *cpi,
                          VP8_COMMON *cm,
                          int mb_row,
                          int mb_col,
                          MACROBLOCK  *x,
                          MACROBLOCKD *xd,
                          TOKENEXTRA **tp,
Ronald S. Bultje's avatar
Ronald S. Bultje committed
486
487
                          int *totalrate,
                          int *totaldist) {
John Koleszar's avatar
John Koleszar committed
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
  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
506
             cm->left_context,
John Koleszar's avatar
John Koleszar committed
507
508
509
510
511
512
513
514
515
516
517
             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
518
    MB_MODE_INFO * mbmi = &xd->mode_info_context->mbmi;
John Koleszar's avatar
John Koleszar committed
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535

    // 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
536
#if CONFIG_DEBUG
John Koleszar's avatar
John Koleszar committed
537
538
      assert((xd->prev_mode_info_context - cpi->common.prev_mip) ==
             (xd->mode_info_context - cpi->common.mip));
Adrian Grange's avatar
Adrian Grange committed
539
#endif
John Koleszar's avatar
John Koleszar committed
540
541
      continue;
    }
542

John Koleszar's avatar
John Koleszar committed
543
544
545
546
547
548
549
550
551
552
553
    // 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
554
    xd->left_context = cm->left_context + (i >> 1);
John Koleszar's avatar
John Koleszar committed
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594

    // 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
    x->mv_row_min = -((mb_row * 16) + VP8BORDERINPIXELS - INTERP_EXTEND);
    x->mv_col_min = -((mb_col * 16) + VP8BORDERINPIXELS - INTERP_EXTEND);
    x->mv_row_max = ((cm->mb_rows - mb_row) * 16 +
                     (VP8BORDERINPIXELS - 16 - INTERP_EXTEND));
    x->mv_col_max = ((cm->mb_cols - mb_col) * 16 +
                     (VP8BORDERINPIXELS - 16 - INTERP_EXTEND));

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

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

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

    // Copy current MB to a work buffer
    RECON_INVOKE(&xd->rtcd->recon, copy16x16)(x->src.y_buffer,
                                              x->src.y_stride,
                                              x->thismb, 16);

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

    if (cpi->oxcf.tuning == VP8_TUNE_SSIM)
      vp8_activity_masking(cpi, x);

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

      vp8cx_mb_init_quantizer(cpi, x);
    } else
      // Set to Segment 0 by default
Paul Wilkins's avatar
Paul Wilkins committed
605
      mbmi->segment_id = 0;
John Koleszar's avatar
John Koleszar committed
606
607
608
609

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

    /* force 4x4 transform for mode selection */
Paul Wilkins's avatar
Paul Wilkins committed
610
    mbmi->txfm_size = TX_4X4; // TODO IS this right??
John Koleszar's avatar
John Koleszar committed
611

Ronald S. Bultje's avatar
Ronald S. Bultje committed
612
613
614
615
#if CONFIG_SUPERBLOCKS
    xd->mode_info_context->mbmi.encoded_as_sb = 0;
#endif

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

      // Dummy encode, do not do the tokenization
      vp8cx_encode_intra_macro_block(cpi, x, tp, 0);
      // Note the encoder may have changed the segment_id
Ronald S. Bultje's avatar
Ronald S. Bultje committed
629
630
631
632

      // 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
633
    } else {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
634
      int seg_id, r, d;
John Koleszar's avatar
John Koleszar committed
635
636
637
638
639
640
641
642
643
644
645
646
647

      if (xd->segmentation_enabled && cpi->seg0_cnt > 0 &&
          !segfeature_active(xd, 0, SEG_LVL_REF_FRAME) &&
          segfeature_active(xd, 1, SEG_LVL_REF_FRAME) &&
          check_segref(xd, 1, INTRA_FRAME)  +
          check_segref(xd, 1, LAST_FRAME)   +
          check_segref(xd, 1, GOLDEN_FRAME) +
          check_segref(xd, 1, ALTREF_FRAME) == 1) {
        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;
      }

Ronald S. Bultje's avatar
Ronald S. Bultje committed
648
649
650
651
      vp8cx_pick_mode_inter_macroblock(cpi, x, recon_yoffset,
                                       recon_uvoffset, &r, &d);
      *totalrate += r;
      *totaldist += d;
John Koleszar's avatar
John Koleszar committed
652
653
654
655
656

      // Dummy encode, do not do the tokenization
      vp8cx_encode_inter_macroblock(cpi, x, tp,
                                    recon_yoffset, recon_uvoffset, 0);

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

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

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

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

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

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

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

Ronald S. Bultje's avatar
Ronald S. Bultje committed
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
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
#if CONFIG_SUPERBLOCKS
static void pick_sb_modes (VP8_COMP *cpi,
                           VP8_COMMON *cm,
                           int mb_row,
                           int mb_col,
                           MACROBLOCK  *x,
                           MACROBLOCKD *xd,
                           TOKENEXTRA **tp,
                           int *totalrate,
                           int *totaldist)
{
  int map_index;
  int recon_yoffset, recon_uvoffset;
  int ref_fb_idx = cm->lst_fb_idx;
  int dst_fb_idx = cm->new_fb_idx;
  int recon_y_stride = cm->yv12_fb[ref_fb_idx].y_stride;
  int recon_uv_stride = cm->yv12_fb[ref_fb_idx].uv_stride;
  ENTROPY_CONTEXT_PLANES left_context[2];
  ENTROPY_CONTEXT_PLANES above_context[2];
  ENTROPY_CONTEXT_PLANES *initial_above_context_ptr = cm->above_context
    + mb_col;

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

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

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

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

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

  /* Set up limit values for MV components to prevent them from
   * extending beyond the UMV borders assuming 16x16 block size */
  x->mv_row_min = -((mb_row * 16) + VP8BORDERINPIXELS - INTERP_EXTEND);
  x->mv_col_min = -((mb_col * 16) + VP8BORDERINPIXELS - INTERP_EXTEND);
  x->mv_row_max = ((cm->mb_rows - mb_row) * 16 +
                   (VP8BORDERINPIXELS - 32 - INTERP_EXTEND));
  x->mv_col_max = ((cm->mb_cols - mb_col) * 16 +
                   (VP8BORDERINPIXELS - 32 - INTERP_EXTEND));

  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 */
  RECON_INVOKE(&xd->rtcd->recon, copy16x16)(x->src.y_buffer,
                                            x->src.y_stride,
                                            x->thismb, 16);
#endif
  x->rddiv = cpi->RDDIV;
  x->rdmult = cpi->RDMULT;
  if(cpi->oxcf.tuning == VP8_TUNE_SSIM)
    vp8_activity_masking(cpi, x);
  /* 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;

    vp8cx_mb_init_quantizer(cpi, x);
  }
  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)
  {
    vp8_rd_pick_intra_mode_sb(cpi, x,
                              totalrate,
                              totaldist);

    /* Save the coding context */
    vpx_memcpy(&x->sb_context[0].mic, xd->mode_info_context,
               sizeof(MODE_INFO));
  }
  else
  {
    if (xd->segmentation_enabled && cpi->seg0_cnt > 0 &&
        !segfeature_active( xd, 0, SEG_LVL_REF_FRAME ) &&
        segfeature_active( xd, 1, SEG_LVL_REF_FRAME ) &&
        check_segref(xd, 1, INTRA_FRAME)  +
        check_segref(xd, 1, LAST_FRAME)   +
        check_segref(xd, 1, GOLDEN_FRAME) +
        check_segref(xd, 1, ALTREF_FRAME) == 1)
    {
      cpi->seg0_progress = (cpi->seg0_idx << 16) / cpi->seg0_cnt;
    }
    else
    {
      cpi->seg0_progress =
        (((mb_col & ~1) * 2 + (mb_row & ~1) * cm->mb_cols) << 16) / cm->MBs;
    }

    vp8_rd_pick_inter_mode_sb(cpi, x,
                              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

John Koleszar's avatar
John Koleszar committed
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
static void encode_sb(VP8_COMP *cpi,
                      VP8_COMMON *cm,
                      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
881
    MB_MODE_INFO * mbmi = &xd->mode_info_context->mbmi;
John Koleszar's avatar
John Koleszar committed
882
883
884
885
886
887
888
889
890
891
892
893
894
895

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

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

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

#if CONFIG_DEBUG
John Koleszar's avatar
John Koleszar committed
898
899
      assert((xd->prev_mode_info_context - cpi->common.prev_mip) ==
             (xd->mode_info_context - cpi->common.mip));
Adrian Grange's avatar
Adrian Grange committed
900
#endif
John Koleszar's avatar
John Koleszar committed
901
902
      continue;
    }
Adrian Grange's avatar
Adrian Grange committed
903

John Koleszar's avatar
John Koleszar committed
904
    xd->mb_index = i;
Adrian Grange's avatar
Adrian Grange committed
905

906
#ifdef ENC_DEBUG
John Koleszar's avatar
John Koleszar committed
907
908
909
910
    enc_debug = (cpi->common.current_video_frame == 0 &&
                 mb_row == 0 && mb_col == 0);
    mb_col_debug = mb_col;
    mb_row_debug = mb_row;
911
#endif
Adrian Grange's avatar
Adrian Grange committed
912

John Koleszar's avatar
John Koleszar committed
913
    // Restore MB state to that when it was picked
Adrian Grange's avatar
Adrian Grange committed
914
#if CONFIG_SUPERBLOCKS
Ronald S. Bultje's avatar
Ronald S. Bultje committed
915
    if (xd->mode_info_context->mbmi.encoded_as_sb) {
John Koleszar's avatar
John Koleszar committed
916
      update_state(cpi, x, &x->sb_context[i]);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
917
918
      cpi->sb_count++;
    } else
Adrian Grange's avatar
Adrian Grange committed
919
#endif
John Koleszar's avatar
John Koleszar committed
920
921
922
923
924
925
926
      update_state(cpi, x, &x->mb_context[i]);

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

    // reset above block coeffs
    xd->above_context = cm->above_context + mb_col;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
927
    xd->left_context  = cm->left_context + (i >> 1);
John Koleszar's avatar
John Koleszar committed
928
929
930
931
932
933
934

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

Adrian Grange's avatar
Adrian Grange committed
935
#if CONFIG_SUPERBLOCKS
Ronald S. Bultje's avatar
Ronald S. Bultje committed
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
    if (xd->mode_info_context->mbmi.encoded_as_sb) {
      // Set up limit values for MV components to prevent them from
      // extending beyond the UMV borders assuming 32x32 block size
      x->mv_row_min = -((mb_row * 16) + VP8BORDERINPIXELS - INTERP_EXTEND);
      x->mv_col_min = -((mb_col * 16) + VP8BORDERINPIXELS - INTERP_EXTEND);
      x->mv_row_max = ((cm->mb_rows - mb_row) * 16 +
                       (VP8BORDERINPIXELS - 32 - INTERP_EXTEND));
      x->mv_col_max = ((cm->mb_cols - mb_col) * 16 +
                       (VP8BORDERINPIXELS - 32 - INTERP_EXTEND));
    } else {
#endif
      // Set up limit values for MV components to prevent them from
      // extending beyond the UMV borders assuming 16x16 block size
      x->mv_row_min = -((mb_row * 16) + VP8BORDERINPIXELS - INTERP_EXTEND);
      x->mv_col_min = -((mb_col * 16) + VP8BORDERINPIXELS - INTERP_EXTEND);
      x->mv_row_max = ((cm->mb_rows - mb_row) * 16 +
                       (VP8BORDERINPIXELS - 16 - INTERP_EXTEND));
      x->mv_col_max = ((cm->mb_cols - mb_col) * 16 +
                       (VP8BORDERINPIXELS - 16 - INTERP_EXTEND));
#if CONFIG_SUPERBLOCKS
    }
Adrian Grange's avatar
Adrian Grange committed
957
958
#endif

John Koleszar's avatar
John Koleszar committed
959
960
    xd->up_available = (mb_row != 0);
    xd->left_available = (mb_col != 0);
Adrian Grange's avatar
Adrian Grange committed
961

John Koleszar's avatar
John Koleszar committed
962
963
    recon_yoffset = (mb_row * recon_y_stride * 16) + (mb_col * 16);
    recon_uvoffset = (mb_row * recon_uv_stride * 8) + (mb_col * 8);
Adrian Grange's avatar
Adrian Grange committed
964

John Koleszar's avatar
John Koleszar committed
965
966
967
    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;
John Koleszar's avatar
John Koleszar committed
968

John Koleszar's avatar
John Koleszar committed
969
970
971
972
    // Copy current MB to a work buffer
    RECON_INVOKE(&xd->rtcd->recon, copy16x16)(x->src.y_buffer,
                                              x->src.y_stride,
                                              x->thismb, 16);
973

John Koleszar's avatar
John Koleszar committed
974
975
    if (cpi->oxcf.tuning == VP8_TUNE_SSIM)
      vp8_activity_masking(cpi, x);
976

John Koleszar's avatar
John Koleszar committed
977
978
979
    // Is segmentation enabled
    if (xd->segmentation_enabled) {
      vp8cx_mb_init_quantizer(cpi, x);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
980
    }
John Koleszar's avatar
John Koleszar committed
981

John Koleszar's avatar
John Koleszar committed
982
    x->active_ptr = cpi->active_map + map_index;
983

John Koleszar's avatar
John Koleszar committed
984
985
986
    cpi->update_context = 0;

    if (cm->frame_type == KEY_FRAME) {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
987
988
989
990
991
992
993
#if CONFIG_SUPERBLOCKS
      if (xd->mode_info_context->mbmi.encoded_as_sb)
        vp8cx_encode_intra_super_block(cpi, x, tp, mb_col);
      else
#endif
        vp8cx_encode_intra_macro_block(cpi, x, tp, 1);
        // Note the encoder may have changed the segment_id
994

John Koleszar's avatar
John Koleszar committed
995
#ifdef MODE_STATS
Paul Wilkins's avatar
Paul Wilkins committed
996
      y_modes[mbmi->mode]++;
John Koleszar's avatar
John Koleszar committed
997
#endif
John Koleszar's avatar
John Koleszar committed
998
999
1000
    } else {
      unsigned char *segment_id;
      int seg_ref_active;
For faster browsing, not all history is shown. View entire blame