onyx_if.c 187 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 "./vpx_scale_rtcd.h"
John Koleszar's avatar
John Koleszar committed
14
#include "vp8/common/onyxc_int.h"
15
#include "vp8/common/blockd.h"
John Koleszar's avatar
John Koleszar committed
16
#include "onyx_int.h"
John Koleszar's avatar
John Koleszar committed
17
#include "vp8/common/systemdependent.h"
John Koleszar's avatar
John Koleszar committed
18
#include "quantize.h"
John Koleszar's avatar
John Koleszar committed
19
#include "vp8/common/alloccommon.h"
John Koleszar's avatar
John Koleszar committed
20
21
#include "mcomp.h"
#include "firstpass.h"
22
#include "vpx/internal/vpx_psnr.h"
Johann's avatar
Johann committed
23
#include "vpx_scale/vpx_scale.h"
John Koleszar's avatar
John Koleszar committed
24
#include "vp8/common/extend.h"
John Koleszar's avatar
John Koleszar committed
25
#include "ratectrl.h"
John Koleszar's avatar
John Koleszar committed
26
#include "vp8/common/quant_common.h"
27
#include "segmentation.h"
28
#if CONFIG_POSTPROC
John Koleszar's avatar
John Koleszar committed
29
#include "vp8/common/postproc.h"
30
#endif
John Koleszar's avatar
John Koleszar committed
31
#include "vpx_mem/vpx_mem.h"
John Koleszar's avatar
John Koleszar committed
32
33
#include "vp8/common/swapyv12buffer.h"
#include "vp8/common/threading.h"
John Koleszar's avatar
John Koleszar committed
34
#include "vpx_ports/vpx_timer.h"
35
36
37
#if ARCH_ARM
#include "vpx_ports/arm.h"
#endif
Yunqing Wang's avatar
Yunqing Wang committed
38
39
40
#if CONFIG_MULTI_RES_ENCODING
#include "mr_dissim.h"
#endif
41
#include "encodeframe.h"
42

John Koleszar's avatar
John Koleszar committed
43
44
45
46
#include <math.h>
#include <stdio.h>
#include <limits.h>

47
48
49
50
51
#if CONFIG_REALTIME_ONLY & CONFIG_ONTHEFLY_BITPACKING
extern int vp8_update_coef_context(VP8_COMP *cpi);
extern void vp8_update_coef_probs(VP8_COMP *cpi);
#endif

John Koleszar's avatar
John Koleszar committed
52
53
54
55
56
57
58
59
extern void vp8cx_pick_filter_level_fast(YV12_BUFFER_CONFIG *sd, VP8_COMP *cpi);
extern void vp8cx_set_alt_lf_level(VP8_COMP *cpi, int filt_val);
extern void vp8cx_pick_filter_level(YV12_BUFFER_CONFIG *sd, VP8_COMP *cpi);

extern void vp8_deblock_frame(YV12_BUFFER_CONFIG *source, YV12_BUFFER_CONFIG *post, int filt_lvl, int low_var_thresh, int flag);
extern void print_parms(VP8_CONFIG *ocf, char *filenam);
extern unsigned int vp8_get_processor_freq();
extern void print_tree_update_probs();
60
extern int vp8cx_create_encoder_threads(VP8_COMP *cpi);
John Koleszar's avatar
John Koleszar committed
61
62
63
extern void vp8cx_remove_encoder_threads(VP8_COMP *cpi);

int vp8_estimate_entropy_savings(VP8_COMP *cpi);
64

John Koleszar's avatar
John Koleszar committed
65
int vp8_calc_ss_err(YV12_BUFFER_CONFIG *source, YV12_BUFFER_CONFIG *dest);
John Koleszar's avatar
John Koleszar committed
66

John Koleszar's avatar
John Koleszar committed
67
extern void vp8_temporal_filter_prepare_c(VP8_COMP *cpi, int distance);
John Koleszar's avatar
John Koleszar committed
68

69
static void set_default_lf_deltas(VP8_COMP *cpi);
John Koleszar's avatar
John Koleszar committed
70
71
72

extern const int vp8_gf_interval_table[101];

73
#if CONFIG_INTERNAL_STATS
John Koleszar's avatar
John Koleszar committed
74
75
76
77
78
79
80
#include "math.h"

extern double vp8_calc_ssim
(
    YV12_BUFFER_CONFIG *source,
    YV12_BUFFER_CONFIG *dest,
    int lumamask,
John Koleszar's avatar
John Koleszar committed
81
    double *weight
John Koleszar's avatar
John Koleszar committed
82
83
);

84

John Koleszar's avatar
John Koleszar committed
85
86
87
88
89
90
extern double vp8_calc_ssimg
(
    YV12_BUFFER_CONFIG *source,
    YV12_BUFFER_CONFIG *dest,
    double *ssim_y,
    double *ssim_u,
John Koleszar's avatar
John Koleszar committed
91
    double *ssim_v
John Koleszar's avatar
John Koleszar committed
92
93
94
95
96
97
98
99
100
);


#endif


#ifdef OUTPUT_YUV_SRC
FILE *yuv_file;
#endif
101
102
103
#ifdef OUTPUT_YUV_DENOISED
FILE *yuv_denoised_file;
#endif
John Koleszar's avatar
John Koleszar committed
104
105
106
107
108
109
110
111
112
113
114
115
116

#if 0
FILE *framepsnr;
FILE *kf_list;
FILE *keyfile;
#endif

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


117
#ifdef VP8_ENTROPY_STATS
John Koleszar's avatar
John Koleszar committed
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
extern int intra_mode_stats[10][10][10];
#endif

#ifdef SPEEDSTATS
unsigned int frames_at_speed[16] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
unsigned int tot_pm = 0;
unsigned int cnt_pm = 0;
unsigned int tot_ef = 0;
unsigned int cnt_ef = 0;
#endif

#ifdef MODE_STATS
extern unsigned __int64 Sectionbits[50];
extern int y_modes[5]  ;
extern int uv_modes[4] ;
extern int b_modes[10]  ;

extern int inter_y_modes[10] ;
extern int inter_uv_modes[4] ;
extern unsigned int inter_b_modes[15];
#endif

extern const int vp8_bits_per_mb[2][QINDEX_RANGE];

extern const int qrounding_factors[129];
extern const int qzbin_factors[129];
extern void vp8cx_init_quantizer(VP8_COMP *cpi);
extern const int vp8cx_base_skip_false_prob[128];

