vp9_onyx_if.c 134 KB
Newer Older
John Koleszar's avatar
John Koleszar committed
1
/*
2
 *  Copyright (c) 2010 The WebM project authors. All Rights Reserved.
John Koleszar's avatar
John Koleszar committed
3
 *
4
 *  Use of this source code is governed by a BSD-style license
5
6
 *  that can be found in the LICENSE file in the root of the source
 *  tree. An additional intellectual property rights grant can be found
7
 *  in the file PATENTS.  All contributing project authors may
8
 *  be found in the AUTHORS file in the root of the source tree.
John Koleszar's avatar
John Koleszar committed
9
10
11
 */


12
#include "vpx_config.h"
13
#include "vp9/common/vp9_filter.h"
14
#include "vp9/common/vp9_onyxc_int.h"
15
#include "vp9/common/vp9_reconinter.h"
16
#include "vp9/encoder/vp9_onyx_int.h"
17
#include "vp9/common/vp9_systemdependent.h"
18
#include "vp9/encoder/vp9_quantize.h"
19
#include "vp9/common/vp9_alloccommon.h"
20
21
22
#include "vp9/encoder/vp9_mcomp.h"
#include "vp9/encoder/vp9_firstpass.h"
#include "vp9/encoder/vp9_psnr.h"
Johann's avatar
Johann committed
23
#include "vpx_scale/vpx_scale.h"
24
#include "vp9/common/vp9_extend.h"
25
#include "vp9/encoder/vp9_ratectrl.h"
26
#include "vp9/common/vp9_quant_common.h"
27
#include "vp9/common/vp9_tile_common.h"
28
#include "vp9/encoder/vp9_segmentation.h"
29
#include "./vp9_rtcd.h"
30
#include "./vpx_scale_rtcd.h"
31
#if CONFIG_POSTPROC
32
#include "vp9/common/vp9_postproc.h"
33
#endif
John Koleszar's avatar
John Koleszar committed
34
35
#include "vpx_mem/vpx_mem.h"
#include "vpx_ports/vpx_timer.h"
36

37
#include "vp9/common/vp9_seg_common.h"
38
#include "vp9/encoder/vp9_mbgraph.h"
39
40
#include "vp9/common/vp9_pred_common.h"
#include "vp9/encoder/vp9_rdopt.h"
41
#include "vp9/encoder/vp9_bitstream.h"
42
43
#include "vp9/encoder/vp9_picklpf.h"
#include "vp9/common/vp9_mvref_common.h"
44
#include "vp9/encoder/vp9_temporal_filter.h"
Paul Wilkins's avatar
Paul Wilkins committed
45

John Koleszar's avatar
John Koleszar committed
46
47
48
49
50
#include <math.h>
#include <stdio.h>
#include <limits.h>

extern void print_tree_update_probs();
51

52
static void set_default_lf_deltas(VP9_COMP *cpi);
John Koleszar's avatar
John Koleszar committed
53

Adrian Grange's avatar
Adrian Grange committed
54
55
#define DEFAULT_INTERP_FILTER SWITCHABLE

56
57
#define SEARCH_BEST_FILTER 0            /* to search exhaustively for
                                           best filter */
58
#define RESET_FOREACH_FILTER 0          /* whether to reset the encoder state
59
60
61
62
63
64
65
66
67
                                           before trying each new filter */
#define SHARP_FILTER_QTHRESH 0          /* Q threshold for 8-tap sharp filter */

#define ALTREF_HIGH_PRECISION_MV 1      /* whether to use high precision mv
                                           for altref computation */
#define HIGH_PRECISION_MV_QTHRESH 200   /* Q threshold for use of high precision
                                           mv. Choose a very high value for
                                           now so that HIGH_PRECISION is always
                                           chosen */
68

69
#if CONFIG_INTERNAL_STATS
John Koleszar's avatar
John Koleszar committed
70
71
#include "math.h"

72
extern double vp9_calc_ssim(YV12_BUFFER_CONFIG *source,
73
74
                            YV12_BUFFER_CONFIG *dest, int lumamask,
                            double *weight);
John Koleszar's avatar
John Koleszar committed
75

76

77
extern double vp9_calc_ssimg(YV12_BUFFER_CONFIG *source,
78
79
                             YV12_BUFFER_CONFIG *dest, double *ssim_y,
                             double *ssim_u, double *ssim_v);
John Koleszar's avatar
John Koleszar committed
80
81
82
83


#endif

John Koleszar's avatar
John Koleszar committed
84
// #define OUTPUT_YUV_REC
John Koleszar's avatar
John Koleszar committed
85
86
87
88

#ifdef OUTPUT_YUV_SRC
FILE *yuv_file;
#endif
89
90
91
#ifdef OUTPUT_YUV_REC
FILE *yuv_rec_file;
#endif
John Koleszar's avatar
John Koleszar committed
92
93
94

#if 0
FILE *framepsnr;
Yaowu Xu's avatar
Yaowu Xu committed
95
FILE *kf_list;
John Koleszar's avatar
John Koleszar committed
96
97
98
99
100
101
102
103
104
105
FILE *keyfile;
#endif

#if 0
extern int skip_true_count;
extern int skip_false_count;
#endif


#ifdef ENTROPY_STATS
106
107
108
extern int intra_mode_stats[VP9_KF_BINTRAMODES]
                           [VP9_KF_BINTRAMODES]
                           [VP9_KF_BINTRAMODES];
John Koleszar's avatar
John Koleszar committed
109
110
#endif

111
112
113
114
115
#ifdef NMV_STATS
extern void init_nmvstats();
extern void print_nmvstats();
#endif

116
117
118
119
120
121
#if CONFIG_CODE_ZEROGROUP
#ifdef ZPC_STATS
extern void init_zpcstats();
extern void print_zpcstats();
#endif
#endif
122

John Koleszar's avatar
John Koleszar committed
123
124
125
126
#ifdef SPEEDSTATS
unsigned int frames_at_speed[16] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
#endif

127
128
129
#if defined(SECTIONBITS_OUTPUT)
extern unsigned __int64 Sectionbits[500];
#endif
John Koleszar's avatar
John Koleszar committed
130
#ifdef MODE_STATS
John Koleszar's avatar
John Koleszar committed
131
extern int64_t Sectionbits[500];
132
133
134
135
extern unsigned int y_modes[VP9_YMODES];
extern unsigned int i8x8_modes[VP9_I8X8_MODES];
extern unsigned int uv_modes[VP9_UV_MODES];
extern unsigned int uv_modes_y[VP9_YMODES][VP9_UV_MODES];
136
extern unsigned int b_modes[B_MODE_COUNT];
John Koleszar's avatar
John Koleszar committed
137
extern unsigned int inter_y_modes[MB_MODE_COUNT];
138
extern unsigned int inter_uv_modes[VP9_UV_MODES];
139
extern unsigned int inter_b_modes[B_MODE_COUNT];
John Koleszar's avatar
John Koleszar committed
140
141
#endif

142
extern void vp9_init_quantizer(VP9_COMP *cpi);
Paul Wilkins's avatar
Paul Wilkins committed
143

144
static int base_skip_false_prob[QINDEX_RANGE][3];
145

146
// Tables relating active max Q to active min Q
147
148
149
150
151
152
153
154
155
156
static int kf_low_motion_minq[QINDEX_RANGE];
static int kf_high_motion_minq[QINDEX_RANGE];
static int gf_low_motion_minq[QINDEX_RANGE];
static int gf_high_motion_minq[QINDEX_RANGE];
static int inter_minq[QINDEX_RANGE];

