vp9_onyx_if.c 133 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

John Koleszar's avatar
John Koleszar committed
116
117
118
119
#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

120
121
122
#if defined(SECTIONBITS_OUTPUT)
extern unsigned __int64 Sectionbits[500];
#endif
John Koleszar's avatar
John Koleszar committed
123
#ifdef MODE_STATS
John Koleszar's avatar
John Koleszar committed
124
extern int64_t Sectionbits[500];
125
126
127
128
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];
129
extern unsigned int b_modes[B_MODE_COUNT];
John Koleszar's avatar
John Koleszar committed
130
extern unsigned int inter_y_modes[MB_MODE_COUNT];
131
extern unsigned int inter_uv_modes[VP9_UV_MODES];
132
extern unsigned int inter_b_modes[B_MODE_COUNT];
John Koleszar's avatar
John Koleszar committed
133
134
#endif

135
extern void vp9_init_quantizer(VP9_COMP *cpi);
Paul Wilkins's avatar
Paul Wilkins committed
136

137
static int base_skip_false_prob[QINDEX_RANGE][3];
138

139
// Tables relating active max Q to active min Q
140
141
142
143
144
145
146
147
148
149
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))
150
static int calculate_minq_index(double maxq,
Dmitry Kovalev's avatar
Dmitry Kovalev committed
151
                                double x3, double x2, double x1, double c) {
John Koleszar's avatar
John Koleszar committed
152
  int i;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
153
154
  const double minqtarget = MIN(((x3 * maxq + x2) * maxq + x1) * maxq + c,
                                maxq);
John Koleszar's avatar
John Koleszar committed
155

Paul Wilkins's avatar
Paul Wilkins committed
156
157
158
159
160
  // 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
161
  for (i = 0; i < QINDEX_RANGE; i++) {
162
    if (minqtarget <= vp9_convert_qindex_to_q(i))
John Koleszar's avatar
John Koleszar committed
163
164
      return i;
  }
Dmitry Kovalev's avatar
Dmitry Kovalev committed
165

John Koleszar's avatar
John Koleszar committed
166
  return QINDEX_RANGE - 1;
167
}
168

169
static void init_minq_luts(void) {
John Koleszar's avatar
John Koleszar committed
170
171
172
  int i;

  for (i = 0; i < QINDEX_RANGE; i++) {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
173
    const double maxq = vp9_convert_qindex_to_q(i);
John Koleszar's avatar
John Koleszar committed
174
175
176


    kf_low_motion_minq[i] = calculate_minq_index(maxq,
177
178
179
                                                 0.000001,
                                                 -0.0004,
                                                 0.15,
John Koleszar's avatar
John Koleszar committed
180
181
                                                 0.0);
    kf_high_motion_minq[i] = calculate_minq_index(maxq,
182
183
184
                                                  0.000002,
                                                  -0.0012,
                                                  0.5,
John Koleszar's avatar
John Koleszar committed
185
                                                  0.0);
186

John Koleszar's avatar
John Koleszar committed
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
    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);

  }
204
}
205

206
207
208
209
210
211
212
213
214
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;
  }
}
215
static void init_base_skip_probs(void) {
John Koleszar's avatar
John Koleszar committed
216
  int i;
Paul Wilkins's avatar
Paul Wilkins committed
217

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

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

225
226
227
    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
228
  }
Paul Wilkins's avatar
Paul Wilkins committed
229
}
230

231
232
static void update_base_skip_probs(VP9_COMP *cpi) {
  VP9_COMMON *cm = &cpi->common;
233
  int k;
Paul Wilkins's avatar
Paul Wilkins committed
234

John Koleszar's avatar
John Koleszar committed
235
  if (cm->frame_type != KEY_FRAME) {
236
    vp9_update_skip_probs(cpi);
Paul Wilkins's avatar
Paul Wilkins committed
237

238
    if (cpi->refresh_alt_ref_frame) {
John Koleszar's avatar
John Koleszar committed
239
240
241
      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;
242
    } else if (cpi->refresh_golden_frame) {
John Koleszar's avatar
John Koleszar committed
243
244
245
246
247
248
249
      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
250

John Koleszar's avatar
John Koleszar committed
251
252
253
      // update the baseline table for the current q
      for (k = 0; k < MBSKIP_CONTEXTS; ++k)
        cpi->base_skip_false_prob[cm->base_qindex][k] =
254
            cm->mbskip_pred_probs[k];
Paul Wilkins's avatar
Paul Wilkins committed
255
    }
John Koleszar's avatar
John Koleszar committed
256
  }
Paul Wilkins's avatar
Paul Wilkins committed
257
}
Paul Wilkins's avatar
Paul Wilkins committed
258

