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

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

49 50 51 52 53
#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
54 55 56 57 58 59 60 61
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();
62
extern int vp8cx_create_encoder_threads(VP8_COMP *cpi);
John Koleszar's avatar
John Koleszar committed
63 64 65
extern void vp8cx_remove_encoder_threads(VP8_COMP *cpi);

int vp8_estimate_entropy_savings(VP8_COMP *cpi);
66

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

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

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

extern const int vp8_gf_interval_table[101];

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

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

86

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


#endif


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

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

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


119
#ifdef VP8_ENTROPY_STATS
John Koleszar's avatar
John Koleszar committed
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 147 148
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];

149
/* Tables relating active max Q to active min Q */
150
static const unsigned char kf_low_motion_minq[QINDEX_RANGE] =
151
{
Paul Wilkins's avatar
Paul Wilkins committed
152 153 154 155 156 157 158 159
    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
160
};
161
static const unsigned char kf_high_motion_minq[QINDEX_RANGE] =
162
{
Paul Wilkins's avatar
Paul Wilkins committed
163 164 165 166 167 168 169 170
    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
171
};
172
static const unsigned char gf_low_motion_minq[QINDEX_RANGE] =
173 174 175 176 177 178 179 180 181 182
{
    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
};
183
static const unsigned char gf_mid_motion_minq[QINDEX_RANGE] =
184 185 186 187 188 189 190 191
{
    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
Paul Wilkins committed
192
    49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64
193
};
194
static const unsigned char gf_high_motion_minq[QINDEX_RANGE] =
195 196 197 198 199 200 201 202
{
    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
Paul Wilkins committed
203
    55,56,57,58,59,60,62,64,66,68,70,72,74,76,78,80
204
};
205
static const unsigned char inter_minq[QINDEX_RANGE] =
206
{
207 208 209 210 211 212 213 214
    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
215
};
John Koleszar's avatar
John Koleszar committed
216 217 218 219 220

#ifdef PACKET_TESTING
extern FILE *vpxlogc;
#endif

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

225
    /* Save layer dependent coding state */
226 227 228 229
    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;
230 231 232
    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;
233 234 235 236 237 238 239 240 241 242 243 244 245 246
    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;
247
    lc->zbin_over_quant                  = cpi->mb.zbin_over_quant;
248 249 250 251 252 253 254
    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,
255 256
            cpi->mb.count_mb_ref_frame_usage,
            sizeof(cpi->mb.count_mb_ref_frame_usage));
257 258 259 260 261 262
}

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

263
    /* Restore layer dependent coding state */
264 265 266 267 268 269
    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;
270 271 272
    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;
273 274 275 276 277 278 279 280 281 282 283 284
    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;
285
    cpi->mb.zbin_over_quant                  = lc->zbin_over_quant;
286 287 288 289 290 291
    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;

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

297 298 299 300 301 302 303 304 305 306 307 308
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,
309
                                        double prev_layer_framerate)
310 311 312
{
    LAYER_CONTEXT *lc = &cpi->layer_context[layer];

313
    lc->framerate = cpi->output_framerate / cpi->oxcf.rate_decimator[layer];
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 341 342
    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 /
343
                (lc->framerate - prev_layer_framerate));
344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369

     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)
{
370
    int i;
371
    double prev_layer_framerate = 0;
372 373 374 375 376 377 378 379 380 381 382 383 384
    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)
        {
385
           init_temporal_layer_context(cpi, oxcf, i, prev_layer_framerate);
386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410
        }
        // 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);
        }
411 412
        prev_layer_framerate = cpi->output_framerate /
                               cpi->oxcf.rate_decimator[i];
413 414 415
    }
}

John Koleszar's avatar
John Koleszar committed
416 417
static void setup_features(VP8_COMP *cpi)
{
418 419 420 421 422 423 424 425 426 427 428
    // 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
429 430 431

    cpi->mb.e_mbd.mode_ref_lf_delta_enabled = 0;
    cpi->mb.e_mbd.mode_ref_lf_delta_update = 0;
James Zern's avatar
James Zern committed
432 433 434 435
    memset(cpi->mb.e_mbd.ref_lf_deltas, 0, sizeof(cpi->mb.e_mbd.ref_lf_deltas));
    memset(cpi->mb.e_mbd.mode_lf_deltas, 0, sizeof(cpi->mb.e_mbd.mode_lf_deltas));
    memset(cpi->mb.e_mbd.last_ref_lf_deltas, 0, sizeof(cpi->mb.e_mbd.ref_lf_deltas));
    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
436

437
    set_default_lf_deltas(cpi);
John Koleszar's avatar
John Koleszar committed
438 439 440 441

}