// Functions to compute the active minq lookup table entries based on a
// formulaic approach to facilitate easier adjustment of the Q tables.
// The formulae were derived from computing a 3rd order polynomial best
// fit to the original data (after plotting real maxq vs minq (not q index))
157
static int calculate_minq_index(double maxq,
Dmitry Kovalev's avatar
Dmitry Kovalev committed
158
                                double x3, double x2, double x1, double c) {
John Koleszar's avatar
John Koleszar committed
159
  int i;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
160
161
  const double minqtarget = MIN(((x3 * maxq + x2) * maxq + x1) * maxq + c,
                                maxq);
John Koleszar's avatar
John Koleszar committed
162

Paul Wilkins's avatar
Paul Wilkins committed
163
164
165
166
167
  // Special case handling to deal with the step from q2.0
  // down to lossless mode represented by q 1.0.
  if (minqtarget <= 2.0)
    return 0;

John Koleszar's avatar
John Koleszar committed
168
  for (i = 0; i < QINDEX_RANGE; i++) {
169
    if (minqtarget <= vp9_convert_qindex_to_q(i))
John Koleszar's avatar
John Koleszar committed
170
171
      return i;
  }
Dmitry Kovalev's avatar
Dmitry Kovalev committed
172

John Koleszar's avatar
John Koleszar committed
173
  return QINDEX_RANGE - 1;
174
}
175

176
static void init_minq_luts(void) {
John Koleszar's avatar
John Koleszar committed
177
178
179
  int i;

  for (i = 0; i < QINDEX_RANGE; i++) {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
180
    const double maxq = vp9_convert_qindex_to_q(i);
John Koleszar's avatar
John Koleszar committed
181
182
183


    kf_low_motion_minq[i] = calculate_minq_index(maxq,
184
185
186
                                                 0.000001,
                                                 -0.0004,
                                                 0.15,
John Koleszar's avatar
John Koleszar committed
187
188
                                                 0.0);
    kf_high_motion_minq[i] = calculate_minq_index(maxq,
189
190
191
                                                  0.000002,
                                                  -0.0012,
                                                  0.5,
John Koleszar's avatar
John Koleszar committed
192
                                                  0.0);
193

John Koleszar's avatar
John Koleszar committed
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
    gf_low_motion_minq[i] = calculate_minq_index(maxq,
                                                 0.0000015,
                                                 -0.0009,
                                                 0.33,
                                                 0.0);
    gf_high_motion_minq[i] = calculate_minq_index(maxq,
                                                  0.0000021,
                                                  -0.00125,
                                                  0.45,
                                                  0.0);
    inter_minq[i] = calculate_minq_index(maxq,
                                         0.00000271,
                                         -0.00113,
                                         0.697,
                                         0.0);

  }
211
}
212

213
214
215
216
217
218
219
220
221
static void set_mvcost(MACROBLOCK *mb) {
  if (mb->e_mbd.allow_high_precision_mv) {
    mb->mvcost = mb->nmvcost_hp;
    mb->mvsadcost = mb->nmvsadcost_hp;
  } else {
    mb->mvcost = mb->nmvcost;
    mb->mvsadcost = mb->nmvsadcost;
  }
}
222
static void init_base_skip_probs(void) {
John Koleszar's avatar
John Koleszar committed
223
  int i;
Paul Wilkins's avatar
Paul Wilkins committed
224

John Koleszar's avatar
John Koleszar committed
225
  for (i = 0; i < QINDEX_RANGE; i++) {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
226
    const double q = vp9_convert_qindex_to_q(i);
Paul Wilkins's avatar
Paul Wilkins committed
227

John Koleszar's avatar
John Koleszar committed
228
229
    // Exponential decay caluclation of baseline skip prob with clamping
    // Based on crude best fit of old table.
Dmitry Kovalev's avatar
Dmitry Kovalev committed
230
    const int t = (int)(564.25 * pow(2.71828, (-0.012 * q)));
231

232
233
234
    base_skip_false_prob[i][1] = clip_prob(t);
    base_skip_false_prob[i][2] = clip_prob(t * 3 / 4);
    base_skip_false_prob[i][0] = clip_prob(t * 5 / 4);
John Koleszar's avatar
John Koleszar committed
235
  }
Paul Wilkins's avatar
Paul Wilkins committed
236
}
237

238
239
static void update_base_skip_probs(VP9_COMP *cpi) {
  VP9_COMMON *cm = &cpi->common;
240
  int k;
Paul Wilkins's avatar
Paul Wilkins committed
241

John Koleszar's avatar
John Koleszar committed
242
  if (cm->frame_type != KEY_FRAME) {
243
    vp9_update_skip_probs(cpi);
Paul Wilkins's avatar
Paul Wilkins committed
244

245
    if (cpi->refresh_alt_ref_frame) {
John Koleszar's avatar
John Koleszar committed
246
247
248
      for (k = 0; k < MBSKIP_CONTEXTS; ++k)
        cpi->last_skip_false_probs[2][k] = cm->mbskip_pred_probs[k];
      cpi->last_skip_probs_q[2] = cm->base_qindex;
249
    } else if (cpi->refresh_golden_frame) {
John Koleszar's avatar
John Koleszar committed
250
251
252
253
254
255
256
      for (k = 0; k < MBSKIP_CONTEXTS; ++k)
        cpi->last_skip_false_probs[1][k] = cm->mbskip_pred_probs[k];
      cpi->last_skip_probs_q[1] = cm->base_qindex;
    } else {
      for (k = 0; k < MBSKIP_CONTEXTS; ++k)
        cpi->last_skip_false_probs[0][k] = cm->mbskip_pred_probs[k];
      cpi->last_skip_probs_q[0] = cm->base_qindex;
Paul Wilkins's avatar
Paul Wilkins committed
257

John Koleszar's avatar
John Koleszar committed
258
259
260
      // update the baseline table for the current q
      for (k = 0; k < MBSKIP_CONTEXTS; ++k)
        cpi->base_skip_false_prob[cm->base_qindex][k] =
261
            cm->mbskip_pred_probs[k];
Paul Wilkins's avatar
Paul Wilkins committed
262
    }
John Koleszar's avatar
John Koleszar committed
263
  }
Paul Wilkins's avatar
Paul Wilkins committed
264
}
Paul Wilkins's avatar
Paul Wilkins committed
265

266
void vp9_initialize_enc() {
John Koleszar's avatar
John Koleszar committed
267
268
269
  static int init_done = 0;

  if (!init_done) {
270
    vp9_initialize_common();
271
    vp9_tokenize_initialize();
272
    vp9_init_quant_tables();
273
    vp9_init_me_luts();
John Koleszar's avatar
John Koleszar committed
274
275
276
277
    init_minq_luts();
    init_base_skip_probs();
    init_done = 1;
  }
John Koleszar's avatar
John Koleszar committed
278
279
280
281
282
}
#ifdef PACKET_TESTING
extern FILE *vpxlogc;
#endif