259
void vp9_initialize_enc() {
John Koleszar's avatar
John Koleszar committed
260
261
262
  static int init_done = 0;

  if (!init_done) {
263
    vp9_initialize_common();
264
    vp9_tokenize_initialize();
265
    vp9_init_quant_tables();
266
    vp9_init_me_luts();
John Koleszar's avatar
John Koleszar committed
267
268
269
270
    init_minq_luts();
    init_base_skip_probs();
    init_done = 1;
  }
John Koleszar's avatar
John Koleszar committed
271
272
273
274
275
}
#ifdef PACKET_TESTING
extern FILE *vpxlogc;
#endif

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

John Koleszar's avatar
John Koleszar committed
279
  // Set up default state for MB feature flags
280
  xd->segmentation_enabled = 0;
281

John Koleszar's avatar
John Koleszar committed
282
283
  xd->update_mb_segmentation_map = 0;
  xd->update_mb_segmentation_data = 0;
284
285
286
#if CONFIG_IMPLICIT_SEGMENTATION
  xd->allow_implicit_segment_update = 0;
#endif
John Koleszar's avatar
John Koleszar committed
287
  vpx_memset(xd->mb_segment_tree_probs, 255, sizeof(xd->mb_segment_tree_probs));
Paul Wilkins's avatar
Paul Wilkins committed
288

289
  vp9_clearall_segfeatures(xd);
Paul Wilkins's avatar
Paul Wilkins committed
290

John Koleszar's avatar
John Koleszar committed
291
292
293
294
295
296
  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
297

John Koleszar's avatar
John Koleszar committed
298
  set_default_lf_deltas(cpi);
John Koleszar's avatar
John Koleszar committed
299
300
301
}


302
static void dealloc_compressor_data(VP9_COMP *cpi) {
John Koleszar's avatar
John Koleszar committed
303
304
305
306
307
308
309
  // 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
310

John Koleszar's avatar
John Koleszar committed
311
312
  vpx_free(cpi->active_map);
  cpi->active_map = 0;
John Koleszar's avatar
John Koleszar committed
313

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

316
317
318
  vp9_free_frame_buffer(&cpi->last_frame_uf);
  vp9_free_frame_buffer(&cpi->scaled_source);
  vp9_free_frame_buffer(&cpi->alt_ref_buffer);
319
  vp9_lookahead_destroy(cpi->lookahead);
John Koleszar's avatar
John Koleszar committed
320

John Koleszar's avatar
John Koleszar committed
321
322
  vpx_free(cpi->tok);
  cpi->tok = 0;
John Koleszar's avatar
John Koleszar committed
323

John Koleszar's avatar
John Koleszar committed
324
325
326
327
328
  // 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;
329

John Koleszar's avatar
John Koleszar committed
330
331
  vpx_free(cpi->mb.pip);
  cpi->mb.pip = 0;
John Koleszar's avatar
John Koleszar committed
332
333
}

334
335
336
// Computes a q delta (in "q index" terms) to get from a starting q value
// to a target value
// target q value
337
static int compute_qdelta(VP9_COMP *cpi, double qstart, double qtarget) {
John Koleszar's avatar
John Koleszar committed
338
339
340
341
342
343
344
  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;
345
    if (vp9_convert_qindex_to_q(i) >= qstart)
John Koleszar's avatar
John Koleszar committed
346
347
348
349
350
351
      break;
  }

  // Convert the q target to an index
  for (i = cpi->best_quality; i < cpi->worst_quality; i++) {
    target_index = i;
352
    if (vp9_convert_qindex_to_q(i) >= qtarget)
John Koleszar's avatar
John Koleszar committed
353
354
355
356
      break;
  }

  return target_index - start_index;
357
358
}