John Koleszar's avatar
John Koleszar committed
147
/* Tables relating active max Q to active min Q */
148
static const unsigned char kf_low_motion_minq[QINDEX_RANGE] =
149
{
Paul Wilkins's avatar
CQ Mode    
Paul Wilkins committed
150
151
152
153
154
155
156
157
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    0,0,0,0,1,1,1,1,1,1,1,1,2,2,2,2,
    3,3,3,3,3,3,4,4,4,5,5,5,5,5,6,6,
    6,6,7,7,8,8,8,8,9,9,10,10,10,10,11,11,
    11,11,12,12,13,13,13,13,14,14,15,15,15,15,16,16,
    16,16,17,17,18,18,18,18,19,20,20,21,21,22,23,23
158
};
159
static const unsigned char kf_high_motion_minq[QINDEX_RANGE] =
160
{
Paul Wilkins's avatar
CQ Mode    
Paul Wilkins committed
161
162
163
164
165
166
167
168
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    1,1,1,1,1,1,1,1,2,2,2,2,3,3,3,3,
    3,3,3,3,4,4,4,4,5,5,5,5,5,5,6,6,
    6,6,7,7,8,8,8,8,9,9,10,10,10,10,11,11,
    11,11,12,12,13,13,13,13,14,14,15,15,15,15,16,16,
    16,16,17,17,18,18,18,18,19,19,20,20,20,20,21,21,
    21,21,22,22,23,23,24,25,25,26,26,27,28,28,29,30
169
};
170
static const unsigned char gf_low_motion_minq[QINDEX_RANGE] =
171
172
173
174
175
176
177
178
179
180
{
    0,0,0,0,1,1,1,1,1,1,1,1,2,2,2,2,
    3,3,3,3,4,4,4,4,5,5,5,5,6,6,6,6,
    7,7,7,7,8,8,8,8,9,9,9,9,10,10,10,10,
    11,11,12,12,13,13,14,14,15,15,16,16,17,17,18,18,
    19,19,20,20,21,21,22,22,23,23,24,24,25,25,26,26,
    27,27,28,28,29,29,30,30,31,31,32,32,33,33,34,34,
    35,35,36,36,37,37,38,38,39,39,40,40,41,41,42,42,
    43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58
};
181
static const unsigned char gf_mid_motion_minq[QINDEX_RANGE] =
182
183
184
185
186
187
188
189
{
    0,0,0,0,1,1,1,1,1,1,2,2,3,3,3,4,
    4,4,5,5,5,6,6,6,7,7,7,8,8,8,9,9,
    9,10,10,10,10,11,11,11,12,12,12,12,13,13,13,14,
    14,14,15,15,16,16,17,17,18,18,19,19,20,20,21,21,
    22,22,23,23,24,24,25,25,26,26,27,27,28,28,29,29,
    30,30,31,31,32,32,33,33,34,34,35,35,36,36,37,37,
    38,39,39,40,40,41,41,42,42,43,43,44,45,46,47,48,
Paul Wilkins's avatar
CQ Mode    
Paul Wilkins committed
190
    49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64
191
};
192
static const unsigned char gf_high_motion_minq[QINDEX_RANGE] =
193
194
195
196
197
198
199
200
{
    0,0,0,0,1,1,1,1,1,2,2,2,3,3,3,4,
    4,4,5,5,5,6,6,6,7,7,7,8,8,8,9,9,
    9,10,10,10,11,11,12,12,13,13,14,14,15,15,16,16,
    17,17,18,18,19,19,20,20,21,21,22,22,23,23,24,24,
    25,25,26,26,27,27,28,28,29,29,30,30,31,31,32,32,
    33,33,34,34,35,35,36,36,37,37,38,38,39,39,40,40,
    41,41,42,42,43,44,45,46,47,48,49,50,51,52,53,54,
Paul Wilkins's avatar
CQ Mode    
Paul Wilkins committed
201
    55,56,57,58,59,60,62,64,66,68,70,72,74,76,78,80
202
};
203
static const unsigned char inter_minq[QINDEX_RANGE] =
204
{
Paul Wilkins's avatar
Paul Wilkins committed
205
206
207
208
209
210
211
212
    0,0,1,1,2,3,3,4,4,5,6,6,7,8,8,9,
    9,10,11,11,12,13,13,14,15,15,16,17,17,18,19,20,
    20,21,22,22,23,24,24,25,26,27,27,28,29,30,30,31,
    32,33,33,34,35,36,36,37,38,39,39,40,41,42,42,43,
    44,45,46,46,47,48,49,50,50,51,52,53,54,55,55,56,
    57,58,59,60,60,61,62,63,64,65,66,67,67,68,69,70,
    71,72,73,74,75,75,76,77,78,79,80,81,82,83,84,85,
    86,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100
213
};
John Koleszar's avatar
John Koleszar committed
214
215
216
217
218

#ifdef PACKET_TESTING
extern FILE *vpxlogc;
#endif

219
220
221
222
static void save_layer_context(VP8_COMP *cpi)
{
    LAYER_CONTEXT *lc = &cpi->layer_context[cpi->current_layer];

John Koleszar's avatar
John Koleszar committed
223
    /* Save layer dependent coding state */
224
225
226
227
    lc->target_bandwidth                 = cpi->target_bandwidth;
    lc->starting_buffer_level            = cpi->oxcf.starting_buffer_level;
    lc->optimal_buffer_level             = cpi->oxcf.optimal_buffer_level;
    lc->maximum_buffer_size              = cpi->oxcf.maximum_buffer_size;
228
229
230
    lc->starting_buffer_level_in_ms      = cpi->oxcf.starting_buffer_level_in_ms;
    lc->optimal_buffer_level_in_ms       = cpi->oxcf.optimal_buffer_level_in_ms;
    lc->maximum_buffer_size_in_ms        = cpi->oxcf.maximum_buffer_size_in_ms;
231
232
233
234
235
236
237
238
239
240
241
242
243
244
    lc->buffer_level                     = cpi->buffer_level;
    lc->bits_off_target                  = cpi->bits_off_target;
    lc->total_actual_bits                = cpi->total_actual_bits;
    lc->worst_quality                    = cpi->worst_quality;
    lc->active_worst_quality             = cpi->active_worst_quality;
    lc->best_quality                     = cpi->best_quality;
    lc->active_best_quality              = cpi->active_best_quality;
    lc->ni_av_qi                         = cpi->ni_av_qi;
    lc->ni_tot_qi                        = cpi->ni_tot_qi;
    lc->ni_frames                        = cpi->ni_frames;
    lc->avg_frame_qindex                 = cpi->avg_frame_qindex;
    lc->rate_correction_factor           = cpi->rate_correction_factor;
    lc->key_frame_rate_correction_factor = cpi->key_frame_rate_correction_factor;
    lc->gf_rate_correction_factor        = cpi->gf_rate_correction_factor;
245
    lc->zbin_over_quant                  = cpi->mb.zbin_over_quant;
246
247
248
249
250
251
252
    lc->inter_frame_target               = cpi->inter_frame_target;
    lc->total_byte_count                 = cpi->total_byte_count;
    lc->filter_level                     = cpi->common.filter_level;

    lc->last_frame_percent_intra         = cpi->last_frame_percent_intra;

    memcpy (lc->count_mb_ref_frame_usage,
253
254
            cpi->mb.count_mb_ref_frame_usage,
            sizeof(cpi->mb.count_mb_ref_frame_usage));
255
256
257
258
259
260
}