283
static void setup_features(VP9_COMP *cpi) {
John Koleszar's avatar
John Koleszar committed
284
  MACROBLOCKD *xd = &cpi->mb.e_mbd;
Paul Wilkins's avatar
Paul Wilkins committed
285

John Koleszar's avatar
John Koleszar committed
286
  // Set up default state for MB feature flags
287
  xd->segmentation_enabled = 0;
288

John Koleszar's avatar
John Koleszar committed
289
290
  xd->update_mb_segmentation_map = 0;
  xd->update_mb_segmentation_data = 0;
291
292
293
#if CONFIG_IMPLICIT_SEGMENTATION
  xd->allow_implicit_segment_update = 0;
#endif
John Koleszar's avatar
John Koleszar committed
294
  vpx_memset(xd->mb_segment_tree_probs, 255, sizeof(xd->mb_segment_tree_probs));
Paul Wilkins's avatar
Paul Wilkins committed
295

296
  vp9_clearall_segfeatures(xd);
Paul Wilkins's avatar
Paul Wilkins committed
297

John Koleszar's avatar
John Koleszar committed
298
299
300
301
302
303
  xd->mode_ref_lf_delta_enabled = 0;
  xd->mode_ref_lf_delta_update = 0;
  vpx_memset(xd->ref_lf_deltas, 0, sizeof(xd->ref_lf_deltas));
  vpx_memset(xd->mode_lf_deltas, 0, sizeof(xd->mode_lf_deltas));
  vpx_memset(xd->last_ref_lf_deltas, 0, sizeof(xd->ref_lf_deltas));
  vpx_memset(xd->last_mode_lf_deltas, 0, sizeof(xd->mode_lf_deltas));
John Koleszar's avatar
John Koleszar committed
304

John Koleszar's avatar
John Koleszar committed
305
  set_default_lf_deltas(cpi);
John Koleszar's avatar
John Koleszar committed
306
307
308
}


309
static void dealloc_compressor_data(VP9_COMP *cpi) {
John Koleszar's avatar
John Koleszar committed
310
311
312
313
314
315
316
  // Delete sementation map
  vpx_free(cpi->segmentation_map);
  cpi->segmentation_map = 0;
  vpx_free(cpi->common.last_frame_seg_map);
  cpi->common.last_frame_seg_map = 0;
  vpx_free(cpi->coding_context.last_frame_seg_map_copy);
  cpi->coding_context.last_frame_seg_map_copy = 0;
John Koleszar's avatar
John Koleszar committed
317

John Koleszar's avatar
John Koleszar committed
318
319
  vpx_free(cpi->active_map);
  cpi->active_map = 0;
John Koleszar's avatar
John Koleszar committed
320

Dmitry Kovalev's avatar
Dmitry Kovalev committed
321
  vp9_free_frame_buffers(&cpi->common);
John Koleszar's avatar
John Koleszar committed
322

John Koleszar's avatar
John Koleszar committed
323
324
325
  vp8_yv12_de_alloc_frame_buffer(&cpi->last_frame_uf);
  vp8_yv12_de_alloc_frame_buffer(&cpi->scaled_source);
  vp8_yv12_de_alloc_frame_buffer(&cpi->alt_ref_buffer);
326
  vp9_lookahead_destroy(cpi->lookahead);
John Koleszar's avatar
John Koleszar committed
327

John Koleszar's avatar
John Koleszar committed
328
329
  vpx_free(cpi->tok);
  cpi->tok = 0;
John Koleszar's avatar
John Koleszar committed
330

John Koleszar's avatar
John Koleszar committed
331
332
333
334
335
  // Activity mask based per mb zbin adjustments
  vpx_free(cpi->mb_activity_map);
  cpi->mb_activity_map = 0;
  vpx_free(cpi->mb_norm_activity_map);
  cpi->mb_norm_activity_map = 0;
336

John Koleszar's avatar
John Koleszar committed
337
338
  vpx_free(cpi->mb.pip);
  cpi->mb.pip = 0;
John Koleszar's avatar
John Koleszar committed
339
340
}

341
342
343
// Computes a q delta (in "q index" terms) to get from a starting q value
// to a target value
// target q value
344
static int compute_qdelta(VP9_COMP *cpi, double qstart, double qtarget) {
John Koleszar's avatar
John Koleszar committed
345
346
347
348
349
350
351
  int i;
  int start_index = cpi->worst_quality;
  int target_index = cpi->worst_quality;

  // Convert the average q value to an index.
  for (i = cpi->best_quality; i < cpi->worst_quality; i++) {
    start_index = i;
352
    if (vp9_convert_qindex_to_q(i) >= qstart)
John Koleszar's avatar
John Koleszar committed
353
354
355
356
357
358
      break;
  }

  // Convert the q target to an index
  for (i = cpi->best_quality; i < cpi->worst_quality; i++) {
    target_index = i;
359
    if (vp9_convert_qindex_to_q(i) >= qtarget)
John Koleszar's avatar
John Koleszar committed
360
361
362
363
      break;
  }

  return target_index - start_index;
364
365
}