359
static void configure_static_seg_features(VP9_COMP *cpi) {
360
  VP9_COMMON *cm = &cpi->common;
John Koleszar's avatar
John Koleszar committed
361
  MACROBLOCKD *xd = &cpi->mb.e_mbd;
362

John Koleszar's avatar
John Koleszar committed
363
364
  int high_q = (int)(cpi->avg_q > 48.0);
  int qi_delta;
365

John Koleszar's avatar
John Koleszar committed
366
367
368
  // Disable and clear down for KF
  if (cm->frame_type == KEY_FRAME) {
    // Clear down the global segmentation map
369
    vpx_memset(cpi->segmentation_map, 0, cm->mi_rows * cm->mi_cols);
John Koleszar's avatar
John Koleszar committed
370
371
    xd->update_mb_segmentation_map = 0;
    xd->update_mb_segmentation_data = 0;
372
#if CONFIG_IMPLICIT_SEGMENTATION
373
    xd->allow_implicit_segment_update = 0;
374
#endif
John Koleszar's avatar
John Koleszar committed
375
    cpi->static_mb_pct = 0;
376

John Koleszar's avatar
John Koleszar committed
377
    // Disable segmentation
378
    vp9_disable_segmentation((VP9_PTR)cpi);
Paul Wilkins's avatar
Paul Wilkins committed
379

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

John Koleszar's avatar
John Koleszar committed
393
    // Disable segmentation and individual segment features by default
394
    vp9_disable_segmentation((VP9_PTR)cpi);
395
    vp9_clearall_segfeatures(xd);
Paul Wilkins's avatar
Paul Wilkins committed
396

John Koleszar's avatar
John Koleszar committed
397
398
    // Scan frames from current to arf frame.
    // This function re-enables segmentation if appropriate.
399
    vp9_update_mbgraph_stats(cpi);
Paul Wilkins's avatar
Paul Wilkins committed
400

John Koleszar's avatar
John Koleszar committed
401
402
403
404
405
    // 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
406

John Koleszar's avatar
John Koleszar committed
407
      qi_delta = compute_qdelta(cpi, cpi->avg_q, (cpi->avg_q * 0.875));
408
409
      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
410

411
412
      vp9_enable_segfeature(xd, 1, SEG_LVL_ALT_Q);
      vp9_enable_segfeature(xd, 1, SEG_LVL_ALT_LF);
413

John Koleszar's avatar
John Koleszar committed
414
415
      // Where relevant assume segment data is delta data
      xd->mb_segment_abs_delta = SEGMENT_DELTADATA;
Paul Wilkins's avatar
Paul Wilkins committed
416

417
    }
418
419
420
  } else if (xd->segmentation_enabled) {
    // All other frames if segmentation has been enabled

John Koleszar's avatar
John Koleszar committed
421
422
    // 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
423
      // Set up segment features for normal frames in an arf group
John Koleszar's avatar
John Koleszar committed
424
425
426
427
      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
428

John Koleszar's avatar
John Koleszar committed
429
430
        qi_delta = compute_qdelta(cpi, cpi->avg_q,
                                  (cpi->avg_q * 1.125));
431
432
433
        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
434

435
436
        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
437

John Koleszar's avatar
John Koleszar committed
438
439
        // Segment coding disabled for compred testing
        if (high_q || (cpi->static_mb_pct == 100)) {
440
441
          vp9_set_segref(xd, 1, ALTREF_FRAME);
          vp9_enable_segfeature(xd, 1, SEG_LVL_REF_FRAME);
Paul Wilkins's avatar
Paul Wilkins committed
442
          vp9_enable_segfeature(xd, 1, SEG_LVL_SKIP);
John Koleszar's avatar
John Koleszar committed
443
        }
444
445
446
447
      } else {
        // Disable segmentation and clear down features if alt ref
        // is not active for this group

448
        vp9_disable_segmentation((VP9_PTR)cpi);
Paul Wilkins's avatar
Paul Wilkins committed
449

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

John Koleszar's avatar
John Koleszar committed
452
453
        xd->update_mb_segmentation_map = 0;
        xd->update_mb_segmentation_data = 0;
Paul Wilkins's avatar
Paul Wilkins committed
454

455
        vp9_clearall_segfeatures(xd);
John Koleszar's avatar
John Koleszar committed
456
      }