static void restore_layer_context(VP8_COMP *cpi, const int layer)
{
    LAYER_CONTEXT *lc = &cpi->layer_context[layer];

John Koleszar's avatar
John Koleszar committed
261
    /* Restore layer dependent coding state */
262
263
264
265
266
267
    cpi->current_layer                    = layer;
    cpi->target_bandwidth                 = lc->target_bandwidth;
    cpi->oxcf.target_bandwidth            = lc->target_bandwidth;
    cpi->oxcf.starting_buffer_level       = lc->starting_buffer_level;
    cpi->oxcf.optimal_buffer_level        = lc->optimal_buffer_level;
    cpi->oxcf.maximum_buffer_size         = lc->maximum_buffer_size;
268
269
270
    cpi->oxcf.starting_buffer_level_in_ms = lc->starting_buffer_level_in_ms;
    cpi->oxcf.optimal_buffer_level_in_ms  = lc->optimal_buffer_level_in_ms;
    cpi->oxcf.maximum_buffer_size_in_ms   = lc->maximum_buffer_size_in_ms;
271
272
273
274
275
276
277
278
279
280
281
282
    cpi->buffer_level                     = lc->buffer_level;
    cpi->bits_off_target                  = lc->bits_off_target;
    cpi->total_actual_bits                = lc->total_actual_bits;
    cpi->active_worst_quality             = lc->active_worst_quality;
    cpi->active_best_quality              = lc->active_best_quality;
    cpi->ni_av_qi                         = lc->ni_av_qi;
    cpi->ni_tot_qi                        = lc->ni_tot_qi;
    cpi->ni_frames                        = lc->ni_frames;
    cpi->avg_frame_qindex                 = lc->avg_frame_qindex;
    cpi->rate_correction_factor           = lc->rate_correction_factor;
    cpi->key_frame_rate_correction_factor = lc->key_frame_rate_correction_factor;
    cpi->gf_rate_correction_factor        = lc->gf_rate_correction_factor;
283
    cpi->mb.zbin_over_quant                  = lc->zbin_over_quant;
284
285
286
287
288
289
    cpi->inter_frame_target               = lc->inter_frame_target;
    cpi->total_byte_count                 = lc->total_byte_count;
    cpi->common.filter_level              = lc->filter_level;

    cpi->last_frame_percent_intra         = lc->last_frame_percent_intra;

290
    memcpy (cpi->mb.count_mb_ref_frame_usage,
291
            lc->count_mb_ref_frame_usage,
292
            sizeof(cpi->mb.count_mb_ref_frame_usage));
293
294
}

295
296
297
298
299
300
301
302
303
304
305
306
static int rescale(int val, int num, int denom)
{
    int64_t llnum = num;
    int64_t llden = denom;
    int64_t llval = val;

    return (int)(llval * llnum / llden);
}

static void init_temporal_layer_context(VP8_COMP *cpi,
                                        VP8_CONFIG *oxcf,
                                        const int layer,
James Zern's avatar
James Zern committed
307
                                        double prev_layer_framerate)
308
309
310
{
    LAYER_CONTEXT *lc = &cpi->layer_context[layer];

James Zern's avatar
James Zern committed
311
    lc->framerate = cpi->output_framerate / cpi->oxcf.rate_decimator[layer];
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
    lc->target_bandwidth = cpi->oxcf.target_bitrate[layer] * 1000;

    lc->starting_buffer_level_in_ms = oxcf->starting_buffer_level;
    lc->optimal_buffer_level_in_ms  = oxcf->optimal_buffer_level;
    lc->maximum_buffer_size_in_ms   = oxcf->maximum_buffer_size;

    lc->starting_buffer_level =
        rescale((int)(oxcf->starting_buffer_level),
                lc->target_bandwidth, 1000);

    if (oxcf->optimal_buffer_level == 0)
      lc->optimal_buffer_level = lc->target_bandwidth / 8;
    else
      lc->optimal_buffer_level =
          rescale((int)(oxcf->optimal_buffer_level),
                  lc->target_bandwidth, 1000);

    if (oxcf->maximum_buffer_size == 0)
      lc->maximum_buffer_size = lc->target_bandwidth / 8;
    else
      lc->maximum_buffer_size =
          rescale((int)(oxcf->maximum_buffer_size),
                  lc->target_bandwidth, 1000);

    /* Work out the average size of a frame within this layer */
    if (layer > 0)
      lc->avg_frame_size_for_layer =
          (int)((cpi->oxcf.target_bitrate[layer] -
                cpi->oxcf.target_bitrate[layer-1]) * 1000 /
James Zern's avatar
James Zern committed
341
                (lc->framerate - prev_layer_framerate));
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367

     lc->active_worst_quality         = cpi->oxcf.worst_allowed_q;
     lc->active_best_quality          = cpi->oxcf.best_allowed_q;
     lc->avg_frame_qindex             = cpi->oxcf.worst_allowed_q;

     lc->buffer_level                 = lc->starting_buffer_level;
     lc->bits_off_target              = lc->starting_buffer_level;

     lc->total_actual_bits                 = 0;
     lc->ni_av_qi                          = 0;
     lc->ni_tot_qi                         = 0;
     lc->ni_frames                         = 0;
     lc->rate_correction_factor            = 1.0;
     lc->key_frame_rate_correction_factor  = 1.0;
     lc->gf_rate_correction_factor         = 1.0;
     lc->inter_frame_target                = 0;
}

// Upon a run-time change in temporal layers, reset the layer context parameters
// for any "new" layers. For "existing" layers, let them inherit the parameters
// from the previous layer state (at the same layer #). In future we may want
// to better map the previous layer state(s) to the "new" ones.
static void reset_temporal_layer_change(VP8_COMP *cpi,
                                        VP8_CONFIG *oxcf,
                                        const int prev_num_layers)
{
368
    int i;
James Zern's avatar
James Zern committed
369
    double prev_layer_framerate = 0;
370
371
372
373
374
375
376
377
378
379
380
381
382
    const int curr_num_layers = cpi->oxcf.number_of_layers;
    // If the previous state was 1 layer, get current layer context from cpi.
    // We need this to set the layer context for the new layers below.
    if (prev_num_layers == 1)
    {
        cpi->current_layer = 0;
        save_layer_context(cpi);
    }
    for (i = 0; i < curr_num_layers; i++)
    {
        LAYER_CONTEXT *lc = &cpi->layer_context[i];
        if (i >= prev_num_layers)
        {
James Zern's avatar
James Zern committed
383
           init_temporal_layer_context(cpi, oxcf, i, prev_layer_framerate);
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
        }
        // The initial buffer levels are set based on their starting levels.
        // We could set the buffer levels based on the previous state (normalized
        // properly by the layer bandwidths) but we would need to keep track of
        // the previous set of layer bandwidths (i.e., target_bitrate[i])
        // before the layer change. For now, reset to the starting levels.
        lc->buffer_level = cpi->oxcf.starting_buffer_level_in_ms *
                           cpi->oxcf.target_bitrate[i];
        lc->bits_off_target = lc->buffer_level;
        // TDOD(marpan): Should we set the rate_correction_factor and
        // active_worst/best_quality to values derived from the previous layer
        // state (to smooth-out quality dips/rate fluctuation at transition)?

        // We need to treat the 1 layer case separately: oxcf.target_bitrate[i]
        // is not set for 1 layer, and the restore_layer_context/save_context()
        // are not called in the encoding loop, so we need to call it here to
        // pass the layer context state to |cpi|.
        if (curr_num_layers == 1)
        {
            lc->target_bandwidth = cpi->oxcf.target_bandwidth;
            lc->buffer_level = cpi->oxcf.starting_buffer_level_in_ms *
                               lc->target_bandwidth  / 1000;
            lc->bits_off_target = lc->buffer_level;
            restore_layer_context(cpi, 0);
        }
James Zern's avatar
James Zern committed
409
410
        prev_layer_framerate = cpi->output_framerate /
                               cpi->oxcf.rate_decimator[i];
411
412
413
    }
}

John Koleszar's avatar
John Koleszar committed
414
415
static void setup_features(VP8_COMP *cpi)
{
416
417
418
419
420
421
422
423
424
425
426
    // If segmentation enabled set the update flags
    if ( cpi->mb.e_mbd.segmentation_enabled )
    {
        cpi->mb.e_mbd.update_mb_segmentation_map = 1;
        cpi->mb.e_mbd.update_mb_segmentation_data = 1;
    }
    else
    {
        cpi->mb.e_mbd.update_mb_segmentation_map = 0;
        cpi->mb.e_mbd.update_mb_segmentation_data = 0;
    }
John Koleszar's avatar
John Koleszar committed
427
428
429
430
431

    cpi->mb.e_mbd.mode_ref_lf_delta_enabled = 0;
    cpi->mb.e_mbd.mode_ref_lf_delta_update = 0;
    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));