366
static void configure_static_seg_features(VP9_COMP *cpi) {
367
  VP9_COMMON *cm = &cpi->common;
John Koleszar's avatar
John Koleszar committed
368
  MACROBLOCKD *xd = &cpi->mb.e_mbd;
369

John Koleszar's avatar
John Koleszar committed
370
371
  int high_q = (int)(cpi->avg_q > 48.0);
  int qi_delta;
372

John Koleszar's avatar
John Koleszar committed
373
374
375
  // Disable and clear down for KF
  if (cm->frame_type == KEY_FRAME) {
    // Clear down the global segmentation map
376
    vpx_memset(cpi->segmentation_map, 0, cm->mi_rows * cm->mi_cols);
John Koleszar's avatar
John Koleszar committed
377
378
    xd->update_mb_segmentation_map = 0;
    xd->update_mb_segmentation_data = 0;
379
#if CONFIG_IMPLICIT_SEGMENTATION
380
    xd->allow_implicit_segment_update = 0;
381
#endif
John Koleszar's avatar
John Koleszar committed
382
    cpi->static_mb_pct = 0;
383

John Koleszar's avatar
John Koleszar committed
384
    // Disable segmentation
385
    vp9_disable_segmentation((VP9_PTR)cpi);
Paul Wilkins's avatar
Paul Wilkins committed
386

John Koleszar's avatar
John Koleszar committed
387
    // Clear down the segment features.
388
    vp9_clearall_segfeatures(xd);
389
390
  } else if (cpi->refresh_alt_ref_frame) {
    // If this is an alt ref frame
John Koleszar's avatar
John Koleszar committed
391
    // Clear down the global segmentation map
392
    vpx_memset(cpi->segmentation_map, 0, cm->mi_rows * cm->mi_cols);
John Koleszar's avatar
John Koleszar committed
393
394
    xd->update_mb_segmentation_map = 0;
    xd->update_mb_segmentation_data = 0;
395
#if CONFIG_IMPLICIT_SEGMENTATION
396
    xd->allow_implicit_segment_update = 0;
397
#endif
John Koleszar's avatar
John Koleszar committed
398
    cpi->static_mb_pct = 0;
Paul Wilkins's avatar
Paul Wilkins committed
399

John Koleszar's avatar
John Koleszar committed
400
    // Disable segmentation and individual segment features by default
401
    vp9_disable_segmentation((VP9_PTR)cpi);
402
    vp9_clearall_segfeatures(xd);
Paul Wilkins's avatar
Paul Wilkins committed
403

John Koleszar's avatar
John Koleszar committed
404
405
    // Scan frames from current to arf frame.
    // This function re-enables segmentation if appropriate.
406
    vp9_update_mbgraph_stats(cpi);
Paul Wilkins's avatar
Paul Wilkins committed
407

John Koleszar's avatar
John Koleszar committed
408
409
410
411
412
    // If segmentation was enabled set those features needed for the
    // arf itself.
    if (xd->segmentation_enabled) {
      xd->update_mb_segmentation_map = 1;
      xd->update_mb_segmentation_data = 1;
Paul Wilkins's avatar
Paul Wilkins committed
413

John Koleszar's avatar
John Koleszar committed
414
      qi_delta = compute_qdelta(cpi, cpi->avg_q, (cpi->avg_q * 0.875));
415
416
      vp9_set_segdata(xd, 1, SEG_LVL_ALT_Q, (qi_delta - 2));
      vp9_set_segdata(xd, 1, SEG_LVL_ALT_LF, -2);
Paul Wilkins's avatar
Paul Wilkins committed
417

418
419
      vp9_enable_segfeature(xd, 1, SEG_LVL_ALT_Q);
      vp9_enable_segfeature(xd, 1, SEG_LVL_ALT_LF);
420

John Koleszar's avatar
John Koleszar committed
421
422
      // Where relevant assume segment data is delta data
      xd->mb_segment_abs_delta = SEGMENT_DELTADATA;
Paul Wilkins's avatar
Paul Wilkins committed
423

424
    }
425
426
427
  } else if (xd->segmentation_enabled) {
    // All other frames if segmentation has been enabled

John Koleszar's avatar
John Koleszar committed
428
429
    // First normal frame in a valid gf or alt ref group
    if (cpi->common.frames_since_golden == 0) {
Paul Wilkins's avatar
Paul Wilkins committed
430
      // Set up segment features for normal frames in an arf group
John Koleszar's avatar
John Koleszar committed
431
432
433
434
      if (cpi->source_alt_ref_active) {
        xd->update_mb_segmentation_map = 0;
        xd->update_mb_segmentation_data = 1;
        xd->mb_segment_abs_delta = SEGMENT_DELTADATA;
Paul Wilkins's avatar
Paul Wilkins committed
435

John Koleszar's avatar
John Koleszar committed
436
437
        qi_delta = compute_qdelta(cpi, cpi->avg_q,
                                  (cpi->avg_q * 1.125));
438
439
440
        vp9_set_segdata(xd, 1, SEG_LVL_ALT_Q, (qi_delta + 2));
        vp9_set_segdata(xd, 1, SEG_LVL_ALT_Q, 0);
        vp9_enable_segfeature(xd, 1, SEG_LVL_ALT_Q);
Paul Wilkins's avatar
Paul Wilkins committed
441

442
443
        vp9_set_segdata(xd, 1, SEG_LVL_ALT_LF, -2);
        vp9_enable_segfeature(xd, 1, SEG_LVL_ALT_LF);
Paul Wilkins's avatar
Paul Wilkins committed
444

John Koleszar's avatar
John Koleszar committed
445
446
        // Segment coding disabled for compred testing
        if (high_q || (cpi->static_mb_pct == 100)) {
447
448
          vp9_set_segref(xd, 1, ALTREF_FRAME);
          vp9_enable_segfeature(xd, 1, SEG_LVL_REF_FRAME);
Paul Wilkins's avatar
Paul Wilkins committed
449
          vp9_enable_segfeature(xd, 1, SEG_LVL_SKIP);
John Koleszar's avatar
John Koleszar committed
450
        }
451
452
453
454
      } else {
        // Disable segmentation and clear down features if alt ref
        // is not active for this group

455
        vp9_disable_segmentation((VP9_PTR)cpi);
Paul Wilkins's avatar
Paul Wilkins committed
456

457
        vpx_memset(cpi->segmentation_map, 0, cm->mi_rows * cm->mi_cols);
Paul Wilkins's avatar
Paul Wilkins committed
458

John Koleszar's avatar
John Koleszar committed
459
460
        xd->update_mb_segmentation_map = 0;
        xd->update_mb_segmentation_data = 0;
Paul Wilkins's avatar
Paul Wilkins committed
461

462
        vp9_clearall_segfeatures(xd);
John Koleszar's avatar
John Koleszar committed
463
      }
464
465
466
467
    } else if (cpi->is_src_frame_alt_ref) {
      // Special case where we are coding over the top of a previous
      // alt ref frame.
      // Segment coding disabled for compred testing
John Koleszar's avatar
John Koleszar committed
468

Paul Wilkins's avatar
Paul Wilkins committed
469
      // Enable ref frame features for segment 0 as well
470
471
      vp9_enable_segfeature(xd, 0, SEG_LVL_REF_FRAME);
      vp9_enable_segfeature(xd, 1, SEG_LVL_REF_FRAME);
John Koleszar's avatar
John Koleszar committed
472

Paul Wilkins's avatar
Paul Wilkins committed
473
      // All mbs should use ALTREF_FRAME
474
475
476
477
      vp9_clear_segref(xd, 0);
      vp9_set_segref(xd, 0, ALTREF_FRAME);
      vp9_clear_segref(xd, 1);
      vp9_set_segref(xd, 1, ALTREF_FRAME);
John Koleszar's avatar
John Koleszar committed
478

Paul Wilkins's avatar
Paul Wilkins committed
479
      // Skip all MBs if high Q (0,0 mv and skip coeffs)
John Koleszar's avatar
John Koleszar committed
480
      if (high_q) {
Paul Wilkins's avatar
Paul Wilkins committed
481
482
          vp9_enable_segfeature(xd, 0, SEG_LVL_SKIP);
          vp9_enable_segfeature(xd, 1, SEG_LVL_SKIP);
John Koleszar's avatar
John Koleszar committed
483
484
485
      }
      // Enable data udpate
      xd->update_mb_segmentation_data = 1;
486
487
488
    } else {
      // All other frames.

John Koleszar's avatar
John Koleszar committed
489
490
491
492
493
      // No updates.. leave things as they are.
      xd->update_mb_segmentation_map = 0;
      xd->update_mb_segmentation_data = 0;
    }
  }
494
495
}

496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
#if CONFIG_IMPLICIT_SEGMENTATION
static void configure_implicit_segmentation(VP9_COMP *cpi) {
  VP9_COMMON *cm = &cpi->common;
  MACROBLOCKD *xd = &cpi->mb.e_mbd;
  int i;
  int qi_delta;
  double q_target = cpi->active_worst_quality * 1.10;

  // Set the flags to allow implicit segment update but disallow explicit update
  xd->segmentation_enabled = 1;
  xd->allow_implicit_segment_update = 1;
  xd->update_mb_segmentation_map = 0;

  // For key frames clear down the segment map to a default state.
  if (cm->frame_type == KEY_FRAME) {
    // Clear down the global segmentation map
    vpx_memset(cpi->segmentation_map, 0, (cm->mb_rows * cm->mb_cols));

    // Clear down the segment features.
    vp9_clearall_segfeatures(xd);

    xd->update_mb_segmentation_data = 1;

519
520
    // Enable use of q deltas on segments 1 and up
    for (i = 1; i < MAX_MB_SEGMENTS; ++i) {
521
522
523
524
525
526
527
528
529
530
531
532
533
534
      qi_delta = compute_qdelta(cpi, cpi->active_worst_quality, q_target);
      vp9_set_segdata(xd, i, SEG_LVL_ALT_Q, qi_delta);
      q_target *= 0.95;
      vp9_enable_segfeature(xd, i, SEG_LVL_ALT_Q);
    }

    // Where relevant assume segment data is delta data
    xd->mb_segment_abs_delta = SEGMENT_DELTADATA;
  } else {
    xd->update_mb_segmentation_data = 0;
  }
}
#endif