457
458
459
460
    } 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
461

Paul Wilkins's avatar
Paul Wilkins committed
462
      // Enable ref frame features for segment 0 as well
463
464
      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
465

Paul Wilkins's avatar
Paul Wilkins committed
466
      // All mbs should use ALTREF_FRAME
467
468
469
470
      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
471

Paul Wilkins's avatar
Paul Wilkins committed
472
      // Skip all MBs if high Q (0,0 mv and skip coeffs)
John Koleszar's avatar
John Koleszar committed
473
      if (high_q) {
Paul Wilkins's avatar
Paul Wilkins committed
474
475
          vp9_enable_segfeature(xd, 0, SEG_LVL_SKIP);
          vp9_enable_segfeature(xd, 1, SEG_LVL_SKIP);
John Koleszar's avatar
John Koleszar committed
476
477
478
      }
      // Enable data udpate
      xd->update_mb_segmentation_data = 1;
479
480
481
    } else {
      // All other frames.

John Koleszar's avatar
John Koleszar committed
482
483
484
485
486
      // No updates.. leave things as they are.
      xd->update_mb_segmentation_map = 0;
      xd->update_mb_segmentation_data = 0;
    }
  }
487
488
}

489
#if CONFIG_IMPLICIT_SEGMENTATION
490
491
492
static double implict_seg_q_modifiers[MAX_MB_SEGMENTS] =
  {1.0, 0.95, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0};
static void configure_implicit_segmentation(VP9_COMP *cpi, int frame_qindex) {
493
494
495
496
  VP9_COMMON *cm = &cpi->common;
  MACROBLOCKD *xd = &cpi->mb.e_mbd;
  int i;
  int qi_delta;
497
  double q_baseline = vp9_convert_qindex_to_q(frame_qindex);
498
499
500
501
502
503
504
505
506
507
508
509
510
511

  // 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);

512
513
514
515
516
    xd->update_mb_segmentation_data = 0;

  // Update the segment data if it is an arf or non overlay gf.
  } else if (cpi->refresh_alt_ref_frame ||
             (cpi->refresh_golden_frame && !cpi->is_src_frame_alt_ref)) {
517
518
    xd->update_mb_segmentation_data = 1;

519
    // Enable use of q deltas on segments 1 and up
520
    // Segment 0 is treated as a neutral segment with no changes
521
    for (i = 1; i < MAX_MB_SEGMENTS; ++i) {
522
523
      qi_delta = compute_qdelta(cpi, q_baseline,
                                implict_seg_q_modifiers[i] * q_baseline);
524
525
526
527
528
529
530
531
532
533
534
535
      vp9_set_segdata(xd, i, SEG_LVL_ALT_Q, qi_delta);
      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

Paul Wilkins's avatar
Paul Wilkins committed
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
#ifdef ENTROPY_STATS
void vp9_update_mode_context_stats(VP9_COMP *cpi) {
  VP9_COMMON *cm = &cpi->common;
  int i, j;
  unsigned int (*mv_ref_ct)[4][2] = cm->fc.mv_ref_ct;
  int64_t (*mv_ref_stats)[4][2] = cpi->mv_ref_stats;
  FILE *f;

  // Read the past stats counters
  f = fopen("mode_context.bin",  "rb");
  if (!f) {
    vpx_memset(cpi->mv_ref_stats, 0, sizeof(cpi->mv_ref_stats));
  } else {
    fread(cpi->mv_ref_stats, sizeof(cpi->mv_ref_stats), 1, f);
    fclose(f);
  }

  // Add in the values for this frame
  for (i = 0; i < INTER_MODE_CONTEXTS; i++) {
    for (j = 0; j < 4; j++) {
      mv_ref_stats[i][j][0] += (int64_t)mv_ref_ct[i][j][0];
      mv_ref_stats[i][j][1] += (int64_t)mv_ref_ct[i][j][1];
    }
  }

  // Write back the accumulated stats
  f = fopen("mode_context.bin",  "wb");
  fwrite(cpi->mv_ref_stats, sizeof(cpi->mv_ref_stats), 1, f);
  fclose(f);
}

void print_mode_context(VP9_COMP *cpi) {
  FILE *f = fopen("vp9_modecont.c", "a");
  int i, j;

  fprintf(f, "#include \"vp9_entropy.h\"\n");
  fprintf(f, "const int vp9_mode_contexts[INTER_MODE_CONTEXTS][4] =");
  fprintf(f, "{\n");
  for (j = 0; j < INTER_MODE_CONTEXTS; j++) {
    fprintf(f, "  {/* %d */ ", j);
    fprintf(f, "    ");
    for (i = 0; i < 4; i++) {
      int this_prob;
      int64_t count = cpi->mv_ref_stats[j][i][0] + cpi->mv_ref_stats[j][i][1];
      if (count)
        this_prob = ((cpi->mv_ref_stats[j][i][0] * 256) + (count >> 1)) / count;
      else
        this_prob = 128;

      // context probs
      fprintf(f, "%5d, ", this_prob);
    }
    fprintf(f, "  },\n");
  }

  fprintf(f, "};\n");
  fclose(f);
}
#endif  // ENTROPY_STATS

596
// DEBUG: Print out the segment id of each MB in the current frame.
597
598
static void print_seg_map(VP9_COMP *cpi) {
  VP9_COMMON *cm = &cpi->common;
John Koleszar's avatar
John Koleszar committed
599
600
  int row, col;
  int map_index = 0;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
601
  FILE *statsfile = fopen("segmap.stt", "a");
602

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

605
606
  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
607
      fprintf(statsfile, "%10d", cpi->segmentation_map[map_index]);
John Koleszar's avatar
John Koleszar committed
608
      map_index++;
609
610
    }
    fprintf(statsfile, "\n");
John Koleszar's avatar
John Koleszar committed
611
612
  }
  fprintf(statsfile, "\n");
613

John Koleszar's avatar
John Koleszar committed
614
  fclose(statsfile);
615
616
}