432
433
    vpx_memset(cpi->mb.e_mbd.last_ref_lf_deltas, 0, sizeof(cpi->mb.e_mbd.ref_lf_deltas));
    vpx_memset(cpi->mb.e_mbd.last_mode_lf_deltas, 0, sizeof(cpi->mb.e_mbd.mode_lf_deltas));
John Koleszar's avatar
John Koleszar committed
434

435
    set_default_lf_deltas(cpi);
John Koleszar's avatar
John Koleszar committed
436
437
438
439

}


440
441
442
static void dealloc_raw_frame_buffers(VP8_COMP *cpi);


443
static void dealloc_compressor_data(VP8_COMP *cpi)
John Koleszar's avatar
John Koleszar committed
444
{
445
    vpx_free(cpi->tplist);
446
447
    cpi->tplist = NULL;

John Koleszar's avatar
John Koleszar committed
448
    /* Delete last frame MV storage buffers */
449
    vpx_free(cpi->lfmv);
450
451
    cpi->lfmv = 0;

452
    vpx_free(cpi->lf_ref_frame_sign_bias);
453
454
    cpi->lf_ref_frame_sign_bias = 0;

455
    vpx_free(cpi->lf_ref_frame);
456
    cpi->lf_ref_frame = 0;
John Koleszar's avatar
John Koleszar committed
457

John Koleszar's avatar
John Koleszar committed
458
    /* Delete sementation map */
459
    vpx_free(cpi->segmentation_map);
John Koleszar's avatar
John Koleszar committed
460
461
    cpi->segmentation_map = 0;

462
    vpx_free(cpi->active_map);
John Koleszar's avatar
John Koleszar committed
463
464
465
466
    cpi->active_map = 0;

    vp8_de_alloc_frame_buffers(&cpi->common);

467
    vp8_yv12_de_alloc_frame_buffer(&cpi->pick_lf_lvl_frame);
John Koleszar's avatar
John Koleszar committed
468
    vp8_yv12_de_alloc_frame_buffer(&cpi->scaled_source);
469
    dealloc_raw_frame_buffers(cpi);
John Koleszar's avatar
John Koleszar committed
470
471
472
473

    vpx_free(cpi->tok);
    cpi->tok = 0;

John Koleszar's avatar
John Koleszar committed
474
    /* Structure used to monitor GF usage */
475
    vpx_free(cpi->gf_active_flags);
476
477
    cpi->gf_active_flags = 0;

John Koleszar's avatar
John Koleszar committed
478
    /* Activity mask based per mb zbin adjustments */
479
480
481
    vpx_free(cpi->mb_activity_map);
    cpi->mb_activity_map = 0;

482
    vpx_free(cpi->mb.pip);
483
    cpi->mb.pip = 0;
484
485
486
487
488

#if CONFIG_MULTITHREAD
    vpx_free(cpi->mt_current_mb_col);
    cpi->mt_current_mb_col = NULL;
#endif
John Koleszar's avatar
John Koleszar committed
489
490
}

John Koleszar's avatar
John Koleszar committed
491
static void enable_segmentation(VP8_COMP *cpi)
John Koleszar's avatar
John Koleszar committed
492
{
John Koleszar's avatar
John Koleszar committed
493
    /* Set the appropriate feature bit */
John Koleszar's avatar
John Koleszar committed
494
495
496
497
    cpi->mb.e_mbd.segmentation_enabled = 1;
    cpi->mb.e_mbd.update_mb_segmentation_map = 1;
    cpi->mb.e_mbd.update_mb_segmentation_data = 1;
}
John Koleszar's avatar
John Koleszar committed
498
static void disable_segmentation(VP8_COMP *cpi)
John Koleszar's avatar
John Koleszar committed
499
{
John Koleszar's avatar
John Koleszar committed
500
    /* Clear the appropriate feature bit */
John Koleszar's avatar
John Koleszar committed
501
502
503
    cpi->mb.e_mbd.segmentation_enabled = 0;
}

John Koleszar's avatar
John Koleszar committed
504
505
506
/* Valid values for a segment are 0 to 3
 * Segmentation map is arrange as [Rows][Columns]
 */
John Koleszar's avatar
John Koleszar committed
507
static void set_segmentation_map(VP8_COMP *cpi, unsigned char *segmentation_map)
John Koleszar's avatar
John Koleszar committed
508
{
John Koleszar's avatar
John Koleszar committed
509
    /* Copy in the new segmentation map */
John Koleszar's avatar
John Koleszar committed
510
511
    vpx_memcpy(cpi->segmentation_map, segmentation_map, (cpi->common.mb_rows * cpi->common.mb_cols));

John Koleszar's avatar
John Koleszar committed
512
    /* Signal that the map should be updated. */
John Koleszar's avatar
John Koleszar committed
513
514
515
516
    cpi->mb.e_mbd.update_mb_segmentation_map = 1;
    cpi->mb.e_mbd.update_mb_segmentation_data = 1;
}

John Koleszar's avatar
John Koleszar committed
517
518
519
520
521
522
523
524
525
526
527
528
/* The values given for each segment can be either deltas (from the default
 * value chosen for the frame) or absolute values.
 *
 * Valid range for abs values is:
 *    (0-127 for MB_LVL_ALT_Q), (0-63 for SEGMENT_ALT_LF)
 * Valid range for delta values are:
 *    (+/-127 for MB_LVL_ALT_Q), (+/-63 for SEGMENT_ALT_LF)
 *
 * abs_delta = SEGMENT_DELTADATA (deltas)
 * abs_delta = SEGMENT_ABSDATA (use the absolute values given).
 *
 */
John Koleszar's avatar
John Koleszar committed
529
static void set_segment_data(VP8_COMP *cpi, signed char *feature_data, unsigned char abs_delta)
John Koleszar's avatar
John Koleszar committed
530
531
532
533
534
535
{
    cpi->mb.e_mbd.mb_segement_abs_delta = abs_delta;
    vpx_memcpy(cpi->segment_feature_data, feature_data, sizeof(cpi->segment_feature_data));
}


John Koleszar's avatar
John Koleszar committed
536
static void segmentation_test_function(VP8_COMP *cpi)
John Koleszar's avatar
John Koleszar committed
537
538
539
540
{
    unsigned char *seg_map;
    signed char feature_data[MB_LVL_MAX][MAX_MB_SEGMENTS];

541
    // Create a temporary map for segmentation data.
John Koleszar's avatar
John Koleszar committed
542
543
    CHECK_MEM_ERROR(seg_map, vpx_calloc(cpi->common.mb_rows * cpi->common.mb_cols, 1));

544
    // Set the segmentation Map
John Koleszar's avatar
John Koleszar committed
545
    set_segmentation_map(cpi, seg_map);
John Koleszar's avatar
John Koleszar committed
546

547
    // Activate segmentation.
John Koleszar's avatar
John Koleszar committed
548
    enable_segmentation(cpi);
John Koleszar's avatar
John Koleszar committed
549

550
    // Set up the quant segment data
John Koleszar's avatar
John Koleszar committed
551
552
553
554
    feature_data[MB_LVL_ALT_Q][0] = 0;
    feature_data[MB_LVL_ALT_Q][1] = 4;
    feature_data[MB_LVL_ALT_Q][2] = 0;
    feature_data[MB_LVL_ALT_Q][3] = 0;
555
    // Set up the loop segment data
John Koleszar's avatar
John Koleszar committed
556
557
558
559
560
    feature_data[MB_LVL_ALT_LF][0] = 0;
    feature_data[MB_LVL_ALT_LF][1] = 0;
    feature_data[MB_LVL_ALT_LF][2] = 0;
    feature_data[MB_LVL_ALT_LF][3] = 0;

561
562
    // Initialise the feature data structure
    // SEGMENT_DELTADATA    0, SEGMENT_ABSDATA      1
John Koleszar's avatar
John Koleszar committed
563
    set_segment_data(cpi, &feature_data[0][0], SEGMENT_DELTADATA);
John Koleszar's avatar
John Koleszar committed
564

565
    // Delete sementation map
John Koleszar's avatar
John Koleszar committed
566
    vpx_free(seg_map);
John Koleszar's avatar
John Koleszar committed
567
568
569
570

    seg_map = 0;
}