535
// DEBUG: Print out the segment id of each MB in the current frame.
536
537
static void print_seg_map(VP9_COMP *cpi) {
  VP9_COMMON *cm = &cpi->common;
John Koleszar's avatar
John Koleszar committed
538
539
  int row, col;
  int map_index = 0;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
540
  FILE *statsfile = fopen("segmap.stt", "a");
541

Dmitry Kovalev's avatar
Dmitry Kovalev committed
542
  fprintf(statsfile, "%10d\n", cm->current_video_frame);
543

544
545
  for (row = 0; row < cpi->common.mi_rows; row++) {
    for (col = 0; col < cpi->common.mi_cols; col++) {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
546
      fprintf(statsfile, "%10d", cpi->segmentation_map[map_index]);
John Koleszar's avatar
John Koleszar committed
547
      map_index++;
548
549
    }
    fprintf(statsfile, "\n");
John Koleszar's avatar
John Koleszar committed
550
551
  }
  fprintf(statsfile, "\n");
552

John Koleszar's avatar
John Koleszar committed
553
  fclose(statsfile);
554
555
}

556
static void update_reference_segmentation_map(VP9_COMP *cpi) {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
557
558
559
560
561
  VP9_COMMON *const cm = &cpi->common;
  int row, col;
  MODE_INFO *mi, *mi_ptr = cm->mi;
  uint8_t *cache_ptr = cm->last_frame_seg_map, *cache;

562
  for (row = 0; row < cm->mi_rows; row++) {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
563
564
    mi = mi_ptr;
    cache = cache_ptr;
565
    for (col = 0; col < cm->mi_cols; col++, mi++, cache++)
Ronald S. Bultje's avatar
Ronald S. Bultje committed
566
567
      cache[0] = mi->mbmi.segment_id;
    mi_ptr += cm->mode_info_stride;
568
    cache_ptr += cm->mi_cols;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
569
570
571
  }
}

572
static void set_default_lf_deltas(VP9_COMP *cpi) {
John Koleszar's avatar
John Koleszar committed
573
574
  cpi->mb.e_mbd.mode_ref_lf_delta_enabled = 1;
  cpi->mb.e_mbd.mode_ref_lf_delta_update = 1;
John Koleszar's avatar
John Koleszar committed
575

John Koleszar's avatar
John Koleszar committed
576
577
  vpx_memset(cpi->mb.e_mbd.ref_lf_deltas, 0, sizeof(cpi->mb.e_mbd.ref_lf_deltas));
  vpx_memset(cpi->mb.e_mbd.mode_lf_deltas, 0, sizeof(cpi->mb.e_mbd.mode_lf_deltas));
John Koleszar's avatar
John Koleszar committed
578

John Koleszar's avatar
John Koleszar committed
579
580
581
582
583
  // Test of ref frame deltas
  cpi->mb.e_mbd.ref_lf_deltas[INTRA_FRAME] = 2;
  cpi->mb.e_mbd.ref_lf_deltas[LAST_FRAME] = 0;
  cpi->mb.e_mbd.ref_lf_deltas[GOLDEN_FRAME] = -2;
  cpi->mb.e_mbd.ref_lf_deltas[ALTREF_FRAME] = -2;
John Koleszar's avatar
John Koleszar committed
584

Yaowu Xu's avatar
Yaowu Xu committed
585
  cpi->mb.e_mbd.mode_lf_deltas[0] = 4;               // I4X4_PRED
John Koleszar's avatar
John Koleszar committed
586
587
588
  cpi->mb.e_mbd.mode_lf_deltas[1] = -2;              // Zero
  cpi->mb.e_mbd.mode_lf_deltas[2] = 2;               // New mv
  cpi->mb.e_mbd.mode_lf_deltas[3] = 4;               // Split mv
John Koleszar's avatar
John Koleszar committed
589
590
}