617
static void update_reference_segmentation_map(VP9_COMP *cpi) {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
618
619
620
621
622
  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;

623
  for (row = 0; row < cm->mi_rows; row++) {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
624
625
    mi = mi_ptr;
    cache = cache_ptr;
626
    for (col = 0; col < cm->mi_cols; col++, mi++, cache++)
Ronald S. Bultje's avatar
Ronald S. Bultje committed
627
628
      cache[0] = mi->mbmi.segment_id;
    mi_ptr += cm->mode_info_stride;
629
    cache_ptr += cm->mi_cols;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
630
631
632
  }
}

633
static void set_default_lf_deltas(VP9_COMP *cpi) {
John Koleszar's avatar
John Koleszar committed
634
635
  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
636

John Koleszar's avatar
John Koleszar committed
637
638
  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
639

John Koleszar's avatar
John Koleszar committed
640
641
642
643
644
  // 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
645

Yaowu Xu's avatar
Yaowu Xu committed
646
  cpi->mb.e_mbd.mode_lf_deltas[0] = 4;               // I4X4_PRED
John Koleszar's avatar
John Koleszar committed
647
648
649
  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
650
651
}

652
653
654
655
656
657
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
658
659
  for (i = 0; i < MAX_MODES; ++i)
    sf->thresh_mult[i] = mode == 0 ? -500 : 0;
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676

  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;
677
678
679
680
681
682
  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;
683
684
685
686
687
688
689
690
691
692
693

  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;

694
695
696
  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;
697

698
699
700
  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;
701

702
703
704
  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;