442 443 444
static void dealloc_raw_frame_buffers(VP8_COMP *cpi);


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

450
    /* Delete last frame MV storage buffers */
451
    vpx_free(cpi->lfmv);
452 453
    cpi->lfmv = 0;

454
    vpx_free(cpi->lf_ref_frame_sign_bias);
455 456
    cpi->lf_ref_frame_sign_bias = 0;

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

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

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

    vp8_de_alloc_frame_buffers(&cpi->common);

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

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

476
    /* Structure used to monitor GF usage */
477
    vpx_free(cpi->gf_active_flags);
478 479
    cpi->gf_active_flags = 0;

480
    /* Activity mask based per mb zbin adjustments */
481 482 483
    vpx_free(cpi->mb_activity_map);
    cpi->mb_activity_map = 0;

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

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

493
static void enable_segmentation(VP8_COMP *cpi)
John Koleszar's avatar
John Koleszar committed
494
{
495
    /* Set the appropriate feature bit */
John Koleszar's avatar
John Koleszar committed
496 497 498 499
    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;
}
500
static void disable_segmentation(VP8_COMP *cpi)
John Koleszar's avatar
John Koleszar committed
501
{
502
    /* Clear the appropriate feature bit */
John Koleszar's avatar
John Koleszar committed
503 504 505
    cpi->mb.e_mbd.segmentation_enabled = 0;
}

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

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

519 520 521 522 523 524 525 526 527 528 529 530
/* 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).
 *
 */
531
static void set_segment_data(VP8_COMP *cpi, signed char *feature_data, unsigned char abs_delta)
John Koleszar's avatar
John Koleszar committed
532 533
{
    cpi->mb.e_mbd.mb_segement_abs_delta = abs_delta;
James Zern's avatar
James Zern committed
534
    memcpy(cpi->segment_feature_data, feature_data, sizeof(cpi->segment_feature_data));
John Koleszar's avatar
John Koleszar committed
535 536 537
}


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

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

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

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

552
    // Set up the quant segment data
John Koleszar's avatar
John Koleszar committed
553 554 555 556
    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;
557
    // Set up the loop segment data
John Koleszar's avatar
John Koleszar committed
558 559 560 561 562
    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;

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

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

    seg_map = 0;
}