591
592
593
594
595
596
static void set_rd_speed_thresholds(VP9_COMP *cpi, int mode, int speed) {
  SPEED_FEATURES *sf = &cpi->sf;
  int speed_multiplier = speed + 1;
  int i;

  // Set baseline threshold values
597
598
  for (i = 0; i < MAX_MODES; ++i)
    sf->thresh_mult[i] = mode == 0 ? -500 : 0;
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615

  sf->thresh_mult[THR_ZEROMV   ] = 0;
  sf->thresh_mult[THR_ZEROG    ] = 0;
  sf->thresh_mult[THR_ZEROA    ] = 0;

  sf->thresh_mult[THR_NEARESTMV] = 0;
  sf->thresh_mult[THR_NEARESTG ] = 0;
  sf->thresh_mult[THR_NEARESTA ] = 0;

  sf->thresh_mult[THR_NEARMV   ] += speed_multiplier * 1000;
  sf->thresh_mult[THR_NEARG    ] += speed_multiplier * 1000;
  sf->thresh_mult[THR_NEARA    ] += speed_multiplier * 1000;

  sf->thresh_mult[THR_DC       ] = 0;
  sf->thresh_mult[THR_TM       ] += speed_multiplier * 1000;
  sf->thresh_mult[THR_V_PRED   ] += speed_multiplier * 1000;
  sf->thresh_mult[THR_H_PRED   ] += speed_multiplier * 1000;
616
617
618
619
620
621
  sf->thresh_mult[THR_D45_PRED ] += speed_multiplier * 1500;
  sf->thresh_mult[THR_D135_PRED] += speed_multiplier * 1500;
  sf->thresh_mult[THR_D117_PRED] += speed_multiplier * 1500;
  sf->thresh_mult[THR_D153_PRED] += speed_multiplier * 1500;
  sf->thresh_mult[THR_D27_PRED ] += speed_multiplier * 1500;
  sf->thresh_mult[THR_D63_PRED ] += speed_multiplier * 1500;
622
623
624
625
626
627
628
629
630
631
632

  sf->thresh_mult[THR_B_PRED   ] += speed_multiplier * 2500;

  sf->thresh_mult[THR_NEWMV    ] += speed_multiplier * 1000;
  sf->thresh_mult[THR_NEWG     ] += speed_multiplier * 1000;
  sf->thresh_mult[THR_NEWA     ] += speed_multiplier * 1000;

  sf->thresh_mult[THR_SPLITMV  ] += speed_multiplier * 2500;
  sf->thresh_mult[THR_SPLITG   ] += speed_multiplier * 2500;
  sf->thresh_mult[THR_SPLITA   ] += speed_multiplier * 2500;

633
634
635
  sf->thresh_mult[THR_COMP_ZEROLG   ] += speed_multiplier * 1500;
  sf->thresh_mult[THR_COMP_ZEROLA   ] += speed_multiplier * 1500;
  sf->thresh_mult[THR_COMP_ZEROGA   ] += speed_multiplier * 1500;
636

637
638
639
  sf->thresh_mult[THR_COMP_NEARESTLG] += speed_multiplier * 1500;
  sf->thresh_mult[THR_COMP_NEARESTLA] += speed_multiplier * 1500;
  sf->thresh_mult[THR_COMP_NEARESTGA] += speed_multiplier * 1500;
640

641
642
643
  sf->thresh_mult[THR_COMP_NEARLG   ] += speed_multiplier * 1500;
  sf->thresh_mult[THR_COMP_NEARLA   ] += speed_multiplier * 1500;
  sf->thresh_mult[THR_COMP_NEARGA   ] += speed_multiplier * 1500;
644
645
646
647
648
649
650
651
652
653

  sf->thresh_mult[THR_COMP_NEWLG    ] += speed_multiplier * 2000;
  sf->thresh_mult[THR_COMP_NEWLA    ] += speed_multiplier * 2000;
  sf->thresh_mult[THR_COMP_NEWGA    ] += speed_multiplier * 2000;

  sf->thresh_mult[THR_COMP_SPLITLA  ] += speed_multiplier * 4500;
  sf->thresh_mult[THR_COMP_SPLITGA  ] += speed_multiplier * 4500;
  sf->thresh_mult[THR_COMP_SPLITLG  ] += speed_multiplier * 4500;

#if CONFIG_COMP_INTERINTRA_PRED
654
655
656
  sf->thresh_mult[THR_COMP_INTERINTRA_ZEROL   ] += speed_multiplier * 1500;
  sf->thresh_mult[THR_COMP_INTERINTRA_ZEROG   ] += speed_multiplier * 1500;
  sf->thresh_mult[THR_COMP_INTERINTRA_ZEROA   ] += speed_multiplier * 1500;
657

658
659
660
  sf->thresh_mult[THR_COMP_INTERINTRA_NEARESTL] += speed_multiplier * 1500;
  sf->thresh_mult[THR_COMP_INTERINTRA_NEARESTG] += speed_multiplier * 1500;
  sf->thresh_mult[THR_COMP_INTERINTRA_NEARESTA] += speed_multiplier * 1500;
661

662
663
664
  sf->thresh_mult[THR_COMP_INTERINTRA_NEARL   ] += speed_multiplier * 1500;
  sf->thresh_mult[THR_COMP_INTERINTRA_NEARG   ] += speed_multiplier * 1500;
  sf->thresh_mult[THR_COMP_INTERINTRA_NEARA   ] += speed_multiplier * 1500;
665
666
667
668
669

  sf->thresh_mult[THR_COMP_INTERINTRA_NEWL    ] += speed_multiplier * 2000;
  sf->thresh_mult[THR_COMP_INTERINTRA_NEWG    ] += speed_multiplier * 2000;
  sf->thresh_mult[THR_COMP_INTERINTRA_NEWA    ] += speed_multiplier * 2000;
#endif
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
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

  /* disable frame modes if flags not set */
  if (!(cpi->ref_frame_flags & VP9_LAST_FLAG)) {
    sf->thresh_mult[THR_NEWMV    ] = INT_MAX;
    sf->thresh_mult[THR_NEARESTMV] = INT_MAX;
    sf->thresh_mult[THR_ZEROMV   ] = INT_MAX;
    sf->thresh_mult[THR_NEARMV   ] = INT_MAX;
    sf->thresh_mult[THR_SPLITMV  ] = INT_MAX;
#if CONFIG_COMP_INTERINTRA_PRED
    sf->thresh_mult[THR_COMP_INTERINTRA_ZEROL   ] = INT_MAX;
    sf->thresh_mult[THR_COMP_INTERINTRA_NEARESTL] = INT_MAX;
    sf->thresh_mult[THR_COMP_INTERINTRA_NEARL   ] = INT_MAX;
    sf->thresh_mult[THR_COMP_INTERINTRA_NEWL    ] = INT_MAX;
#endif
  }
  if (!(cpi->ref_frame_flags & VP9_GOLD_FLAG)) {
    sf->thresh_mult[THR_NEARESTG ] = INT_MAX;
    sf->thresh_mult[THR_ZEROG    ] = INT_MAX;
    sf->thresh_mult[THR_NEARG    ] = INT_MAX;
    sf->thresh_mult[THR_NEWG     ] = INT_MAX;
    sf->thresh_mult[THR_SPLITG   ] = INT_MAX;
#if CONFIG_COMP_INTERINTRA_PRED
    sf->thresh_mult[THR_COMP_INTERINTRA_ZEROG   ] = INT_MAX;
    sf->thresh_mult[THR_COMP_INTERINTRA_NEARESTG] = INT_MAX;
    sf->thresh_mult[THR_COMP_INTERINTRA_NEARG   ] = INT_MAX;
    sf->thresh_mult[THR_COMP_INTERINTRA_NEWG    ] = INT_MAX;
#endif
  }
  if (!(cpi->ref_frame_flags & VP9_ALT_FLAG)) {
    sf->thresh_mult[THR_NEARESTA ] = INT_MAX;
    sf->thresh_mult[THR_ZEROA    ] = INT_MAX;
    sf->thresh_mult[THR_NEARA    ] = INT_MAX;
    sf->thresh_mult[THR_NEWA     ] = INT_MAX;
    sf->thresh_mult[THR_SPLITA   ] = INT_MAX;
#if CONFIG_COMP_INTERINTRA_PRED
    sf->thresh_mult[THR_COMP_INTERINTRA_ZEROA   ] = INT_MAX;
    sf->thresh_mult[THR_COMP_INTERINTRA_NEARESTA] = INT_MAX;
    sf->thresh_mult[THR_COMP_INTERINTRA_NEARA   ] = INT_MAX;
    sf->thresh_mult[THR_COMP_INTERINTRA_NEWA    ] = INT_MAX;
#endif
  }

  if ((cpi->ref_frame_flags & (VP9_LAST_FLAG | VP9_GOLD_FLAG)) !=
      (VP9_LAST_FLAG | VP9_GOLD_FLAG)) {
    sf->thresh_mult[THR_COMP_ZEROLG   ] = INT_MAX;
    sf->thresh_mult[THR_COMP_NEARESTLG] = INT_MAX;
    sf->thresh_mult[THR_COMP_NEARLG   ] = INT_MAX;
    sf->thresh_mult[THR_COMP_NEWLG    ] = INT_MAX;
    sf->thresh_mult[THR_COMP_SPLITLG  ] = INT_MAX;
  }
  if ((cpi->ref_frame_flags & (VP9_LAST_FLAG | VP9_ALT_FLAG)) !=
      (VP9_LAST_FLAG | VP9_ALT_FLAG)) {
    sf->thresh_mult[THR_COMP_ZEROLA   ] = INT_MAX;
    sf->thresh_mult[THR_COMP_NEARESTLA] = INT_MAX;
    sf->thresh_mult[THR_COMP_NEARLA   ] = INT_MAX;
    sf->thresh_mult[THR_COMP_NEWLA    ] = INT_MAX;
    sf->thresh_mult[THR_COMP_SPLITLA  ] = INT_MAX;
  }
  if ((cpi->ref_frame_flags & (VP9_GOLD_FLAG | VP9_ALT_FLAG)) !=
      (VP9_GOLD_FLAG | VP9_ALT_FLAG)) {
    sf->thresh_mult[THR_COMP_ZEROGA   ] = INT_MAX;
    sf->thresh_mult[THR_COMP_NEARESTGA] = INT_MAX;
    sf->thresh_mult[THR_COMP_NEARGA   ] = INT_MAX;
    sf->thresh_mult[THR_COMP_NEWGA    ] = INT_MAX;
    sf->thresh_mult[THR_COMP_SPLITGA  ] = INT_MAX;
  }
736
737
}