705
706
707
708
709
710
711
712
713

  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;

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
  /* 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 (!(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 (!(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 ((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;
  }
761
762
}

763
void vp9_set_speed_features(VP9_COMP *cpi) {
John Koleszar's avatar
John Koleszar committed
764
  SPEED_FEATURES *sf = &cpi->sf;
765
  int mode = cpi->compressor_speed;
766
  int speed = cpi->speed;
John Koleszar's avatar
John Koleszar committed
767
768
769
  int i;

  // Only modes 0 and 1 supported for now in experimental code basae
770
771
  if (mode > 1)
    mode = 1;
John Koleszar's avatar
John Koleszar committed
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787

  // 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
788
  sf->no_skip_block4x4_search = 1;
789
  sf->optimize_coefficients = !cpi->oxcf.lossless;
John Koleszar's avatar
John Koleszar committed
790
791
  sf->first_step = 0;
  sf->max_step_search_steps = MAX_MVSEARCH_STEPS;
792
793
794
#if CONFIG_MULTIPLE_ARF
  // Switch segmentation off.
  sf->static_segmentation = 0;
795
796
797
#else
#if CONFIG_IMPLICIT_SEGMENTATION
  sf->static_segmentation = 0;
798
#else
799
  sf->static_segmentation = 0;
800
#endif
801
#endif
802
803
  sf->splitmode_breakout = 0;
  sf->mb16_breakout = 0;
John Koleszar's avatar
John Koleszar committed
804

805
  switch (mode) {
John Koleszar's avatar
John Koleszar committed
806
    case 0: // best quality mode
John Koleszar's avatar
John Koleszar committed
807
808
809
      sf->search_best_filter = SEARCH_BEST_FILTER;
      break;

810
    case 1:
811
812
813
814
#if CONFIG_MULTIPLE_ARF
      // Switch segmentation off.
      sf->static_segmentation = 0;
#else
815
816
817
#if CONFIG_IMPLICIT_SEGMENTATION
  sf->static_segmentation = 0;
#else
818
  sf->static_segmentation = 0;
819
#endif
820
#endif
821
822
823
      sf->splitmode_breakout = 1;
      sf->mb16_breakout = 0;

824
      if (speed > 0) {
John Koleszar's avatar
John Koleszar committed
825
826
827
        /* Disable coefficient optimization above speed 0 */
        sf->optimize_coefficients = 0;
        sf->no_skip_block4x4_search = 0;
828

John Koleszar's avatar
John Koleszar committed
829
        sf->first_step = 1;
830

John Koleszar's avatar
John Koleszar committed
831
832
833
        cpi->mode_check_freq[THR_SPLITG] = 2;
        cpi->mode_check_freq[THR_SPLITA] = 2;
        cpi->mode_check_freq[THR_SPLITMV] = 0;
834

John Koleszar's avatar
John Koleszar committed
835
836
837
838
        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
839

840
      if (speed > 1) {
John Koleszar's avatar
John Koleszar committed
841
842
843
        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
844

John Koleszar's avatar
John Koleszar committed
845
846
847
848
849
        cpi->mode_check_freq[THR_COMP_SPLITGA] = 4;
        cpi->mode_check_freq[THR_COMP_SPLITLG] = 4;
        cpi->mode_check_freq[THR_COMP_SPLITLA] = 2;
      }

850
      if (speed > 2) {
John Koleszar's avatar
John Koleszar committed
851
852
853
854
855
856
857
858
859
860
861
862
        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
863

John Koleszar's avatar
John Koleszar committed
864
      break;
John Koleszar's avatar
John Koleszar committed
865

John Koleszar's avatar
John Koleszar committed
866
  }; /* switch */
867

868
869
  // Set rd thresholds based on mode and speed setting
  set_rd_speed_thresholds(cpi, mode, speed);
John Koleszar's avatar
John Koleszar committed
870
871
872
873
874
875

  // 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;
  }
876

Yaowu Xu's avatar
Yaowu Xu committed
877
878
879
880
  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
881
  if (cpi->oxcf.lossless || cpi->mb.e_mbd.lossless) {
Yaowu Xu's avatar
Yaowu Xu committed
882
883
    cpi->mb.fwd_txm8x4    = vp9_short_walsh8x4;
    cpi->mb.fwd_txm4x4    = vp9_short_walsh4x4;
John Koleszar's avatar
John Koleszar committed
884
  }
John Koleszar's avatar
John Koleszar committed
885

886
  cpi->mb.quantize_b_4x4      = vp9_regular_quantize_b_4x4;
Paul Wilkins's avatar
Paul Wilkins committed
887

888
  vp9_init_quantizer(cpi);
John Koleszar's avatar
John Koleszar committed
889