John Koleszar's avatar
John Koleszar committed
571
/* A simple function to cyclically refresh the background at a lower Q */
John Koleszar's avatar
John Koleszar committed
572
573
static void cyclic_background_refresh(VP8_COMP *cpi, int Q, int lf_adjustment)
{
Marco Paniconi's avatar
Marco Paniconi committed
574
    unsigned char *seg_map = cpi->segmentation_map;
John Koleszar's avatar
John Koleszar committed
575
576
577
578
579
    signed char feature_data[MB_LVL_MAX][MAX_MB_SEGMENTS];
    int i;
    int block_count = cpi->cyclic_refresh_mode_max_mbs_perframe;
    int mbs_in_frame = cpi->common.mb_rows * cpi->common.mb_cols;

Marco Paniconi's avatar
Marco Paniconi committed
580
    cpi->cyclic_refresh_q = Q / 2;
John Koleszar's avatar
John Koleszar committed
581

Marco Paniconi's avatar
Marco Paniconi committed
582
583
584
585
    // Set every macroblock to be eligible for update.
    // For key frame this will reset seg map to 0.
    vpx_memset(cpi->segmentation_map, 0, mbs_in_frame);

John Koleszar's avatar
John Koleszar committed
586
587
    if (cpi->common.frame_type != KEY_FRAME)
    {
John Koleszar's avatar
John Koleszar committed
588
589
        /* Cycle through the macro_block rows */
        /* MB loop to set local segmentation map */
Marco Paniconi's avatar
Marco Paniconi committed
590
        i = cpi->cyclic_refresh_mode_index;
591
        assert(i < mbs_in_frame);
Marco Paniconi's avatar
Marco Paniconi committed
592
        do
John Koleszar's avatar
John Koleszar committed
593
        {
Marco Paniconi's avatar
Marco Paniconi committed
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
          /* If the MB is as a candidate for clean up then mark it for
           * possible boost/refresh (segment 1) The segment id may get
           * reset to 0 later if the MB gets coded anything other than
           * last frame 0,0 as only (last frame 0,0) MBs are eligable for
           * refresh : that is to say Mbs likely to be background blocks.
           */
          if (cpi->cyclic_refresh_map[i] == 0)
          {
              seg_map[i] = 1;
              block_count --;
          }
          else if (cpi->cyclic_refresh_map[i] < 0)
              cpi->cyclic_refresh_map[i]++;

          i++;
          if (i == mbs_in_frame)
              i = 0;
John Koleszar's avatar
John Koleszar committed
611
612

        }
Marco Paniconi's avatar
Marco Paniconi committed
613
        while(block_count && i != cpi->cyclic_refresh_mode_index);
John Koleszar's avatar
John Koleszar committed
614
615

        cpi->cyclic_refresh_mode_index = i;
616
617

#if CONFIG_TEMPORAL_DENOISING
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
        if (cpi->oxcf.noise_sensitivity > 0) {
          if (cpi->denoiser.denoiser_mode == kDenoiserOnYUVAggressive &&
              Q < (int)cpi->denoiser.denoise_pars.qp_thresh) {
            // Under aggressive denoising, use segmentation to turn off loop
            // filter below some qp thresh. The filter is turned off for all
            // blocks that have been encoded as ZEROMV LAST x frames in a row,
            // where x is set by cpi->denoiser.denoise_pars.consec_zerolast.
            // This is to avoid "dot" artifacts that can occur from repeated
            // loop filtering on noisy input source.
            cpi->cyclic_refresh_q = Q;
            lf_adjustment = -MAX_LOOP_FILTER;
            for (i = 0; i < mbs_in_frame; ++i) {
              seg_map[i] = (cpi->consec_zero_last[i] >
                            cpi->denoiser.denoise_pars.consec_zerolast) ? 1 : 0;
            }
633
634
635
          }
        }
#endif
John Koleszar's avatar
John Koleszar committed
636
637
    }

John Koleszar's avatar
John Koleszar committed
638
    /* Activate segmentation. */
Marco Paniconi's avatar
Marco Paniconi committed
639
640
    cpi->mb.e_mbd.update_mb_segmentation_map = 1;
    cpi->mb.e_mbd.update_mb_segmentation_data = 1;
John Koleszar's avatar
John Koleszar committed
641
    enable_segmentation(cpi);
John Koleszar's avatar
John Koleszar committed
642

John Koleszar's avatar
John Koleszar committed
643
    /* Set up the quant segment data */
John Koleszar's avatar
John Koleszar committed
644
645
646
647
648
    feature_data[MB_LVL_ALT_Q][0] = 0;
    feature_data[MB_LVL_ALT_Q][1] = (cpi->cyclic_refresh_q - Q);
    feature_data[MB_LVL_ALT_Q][2] = 0;
    feature_data[MB_LVL_ALT_Q][3] = 0;

John Koleszar's avatar
John Koleszar committed
649
    /* Set up the loop segment data */
John Koleszar's avatar
John Koleszar committed
650
651
652
653
654
    feature_data[MB_LVL_ALT_LF][0] = 0;
    feature_data[MB_LVL_ALT_LF][1] = lf_adjustment;
    feature_data[MB_LVL_ALT_LF][2] = 0;
    feature_data[MB_LVL_ALT_LF][3] = 0;

John Koleszar's avatar
John Koleszar committed
655
    /* Initialise the feature data structure */
John Koleszar's avatar
John Koleszar committed
656
    set_segment_data(cpi, &feature_data[0][0], SEGMENT_DELTADATA);
John Koleszar's avatar
John Koleszar committed
657
658
659

}