738
void vp9_set_speed_features(VP9_COMP *cpi) {
John Koleszar's avatar
John Koleszar committed
739
  SPEED_FEATURES *sf = &cpi->sf;
740
741
  int mode = cpi->compressor_speed;
  int speed = cpi->Speed;
John Koleszar's avatar
John Koleszar committed
742
743
744
  int i;

  // Only modes 0 and 1 supported for now in experimental code basae
745
746
  if (mode > 1)
    mode = 1;
John Koleszar's avatar
John Koleszar committed
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762

  // Initialise default mode frequency sampling variables
  for (i = 0; i < MAX_MODES; i ++) {
    cpi->mode_check_freq[i] = 0;
    cpi->mode_test_hit_counts[i] = 0;
    cpi->mode_chosen_counts[i] = 0;
  }

  // best quality defaults
  sf->RD = 1;
  sf->search_method = NSTEP;
  sf->auto_filter = 1;
  sf->recode_loop = 1;
  sf->quarter_pixel_search = 1;
  sf->half_pixel_search = 1;
  sf->iterative_sub_pixel = 1;
Yaowu Xu's avatar
Yaowu Xu committed
763
  sf->no_skip_block4x4_search = 1;
764
  sf->optimize_coefficients = !cpi->oxcf.lossless;
John Koleszar's avatar
John Koleszar committed
765
766
  sf->first_step = 0;
  sf->max_step_search_steps = MAX_MVSEARCH_STEPS;
767
768
769
#if CONFIG_MULTIPLE_ARF
  // Switch segmentation off.
  sf->static_segmentation = 0;
770
771
772
#else
#if CONFIG_IMPLICIT_SEGMENTATION
  sf->static_segmentation = 0;
773
#else
774
  sf->static_segmentation = 1;
775
#endif
776
#endif
777
778
  sf->splitmode_breakout = 0;
  sf->mb16_breakout = 0;
John Koleszar's avatar
John Koleszar committed
779

780
  switch (mode) {
John Koleszar's avatar
John Koleszar committed
781
    case 0: // best quality mode
John Koleszar's avatar
John Koleszar committed
782
783
784
      sf->search_best_filter = SEARCH_BEST_FILTER;
      break;

785
    case 1:
786
787
788
789
#if CONFIG_MULTIPLE_ARF
      // Switch segmentation off.
      sf->static_segmentation = 0;
#else
790
791
792
793
794
#if CONFIG_IMPLICIT_SEGMENTATION
  sf->static_segmentation = 0;
#else
  sf->static_segmentation = 1;
#endif
795
#endif
796
797
798
      sf->splitmode_breakout = 1;
      sf->mb16_breakout = 0;

799
      if (speed > 0) {
John Koleszar's avatar
John Koleszar committed
800
801
802
        /* Disable coefficient optimization above speed 0 */
        sf->optimize_coefficients = 0;
        sf->no_skip_block4x4_search = 0;
803

John Koleszar's avatar
John Koleszar committed
804
        sf->first_step = 1;
805

John Koleszar's avatar
John Koleszar committed
806
807
808
        cpi->mode_check_freq[THR_SPLITG] = 2;
        cpi->mode_check_freq[THR_SPLITA] = 2;
        cpi->mode_check_freq[THR_SPLITMV] = 0;
809

John Koleszar's avatar
John Koleszar committed
810
811
812
813
        cpi->mode_check_freq[THR_COMP_SPLITGA] = 2;
        cpi->mode_check_freq[THR_COMP_SPLITLG] = 2;
        cpi->mode_check_freq[THR_COMP_SPLITLA] = 0;
      }
John Koleszar's avatar
John Koleszar committed
814

815
      if (speed > 1) {
John Koleszar's avatar
John Koleszar committed
816
817
818
        cpi->mode_check_freq[THR_SPLITG] = 4;
        cpi->mode_check_freq[THR_SPLITA] = 4;
        cpi->mode_check_freq[THR_SPLITMV] = 2;
John Koleszar's avatar
John Koleszar committed
819

John Koleszar's avatar
John Koleszar committed
820
821
822
823
824
        cpi->mode_check_freq[THR_COMP_SPLITGA] = 4;
        cpi->mode_check_freq[THR_COMP_SPLITLG] = 4;
        cpi->mode_check_freq[THR_COMP_SPLITLA] = 2;
      }

825
      if (speed > 2) {
John Koleszar's avatar
John Koleszar committed
826
827
828
829
830
831
832
833
834
835
836
837
        cpi->mode_check_freq[THR_SPLITG] = 15;
        cpi->mode_check_freq[THR_SPLITA] = 15;
        cpi->mode_check_freq[THR_SPLITMV] = 7;

        cpi->mode_check_freq[THR_COMP_SPLITGA] = 15;
        cpi->mode_check_freq[THR_COMP_SPLITLG] = 15;
        cpi->mode_check_freq[THR_COMP_SPLITLA] = 7;

        // Only do recode loop on key frames, golden frames and
        // alt ref frames
        sf->recode_loop = 2;
      }
John Koleszar's avatar
John Koleszar committed
838

John Koleszar's avatar
John Koleszar committed
839
      break;
John Koleszar's avatar
John Koleszar committed
840

John Koleszar's avatar
John Koleszar committed
841
  }; /* switch */
842

843
844
  // Set rd thresholds based on mode and speed setting
  set_rd_speed_thresholds(cpi, mode, speed);
John Koleszar's avatar
John Koleszar committed
845
846
847
848
849
850

  // Slow quant, dct and trellis not worthwhile for first pass
  // so make sure they are always turned off.
  if (cpi->pass == 1) {
    sf->optimize_coefficients = 0;
  }
851

Yaowu Xu's avatar
Yaowu Xu committed
852
853
854
855
  cpi->mb.fwd_txm16x16  = vp9_short_fdct16x16;
  cpi->mb.fwd_txm8x8    = vp9_short_fdct8x8;
  cpi->mb.fwd_txm8x4    = vp9_short_fdct8x4;
  cpi->mb.fwd_txm4x4    = vp9_short_fdct4x4;
Yaowu Xu's avatar
Yaowu Xu committed
856
  if (cpi->oxcf.lossless || cpi->mb.e_mbd.lossless) {
Yaowu Xu's avatar
Yaowu Xu committed
857
858
    cpi->mb.fwd_txm8x4    = vp9_short_walsh8x4;
    cpi->mb.fwd_txm4x4    = vp9_short_walsh4x4;
John Koleszar's avatar
John Koleszar committed
859
  }
John Koleszar's avatar
John Koleszar committed
860

861
  cpi->mb.quantize_b_4x4      = vp9_regular_quantize_b_4x4;
Paul Wilkins's avatar
Paul Wilkins committed
862

863
  vp9_init_quantizer(cpi);
John Koleszar's avatar
John Koleszar committed
864

John Koleszar's avatar
John Koleszar committed
865
  if (cpi->sf.iterative_sub_pixel == 1) {
866
    cpi->find_fractional_mv_step = vp9_find_best_sub_pixel_step_iteratively;
John Koleszar's avatar
John Koleszar committed
867
  } else if (cpi->sf.quarter_pixel_search) {
868
    cpi->find_fractional_mv_step = vp9_find_best_sub_pixel_step;
John Koleszar's avatar
John Koleszar committed
869
  } else if (cpi->sf.half_pixel_search) {
870
    cpi->find_fractional_mv_step = vp9_find_best_half_pixel_step;
John Koleszar's avatar
John Koleszar committed
871
  }
John Koleszar's avatar
John Koleszar committed
872

873
  cpi->mb.optimize = cpi->sf.optimize_coefficients == 1 && cpi->pass != 1;
John Koleszar's avatar
John Koleszar committed
874
875

#ifdef SPEEDSTATS
John Koleszar's avatar
John Koleszar committed
876
  frames_at_speed[cpi->Speed]++;
John Koleszar's avatar
John Koleszar committed
877
878
#endif
}
879