John Koleszar's avatar
John Koleszar committed
890
  if (cpi->sf.iterative_sub_pixel == 1) {
891
    cpi->find_fractional_mv_step = vp9_find_best_sub_pixel_step_iteratively;
John Koleszar's avatar
John Koleszar committed
892
  } else if (cpi->sf.quarter_pixel_search) {
893
    cpi->find_fractional_mv_step = vp9_find_best_sub_pixel_step;
John Koleszar's avatar
John Koleszar committed
894
  } else if (cpi->sf.half_pixel_search) {
895
    cpi->find_fractional_mv_step = vp9_find_best_half_pixel_step;
John Koleszar's avatar
John Koleszar committed
896
  }
John Koleszar's avatar
John Koleszar committed
897

898
  cpi->mb.optimize = cpi->sf.optimize_coefficients == 1 && cpi->pass != 1;
John Koleszar's avatar
John Koleszar committed
899
900

#ifdef SPEEDSTATS
901
  frames_at_speed[cpi->speed]++;
John Koleszar's avatar
John Koleszar committed
902
903
#endif
}
904

905
static void alloc_raw_frame_buffers(VP9_COMP *cpi) {
906
907
  VP9_COMMON *cm = &cpi->common;

908
  cpi->lookahead = vp9_lookahead_init(cpi->oxcf.width, cpi->oxcf.height,
909
                                      cm->subsampling_x, cm->subsampling_y,
John Koleszar's avatar
John Koleszar committed
910
911
912
913
                                      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
914

915
916
917
918
  if (vp9_realloc_frame_buffer(&cpi->alt_ref_buffer,
                               cpi->oxcf.width, cpi->oxcf.height,
                               cm->subsampling_x, cm->subsampling_y,
                               VP9BORDERINPIXELS))
John Koleszar's avatar
John Koleszar committed
919
920
    vpx_internal_error(&cpi->common.error, VPX_CODEC_MEM_ERROR,
                       "Failed to allocate altref buffer");
John Koleszar's avatar
John Koleszar committed
921
}
922

923
static int alloc_partition_data(VP9_COMP *cpi) {
John Koleszar's avatar
John Koleszar committed
924
  vpx_free(cpi->mb.pip);
925

926
  cpi->mb.pip = vpx_calloc((cpi->common.mode_info_stride) *
927
                           (cpi->common.mi_rows + 1),
John Koleszar's avatar
John Koleszar committed
928
929
930
                           sizeof(PARTITION_INFO));
  if (!cpi->mb.pip)
    return 1;
931

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

John Koleszar's avatar
John Koleszar committed
934
  return 0;
935
936
}

937
938
void vp9_alloc_compressor_data(VP9_COMP *cpi) {
  VP9_COMMON *cm = &cpi->common;
John Koleszar's avatar
John Koleszar committed
939

940
  if (vp9_alloc_frame_buffers(cm, cm->width, cm->height))
John Koleszar's avatar
John Koleszar committed
941
942
    vpx_internal_error(&cpi->common.error, VPX_CODEC_MEM_ERROR,
                       "Failed to allocate frame buffers");
John Koleszar's avatar
John Koleszar committed
943

944
  if (alloc_partition_data(cpi))
John Koleszar's avatar
John Koleszar committed
945
946
    vpx_internal_error(&cpi->common.error, VPX_CODEC_MEM_ERROR,
                       "Failed to allocate partition data");
947

948
949
950
951
  if (vp9_alloc_frame_buffer(&cpi->last_frame_uf,
                             cm->width, cm->height,
                             cm->subsampling_x, cm->subsampling_y,
                             VP9BORDERINPIXELS))
John Koleszar's avatar
John Koleszar committed
952
953
    vpx_internal_error(&cpi->common.error, VPX_CODEC_MEM_ERROR,
                       "Failed to allocate last frame buffer");
John Koleszar's avatar
John Koleszar committed
954

955
956
957
958
  if (vp9_alloc_frame_buffer(&cpi->scaled_source,
                             cm->width, cm->height,
                             cm->subsampling_x, cm->subsampling_y,
                             VP9BORDERINPIXELS))
John Koleszar's avatar
John Koleszar committed
959
960
    vpx_internal_error(&cpi->common.error, VPX_CODEC_MEM_ERROR,
                       "Failed to allocate scaled source buffer");
John Koleszar's avatar
John Koleszar committed
961

John Koleszar's avatar
John Koleszar committed
962
  vpx_free(cpi->tok);
John Koleszar's avatar
John Koleszar committed
963

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