573
/* A simple function to cyclically refresh the background at a lower Q */
John Koleszar's avatar
John Koleszar committed
574 575
static void cyclic_background_refresh(VP8_COMP *cpi, int Q, int lf_adjustment)
{
576
    unsigned char *seg_map = cpi->segmentation_map;
John Koleszar's avatar
John Koleszar committed
577 578 579 580 581
    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;

582
    cpi->cyclic_refresh_q = Q / 2;
John Koleszar's avatar
John Koleszar committed
583

Marco's avatar
Marco committed
584 585 586 587 588 589
    if (cpi->oxcf.screen_content_mode) {
      // Modify quality ramp-up based on Q. Above some Q level, increase the
      // number of blocks to be refreshed, and reduce it below the thredhold.
      // Turn-off under certain conditions (i.e., away from key frame, and if
      // we are at good quality (low Q) and most of the blocks were skipped-encoded
      // in previous frame.
590 591
      int qp_thresh = (cpi->oxcf.screen_content_mode == 2) ? 80 : 100;
      if (Q >= qp_thresh) {
Marco's avatar
Marco committed
592 593 594 595 596 597 598 599 600 601 602 603 604
        cpi->cyclic_refresh_mode_max_mbs_perframe =
            (cpi->common.mb_rows * cpi->common.mb_cols) / 10;
      } else if (cpi->frames_since_key > 250 &&
                 Q < 20 &&
                 cpi->mb.skip_true_count > (int)(0.95 * mbs_in_frame)) {
        cpi->cyclic_refresh_mode_max_mbs_perframe = 0;
      } else {
        cpi->cyclic_refresh_mode_max_mbs_perframe =
            (cpi->common.mb_rows * cpi->common.mb_cols) / 20;
      }
      block_count = cpi->cyclic_refresh_mode_max_mbs_perframe;
    }

605 606
    // Set every macroblock to be eligible for update.
    // For key frame this will reset seg map to 0.
James Zern's avatar
James Zern committed
607
    memset(cpi->segmentation_map, 0, mbs_in_frame);
608

Marco's avatar
Marco committed
609
    if (cpi->common.frame_type != KEY_FRAME && block_count > 0)
John Koleszar's avatar
John Koleszar committed
610
    {
611 612
        /* Cycle through the macro_block rows */
        /* MB loop to set local segmentation map */
613
        i = cpi->cyclic_refresh_mode_index;
614
        assert(i < mbs_in_frame);
615
        do
John Koleszar's avatar
John Koleszar committed
616
        {
617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633
          /* 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
634 635

        }
636
        while(block_count && i != cpi->cyclic_refresh_mode_index);
John Koleszar's avatar
John Koleszar committed
637 638

        cpi->cyclic_refresh_mode_index = i;
639 640

#if CONFIG_TEMPORAL_DENOISING
641 642
        if (cpi->oxcf.noise_sensitivity > 0) {
          if (cpi->denoiser.denoiser_mode == kDenoiserOnYUVAggressive &&
Marco's avatar
Marco committed
643 644 645
              Q < (int)cpi->denoiser.denoise_pars.qp_thresh &&
              (cpi->frames_since_key >
               2 * cpi->denoiser.denoise_pars.consec_zerolast)) {
646
            // Under aggressive denoising, use segmentation to turn off loop
Marco's avatar
Marco committed
647
            // filter below some qp thresh. The filter is reduced for all
648 649 650 651 652
            // 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;
Marco's avatar
Marco committed
653 654
            // lf_adjustment = -MAX_LOOP_FILTER;
            lf_adjustment = -40;
655 656 657 658
            for (i = 0; i < mbs_in_frame; ++i) {
              seg_map[i] = (cpi->consec_zero_last[i] >
                            cpi->denoiser.denoise_pars.consec_zerolast) ? 1 : 0;
            }
659 660 661
          }
        }
#endif
John Koleszar's avatar
John Koleszar committed
662 663
    }

664
    /* Activate segmentation. */
665 666
    cpi->mb.e_mbd.update_mb_segmentation_map = 1;
    cpi->mb.e_mbd.update_mb_segmentation_data = 1;
667
    enable_segmentation(cpi);
John Koleszar's avatar
John Koleszar committed
668

669
    /* Set up the quant segment data */
John Koleszar's avatar
John Koleszar committed
670 671 672 673 674
    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;

675
    /* Set up the loop segment data */
John Koleszar's avatar
John Koleszar committed
676 677 678 679 680
    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;

681
    /* Initialise the feature data structure */
682
    set_segment_data(cpi, &feature_data[0][0], SEGMENT_DELTADATA);
John Koleszar's avatar
John Koleszar committed
683 684 685

}

686
static void set_default_lf_deltas(VP8_COMP *cpi)
John Koleszar's avatar
John Koleszar committed
687 688 689 690
{
    cpi->mb.e_mbd.mode_ref_lf_delta_enabled = 1;
    cpi->mb.e_mbd.mode_ref_lf_delta_update = 1;

James Zern's avatar
James Zern committed
691 692
    memset(cpi->mb.e_mbd.ref_lf_deltas, 0, sizeof(cpi->mb.e_mbd.ref_lf_deltas));
    memset(cpi->mb.e_mbd.mode_lf_deltas, 0, sizeof(cpi->mb.e_mbd.mode_lf_deltas));
John Koleszar's avatar
John Koleszar committed
693

694
    /* Test of ref frame deltas */
John Koleszar's avatar
John Koleszar committed
695 696 697 698 699
    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;

700
    cpi->mb.e_mbd.mode_lf_deltas[0] = 4;               /* BPRED */
701 702 703 704 705 706

    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 */

707 708
    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
709 710
}

711 712 713 714 715 716
/* Convenience macros for mapping speed and mode into a continuous
 * range
 */
#define GOOD(x) (x+1)
#define RT(x) (x+7)

717
static int speed_map(int speed, const int *map)
718 719 720 721 722 723 724 725 726 727
{
    int res;

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

728
static const int thresh_mult_map_znn[] = {
729 730 731 732
    /* map common to zero, nearest, and near */
    0, GOOD(2), 1500, GOOD(3), 2000, RT(0), 1000, RT(2), 2000, INT_MAX
};

733
static const int thresh_mult_map_vhpred[] = {
734 735 736 737
    1000, GOOD(2), 1500, GOOD(3), 2000, RT(0), 1000, RT(1), 2000,
    RT(7), INT_MAX, INT_MAX
};

738
static const int thresh_mult_map_bpred[] = {
739 740 741 742
    2000, GOOD(0), 2500, GOOD(2), 5000, GOOD(3), 7500, RT(0), 2500, RT(1), 5000,
    RT(6), INT_MAX, INT_MAX
};

743
static const int thresh_mult_map_tm[] = {
744 745 746 747
    1000, GOOD(2), 1500, GOOD(3), 2000, RT(0), 0, RT(1), 1000, RT(2), 2000,
    RT(7), INT_MAX, INT_MAX
};

748
static const int thresh_mult_map_new1[] = {
749 750 751
    1000, GOOD(2), 2000, RT(0), 2000, INT_MAX
};

752
static const int thresh_mult_map_new2[] = {
753 754 755 756
    1000, GOOD(2), 2000, GOOD(3), 2500, GOOD(5), 4000, RT(0), 2000, RT(2), 2500,
    RT(5), 4000, INT_MAX
};

757
static const int thresh_mult_map_split1[] = {
758 759 760 761
    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
};

762
static const int thresh_mult_map_split2[] = {
763 764 765 766
    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
};

767
static const int mode_check_freq_map_zn2[] = {
768 769 770 771
    /* {zero,nearest}{2,3} */
    0, RT(10), 1<<1, RT(11), 1<<2, RT(12), 1<<3, INT_MAX
};

772
static const int mode_check_freq_map_vhbpred[] = {
773 774 775
    0, GOOD(5), 2, RT(0), 0, RT(3), 2, RT(5), 4, INT_MAX
};

776
static const int mode_check_freq_map_near2[] = {
777 778 779 780
    0, GOOD(5), 2, RT(0), 0, RT(3), 2, RT(10), 1<<2, RT(11), 1<<3, RT(12), 1<<4,
    INT_MAX
};

781
static const int mode_check_freq_map_new1[] = {
782 783 784
    0, RT(10), 1<<1, RT(11), 1<<2, RT(12), 1<<3, INT_MAX
};

785
static const int mode_check_freq_map_new2[] = {
786 787 788 789
    0, GOOD(5), 4, RT(0), 0, RT(3), 4, RT(10), 1<<3, RT(11), 1<<4, RT(12), 1<<5,
    INT_MAX
};

790
static const int mode_check_freq_map_split1[] = {
791 792 793
    0, GOOD(2), 2, GOOD(3), 7, RT(1), 2, RT(2), 7, INT_MAX
};

794
static const int mode_check_freq_map_split2[] = {
795 796 797
    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
798 799 800 801 802 803 804
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;
805
    int last_improved_quant = sf->improved_quant;
806
    int ref_frames;
John Koleszar's avatar
John Koleszar committed
807

808
    /* Initialise default mode frequency sampling variables */
John Koleszar's avatar
John Koleszar committed
809 810 811 812 813
    for (i = 0; i < MAX_MODES; i ++)
    {
        cpi->mode_check_freq[i] = 0;
    }

814
    cpi->mb.mbs_tested_so_far = 0;
Marco's avatar
Marco committed
815
    cpi->mb.mbs_zero_last_dot_suppress = 0;
John Koleszar's avatar
John Koleszar committed
816

817
    /* best quality defaults */
John Koleszar's avatar
John Koleszar committed
818 819 820 821 822 823 824 825 826 827
    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;
828
    sf->use_fastquant_for_pick = 0;
829
    sf->no_skip_block4x4_search = 1;
John Koleszar's avatar
John Koleszar committed
830 831 832

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

835
    /* default thresholds to 0 */
John Koleszar's avatar
John Koleszar committed
836 837 838
    for (i = 0; i < MAX_MODES; i++)
        sf->thresh_mult[i] = 0;

839 840
    /* Count enabled references */
    ref_frames = 1;
Johann's avatar
Johann committed
841
    if (cpi->ref_frame_flags & VP8_LAST_FRAME)
842
        ref_frames++;
Johann's avatar
Johann committed
843
    if (cpi->ref_frame_flags & VP8_GOLD_FRAME)
844
        ref_frames++;
Johann's avatar
Johann committed
845
    if (cpi->ref_frame_flags & VP8_ALTR_FRAME)
846 847
        ref_frames++;

848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882
    /* 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);

Marco's avatar
Marco committed
883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901
    // Special case for temporal layers.
    // Reduce the thresholds for zero/nearest/near for GOLDEN, if GOLDEN is
    // used as second reference. We don't modify thresholds for ALTREF case
    // since ALTREF is usually used as long-term reference in temporal layers.
    if ((cpi->Speed <= 6) &&
        (cpi->oxcf.number_of_layers > 1) &&
        (cpi->ref_frame_flags & VP8_LAST_FRAME) &&
        (cpi->ref_frame_flags & VP8_GOLD_FRAME)) {
      if (cpi->closest_reference_frame == GOLDEN_FRAME) {
        sf->thresh_mult[THR_ZERO2] =  sf->thresh_mult[THR_ZERO2] >> 3;
        sf->thresh_mult[THR_NEAREST2] = sf->thresh_mult[THR_NEAREST2] >> 3;
        sf->thresh_mult[THR_NEAR2]  = sf->thresh_mult[THR_NEAR2] >> 3;
      } else {
        sf->thresh_mult[THR_ZERO2] =  sf->thresh_mult[THR_ZERO2] >> 1;
        sf->thresh_mult[THR_NEAREST2] = sf->thresh_mult[THR_NEAREST2] >> 1;
        sf->thresh_mult[THR_NEAR2]  = sf->thresh_mult[THR_NEAR2] >> 1;
      }
    }

902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931
    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);
932
    Speed = cpi->Speed;
John Koleszar's avatar
John Koleszar committed
933 934 935
    switch (Mode)
    {
#if !(CONFIG_REALTIME_ONLY)
936
    case 0: /* best quality mode */
John Koleszar's avatar
John Koleszar committed
937 938 939 940 941
        sf->first_step = 0;
        sf->max_step_search_steps = MAX_MVSEARCH_STEPS;
        break;
    case 1:
    case 3:
942
        if (Speed > 0)
John Koleszar's avatar
John Koleszar committed
943
        {
944 945 946 947
            /* Disable coefficient optimization above speed 0 */
            sf->optimize_coefficients = 0;
            sf->use_fastquant_for_pick = 1;
            sf->no_skip_block4x4_search = 0;
948

949
            sf->first_step = 1;
John Koleszar's avatar
John Koleszar committed
950 951
        }

952
        if (Speed > 2)
John Koleszar's avatar
John Koleszar committed
953
        {
954 955 956
            sf->improved_quant = 0;
            sf->improved_dct = 0;

957 958 959
            /* Only do recode loop on key frames, golden frames and
             * alt ref frames
             */
John Koleszar's avatar
John Koleszar committed
960 961 962 963
            sf->recode_loop = 2;

        }

964
        if (Speed > 3)
John Koleszar's avatar
John Koleszar committed
965 966
        {
            sf->auto_filter = 1;
967 968
            sf->recode_loop = 0; /* recode loop off */
            sf->RD = 0;         /* Turn rd off */
969

John Koleszar's avatar
John Koleszar committed
970 971 972 973
        }

        if (Speed > 4)
        {
974
            sf->auto_filter = 0;  /* Faster selection of loop filter */
John Koleszar's avatar
John Koleszar committed
975 976 977 978 979 980 981 982 983 984 985 986 987 988 989
        }

        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;
990 991 992 993

            sf->use_fastquant_for_pick = 1;
            sf->no_skip_block4x4_search = 0;
            sf->first_step = 1;
John Koleszar's avatar
John Koleszar committed
994 995 996
        }

        if (Speed > 2)
997
            sf->auto_filter = 0;  /* Faster selection of loop filter */
John Koleszar's avatar
John Koleszar committed
998 999 1000 1001 1002 1003 1004 1005 1006

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

        if (Speed > 4)
        {
1007
            sf->auto_filter = 0;  /* Faster selection of loop filter */
John Koleszar's avatar
John Koleszar committed
1008
            sf->search_method = HEX;
1009
            sf->iterative_sub_pixel = 0;
John Koleszar's avatar
John Koleszar committed
1010 1011 1012 1013
        }

        if (Speed > 6)
        {
1014
            unsigned int sum = 0;
John Koleszar's avatar
John Koleszar committed
1015
            unsigned int total_mbs = cm->MBs;
1016
            int thresh;
1017
            unsigned int total_skip;
John Koleszar's avatar
John Koleszar committed
1018 1019 1020 1021 1022 1023 1024 1025 1026 1027

            int min = 2000;

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

            min >>= 7;

            for (i = 0; i < min; i++)
            {
1028
                sum += cpi->mb.error_bins[i];
John Koleszar's avatar
John Koleszar committed
1029 1030 1031 1032 1033
            }

            total_skip = sum;
            sum = 0;

1034
            /* i starts from 2 to make sure thresh started from 2048 */
John Koleszar's avatar
John Koleszar committed
1035 1036
            for (; i < 1024; i++)
            {
1037
                sum += cpi->mb.error_bins[i];
John Koleszar's avatar
John Koleszar committed
1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048

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

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

            if (thresh < 2000)
                thresh = 2000;

1049
            if (ref_frames > 1)
John Koleszar's avatar
John Koleszar committed
1050
            {
1051 1052 1053
                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
1054 1055
            }

1056
            if (ref_frames > 2)
John Koleszar's avatar
John Koleszar committed
1057
            {
1058 1059 1060
                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
1061 1062
            }

1063
            if (ref_frames > 3)
John Koleszar's avatar
John Koleszar committed
1064
            {
1065 1066 1067
                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
1068 1069
            }

1070
            sf->improved_mv_pred = 0;
John Koleszar's avatar
John Koleszar committed
1071 1072 1073 1074 1075
        }

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

1076 1077 1078
        if(cm->version == 0)
        {
            cm->filter_type = NORMAL_LOOPFILTER;
John Koleszar's avatar
John Koleszar committed
1079

1080 1081 1082 1083 1084
            if (Speed >= 14)
                cm->filter_type = SIMPLE_LOOPFILTER;
        }
        else
        {
John Koleszar's avatar
John Koleszar committed
1085
            cm->filter_type = SIMPLE_LOOPFILTER;
1086
        }
John Koleszar's avatar
John Koleszar committed
1087

1088
        /* This has a big hit on quality. Last resort */
John Koleszar's avatar
John Koleszar committed
1089
        if (Speed >= 15)
1090
            sf->half_pixel_search = 0;
John Koleszar's avatar
John Koleszar committed
1091

James Zern's avatar
James Zern committed
1092
        memset(cpi->mb.error_bins, 0, sizeof(cpi->mb.error_bins));
John Koleszar's avatar
John Koleszar committed
1093

1094 1095
    }; /* switch */

1096 1097 1098
    /* Slow quant, dct and trellis not worthwhile for first pass
     * so make sure they are always turned off.
     */
1099 1100 1101 1102 1103 1104 1105
    if ( cpi->pass == 1 )
    {
        sf->improved_quant = 0;
        sf->optimize_coefficients = 0;
        sf->improved_dct = 0;
    }

John Koleszar's avatar
John Koleszar committed
1106 1107
    if (cpi->sf.search_method == NSTEP)
    {
1108
        vp8_init3smotion_compensation(&cpi->mb, cm->yv12_fb[cm->lst_fb_idx].y_stride);
John Koleszar's avatar
John Koleszar committed
1109 1110 1111
    }
    else if (cpi->sf.search_method == DIAMOND)
    {
1112
        vp8_init_dsmotion_compensation(&cpi->mb, cm->yv12_fb[cm->lst_fb_idx].y_stride);
John Koleszar's avatar
John Koleszar committed
1113 1114 1115 1116
    }

    if (cpi->sf.improved_dct)
    {
John Koleszar's avatar
John Koleszar committed
1117 1118
        cpi->mb.short_fdct8x4 = vp8_short_fdct8x4;
        cpi->mb.short_fdct4x4 = vp8_short_fdct4x4;
John Koleszar's avatar
John Koleszar committed
1119 1120 1121
    }
    else
    {
John Koleszar's avatar
John Koleszar committed
1122 1123 1124
        /* 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
1125 1126
    }

John Koleszar's avatar
John Koleszar committed
1127
    cpi->mb.short_walsh4x4 = vp8_short_walsh4x4;
John Koleszar's avatar
John Koleszar committed
1128 1129 1130

    if (cpi->sf.improved_quant)
    {
1131
        cpi->mb.quantize_b      = vp8_regular_quantize_b;
John Koleszar's avatar
John Koleszar committed
1132 1133 1134
    }
    else
    {
1135
        cpi->mb.quantize_b      = vp8_fast_quantize_b;
John Koleszar's avatar
John Koleszar committed
1136
    }
1137 1138
    if (cpi->sf.improved_quant != last_improved_quant)
        vp8cx_init_quantizer(cpi);
John Koleszar's avatar
John Koleszar committed
1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156

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

1157
    if (cpi->sf.optimize_coefficients == 1 && cpi->pass!=1)
1158
        cpi->mb.optimize = 1;
John Koleszar's avatar
John Koleszar committed
1159 1160 1161 1162 1163 1164 1165 1166 1167 1168
    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
}
1169 1170 1171
#undef GOOD
#undef RT

John Koleszar's avatar
John Koleszar committed
1172 1173
static void alloc_raw_frame_buffers(VP8_COMP *cpi)
{
Attila Nagy's avatar
Attila Nagy committed
1174
#if VP8_TEMPORAL_ALT_REF
1175
    int width = (cpi->oxcf.Width + 15) & ~15;
1176
    int height = (cpi->oxcf.Height + 15) & ~15;
Attila Nagy's avatar
Attila Nagy committed
1177
#endif
John Koleszar's avatar
John Koleszar committed
1178

1179 1180 1181 1182 1183
    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
1184 1185 1186

#if VP8_TEMPORAL_ALT_REF

1187
    if (vp8_yv12_alloc_frame_buffer(&cpi->alt_ref_buffer,
1188
                                    width, height, VP8BORDERINPIXELS))
John Koleszar's avatar
John Koleszar committed
1189 1190 1191 1192 1193
        vpx_internal_error(&cpi->common.error, VPX_CODEC_MEM_ERROR,
                           "Failed to allocate altref buffer");

#endif
}
1194

1195 1196 1197 1198 1199 1200 1201 1202 1203 1204

static void dealloc_raw_frame_buffers(VP8_COMP *cpi)
{
#if VP8_TEMPORAL_ALT_REF
    vp8_yv12_de_alloc_frame_buffer(&cpi->alt_ref_buffer);
#endif
    vp8_lookahead_destroy(cpi->lookahead);
}


1205 1206
static int vp8_alloc_partition_data(VP8_COMP *cpi)
{
1207 1208
        vpx_free(cpi->mb.pip);

1209 1210 1211 1212
    cpi->mb.pip = vpx_calloc((cpi->common.mb_cols + 1) *
                                (cpi->common.mb_rows + 1),
                                sizeof(PARTITION_INFO));
    if(!cpi->mb.pip)
John Koleszar's avatar
John Koleszar committed
1213
        return 1;
1214 1215 1216 1217 1218 1219

    cpi->mb.pi = cpi->mb.pip + cpi->common.mode_info_stride + 1;

    return 0;
}

John Koleszar's avatar
John Koleszar committed
1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230
void vp8_alloc_compressor_data(VP8_COMP *cpi)
{
    VP8_COMMON *cm = & cpi->common;

    int width = cm->Width;
    int height = cm->Height;

    if (vp8_alloc_frame_buffers(cm, width, height))
        vpx_internal_error(&cpi->common.error, VPX_CODEC_MEM_ERROR,
                           "Failed to allocate frame buffers");

1231 1232 1233 1234 1235
    if (vp8_alloc_partition_data(cpi))
        vpx_internal_error(&cpi->common.error, VPX_CODEC_MEM_ERROR,
                           "Failed to allocate partition data");


John Koleszar's avatar
John Koleszar committed
1236 1237 1238 1239 1240 1241 1242
    if ((width & 0xf) != 0)
        width += 16 - (width & 0xf);

    if ((height & 0xf) != 0)
        height += 16 - (height & 0xf);


1243
    if (vp8_yv12_alloc_frame_buffer(&cpi->pick_lf_lvl_frame,
John Koleszar's avatar
John Koleszar committed
1244 1245 1246 1247
                                    width, height, VP8BORDERINPIXELS))
        vpx_internal_error(&cpi->common.error, VPX_CODEC_MEM_ERROR,
                           "Failed to allocate last frame buffer");

1248 1249
    if (vp8_yv12_alloc_frame_buffer(&cpi->scaled_source,
                                    width, height, VP8BORDERINPIXELS))
John Koleszar's avatar
John Koleszar committed
1250 1251
        vpx_internal_error(&cpi->common.error, VPX_CODEC_MEM_ERROR,
                           "Failed to allocate scaled source buffer");
1252 1253 1254

    vpx_free(cpi->tok);

John Koleszar's avatar
John Koleszar committed
1255
    {
1256 1257 1258
#if CONFIG_REALTIME_ONLY & CONFIG_ONTHEFLY_BITPACKING
        unsigned int tokens = 8 * 24 * 16; /* one MB for each thread */
#else
John Koleszar's avatar
John Koleszar committed
1259
        unsigned int tokens = cm->mb_rows * cm->mb_cols * 24 * 16;
1260
#endif
John Koleszar's avatar
John Koleszar committed
1261 1262 1263
        CHECK_MEM_ERROR(cpi->tok, vpx_calloc(tokens, sizeof(*cpi->tok)));
    }

1264
    /* Data used for real time vc mode to see if gf needs refreshing */
1265
    cpi->zeromv_count = 0;
1266 1267


1268
    /* Structures used to monitor GF usage */
1269 1270
    vpx_free(cpi->gf_active_flags);
    CHECK_MEM_ERROR(cpi->gf_active_flags,
1271 1272
                    vpx_calloc(sizeof(*cpi->gf_active_flags),
                    cm->mb_rows * cm->mb_cols));
1273
    cpi->gf_active_count = cm->mb_rows * cm->mb_cols;
1274

1275 1276
    vpx_free(cpi->mb_activity_map);
    CHECK_MEM_ERROR(cpi->mb_activity_map,
1277
                    vpx_calloc(sizeof(*cpi->mb_activity_map),
1278
                    cm->mb_rows * cm->mb_cols));
1279

1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297
    /* allocate memory for storing last frame's MVs for MV prediction. */
    vpx_free(cpi->lfmv);
    CHECK_MEM_ERROR(cpi->lfmv, vpx_calloc((cm->mb_rows+2) * (cm->mb_cols+2),
                    sizeof(*cpi->lfmv)));
    vpx_free(cpi->lf_ref_frame_sign_bias);
    CHECK_MEM_ERROR(cpi->lf_ref_frame_sign_bias,
                    vpx_calloc((cm->mb_rows+2) * (cm->mb_cols+2),
                    sizeof(*cpi->lf_ref_frame_sign_bias)));
    vpx_free(cpi->lf_ref_frame);
    CHECK_MEM_ERROR(cpi->lf_ref_frame,
                    vpx_calloc((cm->mb_rows+2) * (cm->mb_cols+2),
                    sizeof(*cpi->lf_ref_frame)));

    /* Create the encoder segmentation map and set all entries to 0 */
    vpx_free(cpi->segmentation_map);
    CHECK_MEM_ERROR(cpi->segmentation_map,
                    vpx_calloc(cm->mb_rows * cm->mb_cols,
                    sizeof(*cpi->segmentation_map)));
1298
    cpi->cyclic_refresh_mode_index = 0;
1299 1300 1301 1302
    vpx_free(cpi->active_map);
    CHECK_MEM_ERROR(cpi->active_map,
                    vpx_calloc(cm->mb_rows * cm->mb_cols,
                    sizeof(*cpi->active_map)));
James Zern's avatar
James Zern committed
1303
    memset(cpi->active_map , 1, (cm->mb_rows * cm->mb_cols));
1304

Attila Nagy's avatar
Attila Nagy committed
1305 1306 1307 1308 1309 1310 1311 1312 1313
#if CONFIG_MULTITHREAD
    if (width < 640)
        cpi->mt_sync_range = 1;
    else if (width <= 1280)
        cpi->mt_sync_range = 4;
    else if (width <= 2560)
        cpi->mt_sync_range = 8;
    else
        cpi->mt_sync_range = 16;
1314 1315 1316 1317 1318

    if (cpi->oxcf.multi_threaded > 1)
    {
        vpx_free(cpi->mt_current_mb_col);
        CHECK_MEM_ERROR(cpi->mt_current_mb_col,
1319
                    vpx_malloc(sizeof(*cpi->mt_current_mb_col) * cm->mb_rows));
1320 1321
    }

Attila Nagy's avatar
Attila Nagy committed
1322
#endif
1323

1324
    vpx_free(cpi->tplist);
1325
    CHECK_MEM_ERROR(cpi->tplist, vpx_malloc(sizeof(TOKENLIST) * cm->mb_rows));
1326 1327 1328 1329 1330 1331

#if CONFIG_TEMPORAL_DENOISING
    if (cpi->oxcf.noise_sensitivity > 0) {
      vp8_denoiser_free(&cpi->denoiser);
      vp8_denoiser_allocate(&cpi->denoiser, width, height,
                            cm->mb_rows, cm->mb_cols,
1332
                            cpi->oxcf.noise_sensitivity);
1333 1334
    }
#endif
John Koleszar's avatar
John Koleszar committed
1335 1336 1337
}