880
static void alloc_raw_frame_buffers(VP9_COMP *cpi) {
881
  cpi->lookahead = vp9_lookahead_init(cpi->oxcf.width, cpi->oxcf.height,
John Koleszar's avatar
John Koleszar committed
882
883
884
885
                                      cpi->oxcf.lag_in_frames);
  if (!cpi->lookahead)
    vpx_internal_error(&cpi->common.error, VPX_CODEC_MEM_ERROR,
                       "Failed to allocate lag buffers");
John Koleszar's avatar
John Koleszar committed
886

John Koleszar's avatar
John Koleszar committed
887
  if (vp8_yv12_alloc_frame_buffer(&cpi->alt_ref_buffer,
888
                                  cpi->oxcf.width, cpi->oxcf.height,
John Koleszar's avatar
John Koleszar committed
889
                                  VP9BORDERINPIXELS))
John Koleszar's avatar
John Koleszar committed
890
891
    vpx_internal_error(&cpi->common.error, VPX_CODEC_MEM_ERROR,
                       "Failed to allocate altref buffer");
John Koleszar's avatar
John Koleszar committed
892
}
893

894
static int alloc_partition_data(VP9_COMP *cpi) {
John Koleszar's avatar
John Koleszar committed
895
  vpx_free(cpi->mb.pip);
896

897
  cpi->mb.pip = vpx_calloc((cpi->common.mode_info_stride) *
898
                           (cpi->common.mi_rows + 1),
John Koleszar's avatar
John Koleszar committed
899
900
901
                           sizeof(PARTITION_INFO));
  if (!cpi->mb.pip)
    return 1;
902

John Koleszar's avatar
John Koleszar committed
903
  cpi->mb.pi = cpi->mb.pip + cpi->common.mode_info_stride + 1;
904

John Koleszar's avatar
John Koleszar committed
905
  return 0;
906
907
}

908
909
void vp9_alloc_compressor_data(VP9_COMP *cpi) {
  VP9_COMMON *cm = &cpi->common;
John Koleszar's avatar
John Koleszar committed
910

911
  if (vp9_alloc_frame_buffers(cm, cm->width, cm->height))
John Koleszar's avatar
John Koleszar committed
912
913
    vpx_internal_error(&cpi->common.error, VPX_CODEC_MEM_ERROR,
                       "Failed to allocate frame buffers");
John Koleszar's avatar
John Koleszar committed
914

915
  if (alloc_partition_data(cpi))
John Koleszar's avatar
John Koleszar committed
916
917
    vpx_internal_error(&cpi->common.error, VPX_CODEC_MEM_ERROR,
                       "Failed to allocate partition data");
918

John Koleszar's avatar
John Koleszar committed
919
  if (vp8_yv12_alloc_frame_buffer(&cpi->last_frame_uf,
920
                                  cm->width, cm->height, VP9BORDERINPIXELS))
John Koleszar's avatar
John Koleszar committed
921
922
    vpx_internal_error(&cpi->common.error, VPX_CODEC_MEM_ERROR,
                       "Failed to allocate last frame buffer");
John Koleszar's avatar
John Koleszar committed
923

John Koleszar's avatar
John Koleszar committed
924
  if (vp8_yv12_alloc_frame_buffer(&cpi->scaled_source,
925
                                  cm->width, cm->height, VP9BORDERINPIXELS))
John Koleszar's avatar
John Koleszar committed
926
927
    vpx_internal_error(&cpi->common.error, VPX_CODEC_MEM_ERROR,
                       "Failed to allocate scaled source buffer");
John Koleszar's avatar
John Koleszar committed
928

John Koleszar's avatar
John Koleszar committed
929
  vpx_free(cpi->tok);
John Koleszar's avatar
John Koleszar committed
930

John Koleszar's avatar
John Koleszar committed
931
  {
932
    unsigned int tokens = get_token_alloc(cm->mb_rows, cm->mb_cols);
John Koleszar's avatar
John Koleszar committed
933

John Koleszar's avatar
John Koleszar committed
934
935
    CHECK_MEM_ERROR(cpi->tok, vpx_calloc(tokens, sizeof(*cpi->tok)));
  }
John Koleszar's avatar
John Koleszar committed
936

John Koleszar's avatar
John Koleszar committed
937
938
939
940
  // Data used for real time vc mode to see if gf needs refreshing
  cpi->inter_zz_count = 0;
  cpi->gf_bad_count = 0;
  cpi->gf_update_recommended = 0;
941

John Koleszar's avatar
John Koleszar committed
942
943
944
945
  vpx_free(cpi->mb_activity_map);
  CHECK_MEM_ERROR(cpi->mb_activity_map,
                  vpx_calloc(sizeof(unsigned int),
                             cm->mb_rows * cm->mb_cols));
946

John Koleszar's avatar
John Koleszar committed
947
948
949
950
  vpx_free(cpi->mb_norm_activity_map);
  CHECK_MEM_ERROR(cpi->mb_norm_activity_map,
                  vpx_calloc(sizeof(unsigned int),
                             cm->mb_rows * cm->mb_cols));
John Koleszar's avatar
John Koleszar committed
951
952
953
}


954
955
956
static void update_frame_size(VP9_COMP *cpi) {
  VP9_COMMON *cm = &cpi->common;

957
  vp9_update_frame_size(cm);
958

959
  // Update size of buffers local to this frame
960
  if (vp8_yv12_realloc_frame_buffer(&cpi->last_frame_uf,
961
                                    cm->width, cm->height, VP9BORDERINPIXELS))
962
963
964
965
    vpx_internal_error(&cpi->common.error, VPX_CODEC_MEM_ERROR,
                       "Failed to reallocate last frame buffer");

  if (vp8_yv12_realloc_frame_buffer(&cpi->scaled_source,
966
                                    cm->width, cm->height, VP9BORDERINPIXELS))
967
968
    vpx_internal_error(&cpi->common.error, VPX_CODEC_MEM_ERROR,
                       "Failed to reallocate scaled source buffer");
969
970
971
972
973
974
975
976
977
978

  {
    int y_stride = cpi->scaled_source.y_stride;

    if (cpi->sf.search_method == NSTEP) {
      vp9_init3smotion_compensation(&cpi->mb, y_stride);
    } else if (cpi->sf.search_method == DIAMOND) {
      vp9_init_dsmotion_compensation(&cpi->mb, y_stride);
    }
  }
979
980
981
}


Paul Wilkins's avatar
Paul Wilkins committed
982
983
984
985
986
987
// TODO perhaps change number of steps expose to outside world when setting
// max and min limits. Also this will likely want refining for the extended Q
// range.
//
// Table that converts 0-63 Q range values passed in outside to the Qindex
// range used internally.
John Koleszar's avatar
John Koleszar committed
988
989
990
991
992
993
994
995
996
static const int q_trans[] = {
  0,    4,   8,  12,  16,  20,  24,  28,