660
static void set_default_lf_deltas(VP8_COMP *cpi)
John Koleszar's avatar
John Koleszar committed
661
662
663
664
665
666
667
{
    cpi->mb.e_mbd.mode_ref_lf_delta_enabled = 1;
    cpi->mb.e_mbd.mode_ref_lf_delta_update = 1;

    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
668
    /* Test of ref frame deltas */
John Koleszar's avatar
John Koleszar committed
669
670
671
672
673
    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
674
    cpi->mb.e_mbd.mode_lf_deltas[0] = 4;               /* BPRED */
675
676
677
678
679
680

    if(cpi->oxcf.Mode == MODE_REALTIME)
      cpi->mb.e_mbd.mode_lf_deltas[1] = -12;              /* Zero */
    else
      cpi->mb.e_mbd.mode_lf_deltas[1] = -2;              /* Zero */

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

685
686
687
688
689
690
/* Convenience macros for mapping speed and mode into a continuous
 * range
 */
#define GOOD(x) (x+1)
#define RT(x) (x+7)

691
static int speed_map(int speed, const int *map)
692
693
694
695
696
697
698
699
700
701
{
    int res;

    do
    {
        res = *map++;
    } while(speed >= *map++);
    return res;
}

702
static const int thresh_mult_map_znn[] = {
703
704
705
706
    /* map common to zero, nearest, and near */
    0, GOOD(2), 1500, GOOD(3), 2000, RT(0), 1000, RT(2), 2000, INT_MAX
};

707
static const int thresh_mult_map_vhpred[] = {
708
709
710
711
    1000, GOOD(2), 1500, GOOD(3), 2000, RT(0), 1000, RT(1), 2000,
    RT(7), INT_MAX, INT_MAX
};

712
static const int thresh_mult_map_bpred[] = {
713
714
715
716
    2000, GOOD(0), 2500, GOOD(2), 5000, GOOD(3), 7500, RT(0), 2500, RT(1), 5000,
    RT(6), INT_MAX, INT_MAX
};

717
static const int thresh_mult_map_tm[] = {
718
719
720
721
    1000, GOOD(2), 1500, GOOD(3), 2000, RT(0), 0, RT(1), 1000, RT(2), 2000,
    RT(7), INT_MAX, INT_MAX
};

722
static const int thresh_mult_map_new1[] = {
723
724
725
    1000, GOOD(2), 2000, RT(0), 2000, INT_MAX
};

726
static const int thresh_mult_map_new2[] = {
727
728
729
730
    1000, GOOD(2), 2000, GOOD(3), 2500, GOOD(5), 4000, RT(0), 2000, RT(2), 2500,
    RT(5), 4000, INT_MAX
};

731
static const int thresh_mult_map_split1[] = {
732
733
734
735
    2500, GOOD(0), 1700, GOOD(2), 10000, GOOD(3), 25000, GOOD(4), INT_MAX,
    RT(0), 5000, RT(1), 10000, RT(2), 25000, RT(3), INT_MAX, INT_MAX
};

736
static const int thresh_mult_map_split2[] = {
737
738
739
740
    5000, GOOD(0), 4500, GOOD(2), 20000, GOOD(3), 50000, GOOD(4), INT_MAX,
    RT(0), 10000, RT(1), 20000, RT(2), 50000, RT(3), INT_MAX, INT_MAX
};

741
static const int mode_check_freq_map_zn2[] = {
742
743
744
745
    /* {zero,nearest}{2,3} */
    0, RT(10), 1<<1, RT(11), 1<<2, RT(12), 1<<3, INT_MAX
};

746
static const int mode_check_freq_map_vhbpred[] = {
747
748
749
    0, GOOD(5), 2, RT(0), 0, RT(3), 2, RT(5), 4, INT_MAX
};

750
static const int mode_check_freq_map_near2[] = {
751
752
753
754
    0, GOOD(5), 2, RT(0), 0, RT(3), 2, RT(10), 1<<2, RT(11), 1<<3, RT(12), 1<<4,
    INT_MAX
};

755
static const int mode_check_freq_map_new1[] = {
756
757
758
    0, RT(10), 1<<1, RT(11), 1<<2, RT(12), 1<<3, INT_MAX
};

759
static const int mode_check_freq_map_new2[] = {
760
761
762
763
    0, GOOD(5), 4, RT(0), 0, RT(3), 4, RT(10), 1<<3, RT(11), 1<<4, RT(12), 1<<5,
    INT_MAX
};

764
static const int mode_check_freq_map_split1[] = {
765
766
767
    0, GOOD(2), 2, GOOD(3), 7, RT(1), 2, RT(2), 7, INT_MAX
};

768
static const int mode_check_freq_map_split2[] = {
769
770
771
    0, GOOD(1), 2, GOOD(2), 4, GOOD(3), 15, RT(1), 4, RT(2), 15, INT_MAX
};

John Koleszar's avatar
John Koleszar committed
772
773
774
775
776
777
778
void vp8_set_speed_features(VP8_COMP *cpi)
{
    SPEED_FEATURES *sf = &cpi->sf;
    int Mode = cpi->compressor_speed;
    int Speed = cpi->Speed;
    int i;
    VP8_COMMON *cm = &cpi->common;
779
    int last_improved_quant = sf->improved_quant;
780
    int ref_frames;
John Koleszar's avatar
John Koleszar committed
781

John Koleszar's avatar
John Koleszar committed
782
    /* Initialise default mode frequency sampling variables */
John Koleszar's avatar
John Koleszar committed
783
784
785
786
787
    for (i = 0; i < MAX_MODES; i ++)
    {
        cpi->mode_check_freq[i] = 0;
    }

788
    cpi->mb.mbs_tested_so_far = 0;
John Koleszar's avatar
John Koleszar committed
789

John Koleszar's avatar
John Koleszar committed
790
    /* best quality defaults */
John Koleszar's avatar
John Koleszar committed
791
792
793
794
795
796
797
798
799
800
    sf->RD = 1;
    sf->search_method = NSTEP;
    sf->improved_quant = 1;
    sf->improved_dct = 1;
    sf->auto_filter = 1;
    sf->recode_loop = 1;
    sf->quarter_pixel_search = 1;
    sf->half_pixel_search = 1;
    sf->iterative_sub_pixel = 1;
    sf->optimize_coefficients = 1;
801
    sf->use_fastquant_for_pick = 0;
802
    sf->no_skip_block4x4_search = 1;
John Koleszar's avatar
John Koleszar committed
803
804
805

    sf->first_step = 0;
    sf->max_step_search_steps = MAX_MVSEARCH_STEPS;
806
    sf->improved_mv_pred = 1;
John Koleszar's avatar
John Koleszar committed
807

John Koleszar's avatar
John Koleszar committed
808
    /* default thresholds to 0 */
John Koleszar's avatar
John Koleszar committed
809
810
811
    for (i = 0; i < MAX_MODES; i++)
        sf->thresh_mult[i] = 0;

812
813
    /* Count enabled references */
    ref_frames = 1;
Johann's avatar
Johann committed
814
    if (cpi->ref_frame_flags & VP8_LAST_FRAME)
815
        ref_frames++;
Johann's avatar
Johann committed
816
    if (cpi->ref_frame_flags & VP8_GOLD_FRAME)
817
        ref_frames++;
Johann's avatar
Johann committed
818
    if (cpi->ref_frame_flags & VP8_ALTR_FRAME)
819
820
        ref_frames++;

821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
    /* Convert speed to continuous range, with clamping */
    if (Mode == 0)
        Speed = 0;
    else if (Mode == 2)
        Speed = RT(Speed);
    else
    {
        if (Speed > 5)
            Speed = 5;
        Speed = GOOD(Speed);
    }

    sf->thresh_mult[THR_ZERO1] =
    sf->thresh_mult[THR_NEAREST1] =
    sf->thresh_mult[THR_NEAR1] =
    sf->thresh_mult[THR_DC] = 0; /* always */

    sf->thresh_mult[THR_ZERO2] =
    sf->thresh_mult[THR_ZERO3] =
    sf->thresh_mult[THR_NEAREST2] =
    sf->thresh_mult[THR_NEAREST3] =
    sf->thresh_mult[THR_NEAR2]  =
    sf->thresh_mult[THR_NEAR3]  = speed_map(Speed, thresh_mult_map_znn);

    sf->thresh_mult[THR_V_PRED] =
    sf->thresh_mult[THR_H_PRED] = speed_map(Speed, thresh_mult_map_vhpred);
    sf->thresh_mult[THR_B_PRED] = speed_map(Speed, thresh_mult_map_bpred);
    sf->thresh_mult[THR_TM]     = speed_map(Speed, thresh_mult_map_tm);
    sf->thresh_mult[THR_NEW1]   = speed_map(Speed, thresh_mult_map_new1);
    sf->thresh_mult[THR_NEW2]   =
    sf->thresh_mult[THR_NEW3]   = speed_map(Speed, thresh_mult_map_new2);
    sf->thresh_mult[THR_SPLIT1] = speed_map(Speed, thresh_mult_map_split1);
    sf->thresh_mult[THR_SPLIT2] =
    sf->thresh_mult[THR_SPLIT3] = speed_map(Speed, thresh_mult_map_split2);

856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
    cpi->mode_check_freq[THR_ZERO1] =
    cpi->mode_check_freq[THR_NEAREST1] =
    cpi->mode_check_freq[THR_NEAR1] =
    cpi->mode_check_freq[THR_TM]     =
    cpi->mode_check_freq[THR_DC] = 0; /* always */

    cpi->mode_check_freq[THR_ZERO2] =
    cpi->mode_check_freq[THR_ZERO3] =
    cpi->mode_check_freq[THR_NEAREST2] =
    cpi->mode_check_freq[THR_NEAREST3] = speed_map(Speed,
                                                   mode_check_freq_map_zn2);

    cpi->mode_check_freq[THR_NEAR2]  =
    cpi->mode_check_freq[THR_NEAR3]  = speed_map(Speed,
                                                 mode_check_freq_map_near2);

    cpi->mode_check_freq[THR_V_PRED] =
    cpi->mode_check_freq[THR_H_PRED] =
    cpi->mode_check_freq[THR_B_PRED] = speed_map(Speed,
                                                 mode_check_freq_map_vhbpred);
    cpi->mode_check_freq[THR_NEW1]   = speed_map(Speed,
                                                 mode_check_freq_map_new1);
    cpi->mode_check_freq[THR_NEW2]   =
    cpi->mode_check_freq[THR_NEW3]   = speed_map(Speed,
                                                 mode_check_freq_map_new2);
    cpi->mode_check_freq[THR_SPLIT1] = speed_map(Speed,
                                                 mode_check_freq_map_split1);
    cpi->mode_check_freq[THR_SPLIT2] =
    cpi->mode_check_freq[THR_SPLIT3] = speed_map(Speed,
                                                 mode_check_freq_map_split2);
886
    Speed = cpi->Speed;
John Koleszar's avatar
John Koleszar committed
887
888
889
    switch (Mode)
    {
#if !(CONFIG_REALTIME_ONLY)
John Koleszar's avatar
John Koleszar committed
890
    case 0: /* best quality mode */
John Koleszar's avatar
John Koleszar committed
891
892
893
894
895
        sf->first_step = 0;
        sf->max_step_search_steps = MAX_MVSEARCH_STEPS;
        break;
    case 1:
    case 3:
896
        if (Speed > 0)
John Koleszar's avatar
John Koleszar committed
897
        {
898
899
900
901
            /* Disable coefficient optimization above speed 0 */
            sf->optimize_coefficients = 0;
            sf->use_fastquant_for_pick = 1;
            sf->no_skip_block4x4_search = 0;
902

903
            sf->first_step = 1;
John Koleszar's avatar
John Koleszar committed
904
905
        }

906
        if (Speed > 2)
John Koleszar's avatar
John Koleszar committed
907
        {
908
909
910
            sf->improved_quant = 0;
            sf->improved_dct = 0;

John Koleszar's avatar
John Koleszar committed
911
912
913
            /* Only do recode loop on key frames, golden frames and
             * alt ref frames
             */
John Koleszar's avatar
John Koleszar committed
914
915
916
917
            sf->recode_loop = 2;

        }

918
        if (Speed > 3)
John Koleszar's avatar
John Koleszar committed
919
920
        {
            sf->auto_filter = 1;
John Koleszar's avatar
John Koleszar committed
921
922
            sf->recode_loop = 0; /* recode loop off */
            sf->RD = 0;         /* Turn rd off */
923

John Koleszar's avatar
John Koleszar committed
924
925
926
927
        }

        if (Speed > 4)
        {
John Koleszar's avatar
John Koleszar committed
928
            sf->auto_filter = 0;  /* Faster selection of loop filter */
John Koleszar's avatar
John Koleszar committed
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
        }

        break;
#endif
    case 2:
        sf->optimize_coefficients = 0;
        sf->recode_loop = 0;
        sf->auto_filter = 1;
        sf->iterative_sub_pixel = 1;
        sf->search_method = NSTEP;

        if (Speed > 0)
        {
            sf->improved_quant = 0;
            sf->improved_dct = 0;
944
945
946
947

            sf->use_fastquant_for_pick = 1;
            sf->no_skip_block4x4_search = 0;
            sf->first_step = 1;
John Koleszar's avatar
John Koleszar committed
948
949
950
        }

        if (Speed > 2)
John Koleszar's avatar
John Koleszar committed
951
            sf->auto_filter = 0;  /* Faster selection of loop filter */
John Koleszar's avatar
John Koleszar committed
952
953
954
955
956
957
958
959
960

        if (Speed > 3)
        {
            sf->RD = 0;
            sf->auto_filter = 1;
        }

        if (Speed > 4)
        {
John Koleszar's avatar
John Koleszar committed
961
            sf->auto_filter = 0;  /* Faster selection of loop filter */
John Koleszar's avatar
John Koleszar committed
962
            sf->search_method = HEX;
963
            sf->iterative_sub_pixel = 0;
John Koleszar's avatar
John Koleszar committed
964
965
966
967
        }

        if (Speed > 6)
        {
968
            unsigned int sum = 0;
John Koleszar's avatar
John Koleszar committed
969
            unsigned int total_mbs = cm->MBs;
970
            int thresh;
971
            unsigned int total_skip;
John Koleszar's avatar
John Koleszar committed
972
973
974
975
976
977
978
979
980
981

            int min = 2000;

            if (cpi->oxcf.encode_breakout > 2000)
                min = cpi->oxcf.encode_breakout;

            min >>= 7;

            for (i = 0; i < min; i++)
            {
982
                sum += cpi->mb.error_bins[i];
John Koleszar's avatar
John Koleszar committed
983
984
985
986
987
            }

            total_skip = sum;
            sum = 0;

John Koleszar's avatar
John Koleszar committed
988
            /* i starts from 2 to make sure thresh started from 2048 */
John Koleszar's avatar
John Koleszar committed
989
990
            for (; i < 1024; i++)
            {
991
                sum += cpi->mb.error_bins[i];
John Koleszar's avatar
John Koleszar committed
992
993
994
995
996
997
998
999
1000
1001
1002

                if (10 * sum >= (unsigned int)(cpi->Speed - 6)*(total_mbs - total_skip))
                    break;
            }

            i--;
            thresh = (i << 7);

            if (thresh < 2000)
                thresh = 2000;

1003
            if (ref_frames > 1)
John Koleszar's avatar
John Koleszar committed
1004
            {
1005
1006
1007
                sf->thresh_mult[THR_NEW1 ] = thresh;
                sf->thresh_mult[THR_NEAREST1  ] = thresh >> 1;
                sf->thresh_mult[THR_NEAR1     ] = thresh >> 1;
John Koleszar's avatar
John Koleszar committed
1008
1009
            }

1010
            if (ref_frames > 2)
John Koleszar's avatar
John Koleszar committed
1011
            {
1012
1013
1014
                sf->thresh_mult[THR_NEW2] = thresh << 1;
                sf->thresh_mult[THR_NEAREST2 ] = thresh;
                sf->thresh_mult[THR_NEAR2    ] = thresh;
John Koleszar's avatar
John Koleszar committed
1015
1016
            }

1017
            if (ref_frames > 3)
John Koleszar's avatar
John Koleszar committed
1018
            {
1019
1020
1021
                sf->thresh_mult[THR_NEW3] = thresh << 1;
                sf->thresh_mult[THR_NEAREST3 ] = thresh;
                sf->thresh_mult[THR_NEAR3    ] = thresh;
John Koleszar's avatar
John Koleszar committed
1022
1023
            }

1024
            sf->improved_mv_pred = 0;
John Koleszar's avatar
John Koleszar committed
1025
1026
1027
1028
1029
        }

        if (Speed > 8)
            sf->quarter_pixel_search = 0;

1030
1031
1032
        if(cm->version == 0)
        {
            cm->filter_type = NORMAL_LOOPFILTER;
John Koleszar's avatar
John Koleszar committed
1033

1034
1035
1036
1037
1038
            if (Speed >= 14)
                cm->filter_type = SIMPLE_LOOPFILTER;
        }
        else
        {
John Koleszar's avatar
John Koleszar committed
1039
            cm->filter_type = SIMPLE_LOOPFILTER;
1040
        }
John Koleszar's avatar
John Koleszar committed
1041

John Koleszar's avatar
John Koleszar committed
1042
        /* This has a big hit on quality. Last resort */
John Koleszar's avatar
John Koleszar committed
1043
        if (Speed >= 15)
1044
            sf->half_pixel_search = 0;
John Koleszar's avatar
John Koleszar committed
1045

1046
        vpx_memset(cpi->mb.error_bins, 0, sizeof(cpi->mb.error_bins));
John Koleszar's avatar
John Koleszar committed
1047

1048
1049
    }; /* switch */

John Koleszar's avatar
John Koleszar committed
1050
1051
1052
    /* Slow quant, dct and trellis not worthwhile for first pass
     * so make sure they are always turned off.
     */
1053
1054
1055
1056
1057
1058
1059
    if ( cpi->pass == 1 )
    {
        sf->improved_quant = 0;
        sf->optimize_coefficients = 0;
        sf->improved_dct = 0;
    }

John Koleszar's avatar
John Koleszar committed
1060
1061
    if (cpi->sf.search_method == NSTEP)
    {
1062
        vp8_init3smotion_compensation(&cpi->mb, cm->yv12_fb[cm->lst_fb_idx].y_stride);
John Koleszar's avatar
John Koleszar committed
1063
1064
1065
    }
    else if (cpi->sf.search_method == DIAMOND)
    {
1066
        vp8_init_dsmotion_compensation(&cpi->mb, cm->yv12_fb[cm->lst_fb_idx].y_stride);
John Koleszar's avatar
John Koleszar committed
1067
1068
1069
1070
    }

    if (cpi->sf.improved_dct)
    {
John Koleszar's avatar
John Koleszar committed
1071
1072
        cpi->mb.short_fdct8x4 = vp8_short_fdct8x4;
        cpi->mb.short_fdct4x4 = vp8_short_fdct4x4;
John Koleszar's avatar
John Koleszar committed
1073
1074
1075
    }
    else
    {
John Koleszar's avatar
John Koleszar committed
1076
1077
1078
        /* No fast FDCT defined for any platform at this time. */
        cpi->mb.short_fdct8x4 = vp8_short_fdct8x4;
        cpi->mb.short_fdct4x4 = vp8_short_fdct4x4;
John Koleszar's avatar
John Koleszar committed
1079
1080
    }

John Koleszar's avatar
John Koleszar committed
1081
    cpi->mb.short_walsh4x4 = vp8_short_walsh4x4;
John Koleszar's avatar
John Koleszar committed
1082
1083
1084

    if (cpi->sf.improved_quant)
    {
John Koleszar's avatar
John Koleszar committed
1085
1086
        cpi->mb.quantize_b      = vp8_regular_quantize_b;
        cpi->mb.quantize_b_pair = vp8_regular_quantize_b_pair;
John Koleszar's avatar
John Koleszar committed
1087
1088
1089
    }
    else
    {
John Koleszar's avatar
John Koleszar committed
1090
1091
        cpi->mb.quantize_b      = vp8_fast_quantize_b;
        cpi->mb.quantize_b_pair = vp8_fast_quantize_b_pair;
John Koleszar's avatar
John Koleszar committed
1092
    }
1093
1094
    if (cpi->sf.improved_quant != last_improved_quant)
        vp8cx_init_quantizer(cpi);
John Koleszar's avatar
John Koleszar committed
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112

    if (cpi->sf.iterative_sub_pixel == 1)
    {
        cpi->find_fractional_mv_step = vp8_find_best_sub_pixel_step_iteratively;
    }
    else if (cpi->sf.quarter_pixel_search)
    {
        cpi->find_fractional_mv_step = vp8_find_best_sub_pixel_step;
    }
    else if (cpi->sf.half_pixel_search)
    {
        cpi->find_fractional_mv_step = vp8_find_best_half_pixel_step;
    }
    else
    {
        cpi->find_fractional_mv_step = vp8_skip_fractional_mv_step;
    }

1113
    if (cpi->sf.optimize_coefficients == 1 && cpi->pass!=1)
Yaowu Xu's avatar
Yaowu Xu committed
1114
        cpi->mb.optimize = 1;
John Koleszar's avatar
John Koleszar committed
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
    else
        cpi->mb.optimize = 0;

    if (cpi->common.full_pixel)
        cpi->find_fractional_mv_step = vp8_skip_fractional_mv_step;

#ifdef SPEEDSTATS
    frames_at_speed[cpi->Speed]++;
#endif
}
1125
1126
1127
#undef GOOD
#undef RT

John Koleszar's avatar
John Koleszar committed
1128
1129
static void alloc_raw_frame_buffers(VP8_COMP *cpi)
{
Attila Nagy's avatar
Attila Nagy committed
1130
#if VP8_TEMPORAL_ALT_REF
1131
    int width = (cpi->oxcf.Width + 15) & ~15;
John Koleszar's avatar
John Koleszar committed
1132
    int height = (cpi->oxcf.Height + 15) & ~15;
Attila Nagy's avatar
Attila Nagy committed
1133
#endif
John Koleszar's avatar
John Koleszar committed
1134

John Koleszar's avatar
John Koleszar committed
1135
1136
1137
1138
1139
    cpi->lookahead = vp8_lookahead_init(cpi->oxcf.Width, cpi->oxcf.Height,
                                        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
1140
1141
1142

#if VP8_TEMPORAL_ALT_REF

John Koleszar's avatar
John Koleszar committed
1143
    if (vp8_yv12_alloc_frame_buffer(&cpi->alt_ref_buffer,
1144
                                    width, height, VP8BORDERINPIXELS))
John Koleszar's avatar
John Koleszar committed
1145
1146
1147
1148
1149
        vpx_internal_error(&cpi->common.error, VPX_CODEC_MEM_ERROR,
                           "Failed to allocate altref buffer");

#endif
}