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


#ifndef __INC_VP8_INT_H
#define __INC_VP8_INT_H

#include <stdio.h>
#include "vpx_ports/config.h"
John Koleszar's avatar
John Koleszar committed
17
#include "vp8/common/onyx.h"
John Koleszar's avatar
John Koleszar committed
18
19
#include "treewriter.h"
#include "tokenize.h"
John Koleszar's avatar
John Koleszar committed
20
#include "vp8/common/onyxc_int.h"
John Koleszar's avatar
John Koleszar committed
21
22
23
24
#include "variance.h"
#include "dct.h"
#include "encodemb.h"
#include "quantize.h"
John Koleszar's avatar
John Koleszar committed
25
#include "vp8/common/entropy.h"
John Koleszar's avatar
John Koleszar committed
26
#include "vpx_ports/mem.h"
27
#include "vpx/internal/vpx_codec_internal.h"
John Koleszar's avatar
John Koleszar committed
28
#include "mcomp.h"
Johann's avatar
Johann committed
29
#include "temporal_filter.h"
John Koleszar's avatar
John Koleszar committed
30
#include "vp8/common/findnearmv.h"
John Koleszar's avatar
John Koleszar committed
31
#include "lookahead.h"
John Koleszar's avatar
John Koleszar committed
32
33
34
35
36
37
38

//#define SPEEDSTATS 1
#define MIN_GF_INTERVAL             4
#define DEFAULT_GF_INTERVAL         7

#define KEY_FRAME_CONTEXT 5

39
#define MAX_LAG_BUFFERS 25
John Koleszar's avatar
John Koleszar committed
40
41
42
43

#define AF_THRESH   25
#define AF_THRESH2  100
#define ARF_DECAY_THRESH 12
44
45
46
47

#if CONFIG_NEWINTRAMODES
#define MAX_MODES 42
#else
48
#define MAX_MODES 36
49
#endif
50

John Koleszar's avatar
John Koleszar committed
51
52
53
#define MIN_THRESHMULT  32
#define MAX_THRESHMULT  512

54
55
#define GF_ZEROMV_ZBIN_BOOST 12
#define LF_ZEROMV_ZBIN_BOOST 6
56
#define MV_ZBIN_BOOST        4
John Koleszar's avatar
John Koleszar committed
57
58
59
60
61
62
63
64
#define ZBIN_OQ_MAX 192

#define VP8_TEMPORAL_ALT_REF 1

typedef struct
{
    MV_CONTEXT mvc[2];
    int mvcosts[2][MVvals+1];
65
66
67
68
#if CONFIG_HIGH_PRECISION_MV
    MV_CONTEXT_HP mvc_hp[2];
    int mvcosts_hp[2][MVvals_hp+1];
#endif
John Koleszar's avatar
John Koleszar committed
69
70
71

#ifdef MODE_STATS
    // Stats
Yaowu Xu's avatar
Yaowu Xu committed
72
73
74
    int y_modes[VP8_YMODES];
    int uv_modes[VP8_UV_MODES];
    int i8x8_modes[VP8_I8X8_MODES];
75
    int b_modes[B_MODE_COUNT];
76
    int inter_y_modes[MB_MODE_COUNT];
Yaowu Xu's avatar
Yaowu Xu committed
77
    int inter_uv_modes[VP8_UV_MODES];
78
    int inter_b_modes[B_MODE_COUNT];
John Koleszar's avatar
John Koleszar committed
79
#endif
80

81
82
83
84
    vp8_prob segment_pred_probs[PREDICTION_PROBS];
    unsigned char ref_pred_probs_update[PREDICTION_PROBS];
    vp8_prob ref_pred_probs[PREDICTION_PROBS];
    vp8_prob prob_comppred[COMP_PRED_CONTEXTS];
John Koleszar's avatar
John Koleszar committed
85

86
87
88
89
90
91
    unsigned char * last_frame_seg_map_copy;

    // 0 = Intra, Last, GF, ARF
    signed char last_ref_lf_deltas[MAX_REF_LF_DELTAS];
    // 0 = BPRED, ZERO_MV, MV, SPLIT
    signed char last_mode_lf_deltas[MAX_MODE_LF_DELTAS];
John Koleszar's avatar
John Koleszar committed
92

93
94
    vp8_prob coef_probs[BLOCK_TYPES]
                       [COEF_BANDS][PREV_COEF_CONTEXTS][ENTROPY_NODES];
95
    vp8_prob coef_probs_8x8[BLOCK_TYPES_8X8]
96
                           [COEF_BANDS][PREV_COEF_CONTEXTS][ENTROPY_NODES];
John Koleszar's avatar
John Koleszar committed
97

98
99
    vp8_prob ymode_prob [VP8_YMODES-1];   /* interframe intra mode probs */
    vp8_prob uv_mode_prob [VP8_YMODES][VP8_UV_MODES-1];
100
101
    vp8_prob bmode_prob [VP8_BINTRAMODES-1];
    vp8_prob i8x8_mode_prob [VP8_I8X8_MODES-1];
102

103
104
105
106
    int mv_ref_ct[6][4][2];
    int mode_context[6][4];
    int mv_ref_ct_a[6][4][2];
    int mode_context_a[6][4];
John Koleszar's avatar
John Koleszar committed
107
108
109
110
111
112
113
114

} CODING_CONTEXT;

typedef struct
{
    double frame;
    double intra_error;
    double coded_error;
115
    double sr_coded_error;
John Koleszar's avatar
John Koleszar committed
116
117
118
119
    double ssim_weighted_pred_err;
    double pcnt_inter;
    double pcnt_motion;
    double pcnt_second_ref;
Paul Wilkins's avatar
Paul Wilkins committed
120
    double pcnt_neutral;
John Koleszar's avatar
John Koleszar committed
121
122
123
124
125
126
127
    double MVr;
    double mvr_abs;
    double MVc;
    double mvc_abs;
    double MVrv;
    double MVcv;
    double mv_in_out_count;
128
    double new_mv_count;
John Koleszar's avatar
John Koleszar committed
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
    double duration;
    double count;
}
FIRSTPASS_STATS;

typedef struct
{
    int frames_so_far;
    double frame_intra_error;
    double frame_coded_error;
    double frame_pcnt_inter;
    double frame_pcnt_motion;
    double frame_mvr;
    double frame_mvr_abs;
    double frame_mvc;
    double frame_mvc_abs;

} ONEPASS_FRAMESTATS;

148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
typedef struct
{
    struct {
        int err;
        union {
            int_mv mv;
            MB_PREDICTION_MODE mode;
        } m;
    } ref[MAX_REF_FRAMES];
} MBGRAPH_MB_STATS;

typedef struct
{
    MBGRAPH_MB_STATS *mb_stats;
} MBGRAPH_FRAME_STATS;
John Koleszar's avatar
John Koleszar committed
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182

typedef enum
{
    THR_ZEROMV         = 0,
    THR_DC             = 1,

    THR_NEARESTMV      = 2,
    THR_NEARMV         = 3,

    THR_ZEROG          = 4,
    THR_NEARESTG       = 5,

    THR_ZEROA          = 6,
    THR_NEARESTA       = 7,

    THR_NEARG          = 8,
    THR_NEARA          = 9,

    THR_V_PRED         = 10,
    THR_H_PRED         = 11,
183
184
185
186
187
188
189
190
191
#if CONFIG_NEWINTRAMODES
    THR_D45_PRED,
    THR_D135_PRED,
    THR_D117_PRED,
    THR_D153_PRED,
    THR_D27_PRED,
    THR_D63_PRED,
#endif
    THR_TM,
John Koleszar's avatar
John Koleszar committed
192

193
194
195
    THR_NEWMV,
    THR_NEWG,
    THR_NEWA,
John Koleszar's avatar
John Koleszar committed
196

197
198
199
    THR_SPLITMV,
    THR_SPLITG,
    THR_SPLITA,
John Koleszar's avatar
John Koleszar committed
200

201
202
    THR_B_PRED,
    THR_I8X8_PRED,
203

204
205
206
    THR_COMP_ZEROLG,
    THR_COMP_NEARESTLG,
    THR_COMP_NEARLG,
207

208
209
210
    THR_COMP_ZEROLA,
    THR_COMP_NEARESTLA,
    THR_COMP_NEARLA,
211

212
213
214
    THR_COMP_ZEROGA,
    THR_COMP_NEARESTGA,
    THR_COMP_NEARGA,
215

216
217
218
    THR_COMP_NEWLG,
    THR_COMP_NEWLA,
    THR_COMP_NEWGA,
219

220
221
222
    THR_COMP_SPLITLG,
    THR_COMP_SPLITLA,
    THR_COMP_SPLITGA,
John Koleszar's avatar
John Koleszar committed
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
}
THR_MODES;

typedef enum
{
    DIAMOND = 0,
    NSTEP = 1,
    HEX = 2
} SEARCH_METHODS;

typedef struct
{
    int RD;
    SEARCH_METHODS search_method;
    int improved_dct;
    int auto_filter;
    int recode_loop;
    int iterative_sub_pixel;
    int half_pixel_search;
    int quarter_pixel_search;
    int thresh_mult[MAX_MODES];
    int max_step_search_steps;
    int first_step;
    int optimize_coefficients;
247
    int no_skip_block4x4_search;
248
    int improved_mv_pred;
249
250
251
#if CONFIG_ENHANCED_INTERP
    int search_best_filter;
#endif
252

John Koleszar's avatar
John Koleszar committed
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
} SPEED_FEATURES;

typedef struct
{
    MACROBLOCK  mb;
    int totalrate;
} MB_ROW_COMP;

typedef struct
{
    TOKENEXTRA *start;
    TOKENEXTRA *stop;
} TOKENLIST;

typedef struct
{
    int ithread;
    void *ptr1;
    void *ptr2;
} ENCODETHREAD_DATA;
typedef struct
{
    int ithread;
    void *ptr1;
} LPFTHREAD_DATA;


typedef struct VP8_ENCODER_RTCD
{
    VP8_COMMON_RTCD            *common;
    vp8_variance_rtcd_vtable_t  variance;
    vp8_fdct_rtcd_vtable_t      fdct;
    vp8_encodemb_rtcd_vtable_t  encodemb;
    vp8_search_rtcd_vtable_t    search;
Johann's avatar
Johann committed
287
    vp8_temporal_rtcd_vtable_t  temporal;
John Koleszar's avatar
John Koleszar committed
288
289
} VP8_ENCODER_RTCD;

290
291
292
293
294
295
296
297
298
299
enum
{
    BLOCK_16X8,
    BLOCK_8X16,
    BLOCK_8X8,
    BLOCK_4X4,
    BLOCK_16X16,
    BLOCK_MAX_SEGMENTS
};

300
typedef struct VP8_COMP
John Koleszar's avatar
John Koleszar committed
301
302
{

303
    DECLARE_ALIGNED(16, short, Y1quant[QINDEX_RANGE][16]);
Johann's avatar
Johann committed
304
    DECLARE_ALIGNED(16, unsigned char, Y1quant_shift[QINDEX_RANGE][16]);
305
306
    DECLARE_ALIGNED(16, short, Y1zbin[QINDEX_RANGE][16]);
    DECLARE_ALIGNED(16, short, Y1round[QINDEX_RANGE][16]);
John Koleszar's avatar
John Koleszar committed
307

308
    DECLARE_ALIGNED(16, short, Y2quant[QINDEX_RANGE][16]);
Johann's avatar
Johann committed
309
    DECLARE_ALIGNED(16, unsigned char, Y2quant_shift[QINDEX_RANGE][16]);
310
311
    DECLARE_ALIGNED(16, short, Y2zbin[QINDEX_RANGE][16]);
    DECLARE_ALIGNED(16, short, Y2round[QINDEX_RANGE][16]);
John Koleszar's avatar
John Koleszar committed
312

313
    DECLARE_ALIGNED(16, short, UVquant[QINDEX_RANGE][16]);
Johann's avatar
Johann committed
314
    DECLARE_ALIGNED(16, unsigned char, UVquant_shift[QINDEX_RANGE][16]);
315
316
    DECLARE_ALIGNED(16, short, UVzbin[QINDEX_RANGE][16]);
    DECLARE_ALIGNED(16, short, UVround[QINDEX_RANGE][16]);
John Koleszar's avatar
John Koleszar committed
317
318
319
320
321

    DECLARE_ALIGNED(16, short, zrun_zbin_boost_y1[QINDEX_RANGE][16]);
    DECLARE_ALIGNED(16, short, zrun_zbin_boost_y2[QINDEX_RANGE][16]);
    DECLARE_ALIGNED(16, short, zrun_zbin_boost_uv[QINDEX_RANGE][16]);

322
323
324
325
326
327
    DECLARE_ALIGNED(64, short, Y1zbin_8x8[QINDEX_RANGE][64]);
    DECLARE_ALIGNED(64, short, Y2zbin_8x8[QINDEX_RANGE][64]);
    DECLARE_ALIGNED(64, short, UVzbin_8x8[QINDEX_RANGE][64]);
    DECLARE_ALIGNED(64, short, zrun_zbin_boost_y1_8x8[QINDEX_RANGE][64]);
    DECLARE_ALIGNED(64, short, zrun_zbin_boost_y2_8x8[QINDEX_RANGE][64]);
    DECLARE_ALIGNED(64, short, zrun_zbin_boost_uv_8x8[QINDEX_RANGE][64]);
John Koleszar's avatar
John Koleszar committed
328
329
330
331
332
333
334
335

    MACROBLOCK mb;
    VP8_COMMON common;
    vp8_writer bc, bc2;
    // bool_writer *bc2;

    VP8_CONFIG oxcf;

John Koleszar's avatar
John Koleszar committed
336
337
338
339
    struct lookahead_ctx    *lookahead;
    struct lookahead_entry  *source;
    struct lookahead_entry  *alt_ref_source;

John Koleszar's avatar
John Koleszar committed
340
341
342
343
    YV12_BUFFER_CONFIG *Source;
    YV12_BUFFER_CONFIG *un_scaled_source;
    YV12_BUFFER_CONFIG scaled_source;

Fritz Koenig's avatar
Fritz Koenig committed
344
345
346
347
    int source_alt_ref_pending; // frame in src_buffers has been identified to be encoded as an alt ref
    int source_alt_ref_active;  // an alt ref frame has been encoded and is usable

    int is_src_frame_alt_ref;   // source of frame to encode is an exact copy of an alt ref frame
John Koleszar's avatar
John Koleszar committed
348
349
350
351
352
353
354
355
356
357
358
359
360
361

    int gold_is_last; // golden frame same as last frame ( short circuit gold searches)
    int alt_is_last;  // Alt reference frame same as last ( short circuit altref search)
    int gold_is_alt;  // don't do both alt and gold search ( just do gold).

    //int refresh_alt_ref_frame;
    YV12_BUFFER_CONFIG last_frame_uf;

    TOKENEXTRA *tok;
    unsigned int tok_count;


    unsigned int frames_since_key;
    unsigned int key_frame_frequency;
362
363
    unsigned int this_key_frame_forced;
    unsigned int next_key_frame_forced;
John Koleszar's avatar
John Koleszar committed
364

365
366
367
    // Ambient reconstruction err target for force key frames
    int ambient_err;

John Koleszar's avatar
John Koleszar committed
368
369
370
371
372
373
374
    unsigned int mode_check_freq[MAX_MODES];
    unsigned int mode_test_hit_counts[MAX_MODES];
    unsigned int mode_chosen_counts[MAX_MODES];

    int rd_thresh_mult[MAX_MODES];
    int rd_baseline_thresh[MAX_MODES];
    int rd_threshes[MAX_MODES];
375
    int64_t rd_single_diff, rd_comp_diff, rd_hybrid_diff;
376
    int rd_prediction_type_threshes[4][NB_PREDICTION_TYPES];
377
378
    int comp_pred_count[COMP_PRED_CONTEXTS];
    int single_pred_count[COMP_PRED_CONTEXTS];
John Koleszar's avatar
John Koleszar committed
379
380
381
382
383
384
385

    int RDMULT;
    int RDDIV ;

    CODING_CONTEXT coding_context;

    // Rate targetting variables
386
387
388
389
    int64_t prediction_error;
    int64_t last_prediction_error;
    int64_t intra_error;
    int64_t last_intra_error;
John Koleszar's avatar
John Koleszar committed
390
391
392
393

    int this_frame_target;
    int projected_frame_size;
    int last_q[2];                   // Separate values for Intra/Inter
394
    int last_boosted_qindex;         // Last boosted GF/KF/ARF q
John Koleszar's avatar
John Koleszar committed
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410

    double rate_correction_factor;
    double key_frame_rate_correction_factor;
    double gf_rate_correction_factor;

    int frames_till_gf_update_due;      // Count down till next GF
    int current_gf_interval;          // GF interval chosen when we coded the last GF

    int gf_overspend_bits;            // Total bits overspent becasue of GF boost (cumulative)

    int non_gf_bitrate_adjustment;     // Used in the few frames following a GF to recover the extra bits spent in that GF

    int kf_overspend_bits;            // Extra bits spent on key frames that need to be recovered on inter frames
    int kf_bitrate_adjustment;        // Current number of bit s to try and recover on each inter frame.
    int max_gf_interval;
    int baseline_gf_interval;
411
    int active_arnr_frames;           // <= cpi->oxcf.arnr_max_frames
John Koleszar's avatar
John Koleszar committed
412

413
    int64_t key_frame_count;
John Koleszar's avatar
John Koleszar committed
414
415
416
417
418
419
    int prior_key_frame_distance[KEY_FRAME_CONTEXT];
    int per_frame_bandwidth;          // Current section per frame bandwidth target
    int av_per_frame_bandwidth;        // Average frame size target for clip
    int min_frame_bandwidth;          // Minimum allocation that should be used for any frame
    int inter_frame_target;
    double output_frame_rate;
420
421
422
    int64_t last_time_stamp_seen;
    int64_t last_end_time_stamp_seen;
    int64_t first_time_stamp_ever;
John Koleszar's avatar
John Koleszar committed
423
424
425
426
427

    int ni_av_qi;
    int ni_tot_qi;
    int ni_frames;
    int avg_frame_qindex;
428
429
    double tot_q;
    double avg_q;
John Koleszar's avatar
John Koleszar committed
430
431
432
433
434

    int zbin_over_quant;
    int zbin_mode_boost;
    int zbin_mode_boost_enabled;

435
    int64_t total_byte_count;
John Koleszar's avatar
John Koleszar committed
436
437
438
439
440
441
442
443
444
445
446
447

    int buffered_mode;

    int buffer_level;
    int bits_off_target;

    int rolling_target_bits;
    int rolling_actual_bits;

    int long_rolling_target_bits;
    int long_rolling_actual_bits;

448
    int64_t total_actual_bits;
John Koleszar's avatar
John Koleszar committed
449
450
451
452
453
454
455
    int total_target_vs_actual;        // debug stats

    int worst_quality;
    int active_worst_quality;
    int best_quality;
    int active_best_quality;

Paul Wilkins's avatar
CQ Mode    
Paul Wilkins committed
456
    int cq_target_quality;
457

John Koleszar's avatar
John Koleszar committed
458
    int ymode_count [VP8_YMODES];        /* intra MB type cts this frame */
459
460
461
    int bmode_count [VP8_BINTRAMODES];
    int i8x8_mode_count [VP8_I8X8_MODES];
    //int uv_mode_count[VP8_UV_MODES];       /* intra MB type cts this frame */
John Koleszar's avatar
John Koleszar committed
462
463

    unsigned int MVcount [2] [MVvals];  /* (row,col) MV cts this frame */
464
465
466
#if CONFIG_HIGH_PRECISION_MV
    unsigned int MVcount_hp [2] [MVvals_hp];  /* (row,col) MV cts this frame */
#endif
John Koleszar's avatar
John Koleszar committed
467

468
469
    unsigned int coef_counts [BLOCK_TYPES] [COEF_BANDS] [PREV_COEF_CONTEXTS] [MAX_ENTROPY_TOKENS];  /* for this frame */
    //DECLARE_ALIGNED(16, int, coef_counts_backup [BLOCK_TYPES] [COEF_BANDS] [PREV_COEF_CONTEXTS] [MAX_ENTROPY_TOKENS]);   //not used any more
John Koleszar's avatar
John Koleszar committed
470
    //save vp8_tree_probs_from_distribution result for each frame to avoid repeat calculation
471
472
    vp8_prob frame_coef_probs [BLOCK_TYPES] [COEF_BANDS] [PREV_COEF_CONTEXTS] [ENTROPY_NODES];
    unsigned int frame_branch_ct [BLOCK_TYPES] [COEF_BANDS] [PREV_COEF_CONTEXTS] [ENTROPY_NODES][2];
473
474
475
    unsigned int coef_counts_8x8 [BLOCK_TYPES_8X8] [COEF_BANDS] [PREV_COEF_CONTEXTS] [MAX_ENTROPY_TOKENS];  /* for this frame */
    vp8_prob frame_coef_probs_8x8 [BLOCK_TYPES_8X8] [COEF_BANDS] [PREV_COEF_CONTEXTS] [ENTROPY_NODES];
    unsigned int frame_branch_ct_8x8 [BLOCK_TYPES_8X8] [COEF_BANDS] [PREV_COEF_CONTEXTS] [ENTROPY_NODES][2];
John Koleszar's avatar
John Koleszar committed
476
477
478

    int gfu_boost;
    int last_boost;
479
480
    int kf_boost;
    int kf_zeromotion_pct;
John Koleszar's avatar
John Koleszar committed
481
482
483

    int target_bandwidth;
    struct vpx_codec_pkt_list  *output_pkt_list;
484

John Koleszar's avatar
John Koleszar committed
485
486
487
488
489
#if 0
    // Experimental code for lagged and one pass
    ONEPASS_FRAMESTATS one_pass_frame_stats[MAX_LAG_BUFFERS];
    int one_pass_frame_index;
#endif
490
491
    MBGRAPH_FRAME_STATS mbgraph_stats[MAX_LAG_BUFFERS];
    int mbgraph_n_frames;             // number of frames filled in the above
492
    int static_mb_pct;                // % forced skip mbs by segmentation
493
494
    int seg0_progress, seg0_idx, seg0_cnt;
    int ref_pred_count[3][2];
John Koleszar's avatar
John Koleszar committed
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513

    int decimation_factor;
    int decimation_count;

    // for real time encoding
    int avg_encode_time;              //microsecond
    int avg_pick_mode_time;            //microsecond
    int Speed;
    unsigned int cpu_freq;           //Mhz
    int compressor_speed;

    int interquantizer;
    int goldfreq;
    int auto_worst_q;
    int cpu_used;
    int horiz_scale;
    int vert_scale;
    int pass;

514
#if CONFIG_NEWENTROPY
515
    vp8_prob last_skip_false_probs[3][MBSKIP_CONTEXTS];
516
#else
517
518
    vp8_prob prob_skip_false;
    vp8_prob last_skip_false_probs[3];
519
#endif
John Koleszar's avatar
John Koleszar committed
520
521
    int last_skip_probs_q[3];

522
    int recent_ref_frame_usage[MAX_REF_FRAMES];
John Koleszar's avatar
John Koleszar committed
523
524
525
    int count_mb_ref_frame_usage[MAX_REF_FRAMES];
    int ref_frame_flags;

526
    unsigned char ref_pred_probs_update[PREDICTION_PROBS];
527

John Koleszar's avatar
John Koleszar committed
528
529
530
531
532
533
534
    SPEED_FEATURES sf;
    int error_bins[1024];

    // Data used for real time conferencing mode to help determine if it would be good to update the gf
    int inter_zz_count;
    int gf_bad_count;
    int gf_update_recommended;
535
536
537
538
#if CONFIG_NEWENTROPY
    int skip_true_count[3];
    int skip_false_count[3];
#else
John Koleszar's avatar
John Koleszar committed
539
540
    int skip_true_count;
    int skip_false_count;
541
#endif
Paul Wilkins's avatar
Paul Wilkins committed
542
543
    int t4x4_count;
    int t8x8_count;
John Koleszar's avatar
John Koleszar committed
544

545
    int y_uv_mode_count[VP8_YMODES][VP8_UV_MODES];
John Koleszar's avatar
John Koleszar committed
546
    unsigned char *segmentation_map;
Paul Wilkins's avatar
Paul Wilkins committed
547
548
549

    // segment threashold for encode breakout
    int  segment_encode_breakout[MAX_MB_SEGMENTS];
John Koleszar's avatar
John Koleszar committed
550
551
552
553
554
555
556
557

    unsigned char *active_map;
    unsigned int active_map_enabled;

    TOKENLIST *tplist;

    fractional_mv_step_fp *find_fractional_mv_step;
    vp8_full_search_fn_t full_search_sad;
558
    vp8_refining_search_fn_t refining_search_sad;
John Koleszar's avatar
John Koleszar committed
559
    vp8_diamond_search_fn_t diamond_search_sad;
560
    vp8_variance_fn_ptr_t fn_ptr[BLOCK_MAX_SEGMENTS];
John Koleszar's avatar
John Koleszar committed
561
562
563
564
565
    unsigned int time_receive_data;
    unsigned int time_compress_data;
    unsigned int time_pick_lpf;
    unsigned int time_encode_mb_row;

566
567
568
#if CONFIG_NEWENTROPY
    int base_skip_false_prob[QINDEX_RANGE][3];
#else
Paul Wilkins's avatar
Paul Wilkins committed
569
    int base_skip_false_prob[QINDEX_RANGE];
570
#endif
John Koleszar's avatar
John Koleszar committed
571

572
573
574
575
576
577
578
    struct twopass_rc
    {
        unsigned int section_intra_rating;
        unsigned int next_iiratio;
        unsigned int this_iiratio;
        FIRSTPASS_STATS *total_stats;
        FIRSTPASS_STATS *this_frame_stats;
579
        FIRSTPASS_STATS *stats_in, *stats_in_end, *stats_in_start;
580
        FIRSTPASS_STATS *total_left_stats;
581
        int first_pass_done;
582
583
        int64_t bits_left;
        int64_t clip_bits_total;
584
585
586
587
588
589
590
591
592
593
594
595
596
597
        double avg_iiratio;
        double modified_error_total;
        double modified_error_used;
        double modified_error_left;
        double kf_intra_err_min;
        double gf_intra_err_min;
        int frames_to_key;
        int maxq_max_limit;
        int maxq_min_limit;
        int static_scene_max_gf_interval;
        int kf_bits;
        int gf_group_error_left;           // Remaining error from uncoded frames in a gf group. Two pass use only

        // Projected total bits available for a key frame group of frames
598
        int64_t kf_group_bits;
599
600

        // Error score of frames still to be coded in kf group
601
        int64_t kf_group_error_left;
602
603
604

        int gf_group_bits;                // Projected Bits available for a group of frames including 1 GF or ARF
        int gf_bits;                     // Bits for the golden frame or ARF - 2 pass only
605
        int alt_extra_bits;
Paul Wilkins's avatar
Paul Wilkins committed
606
607

        int sr_update_lag;
608
609
        double est_max_qcorrection_factor;
    } twopass;
John Koleszar's avatar
John Koleszar committed
610
611
612
613
614

#if CONFIG_RUNTIME_CPU_DETECT
    VP8_ENCODER_RTCD            rtcd;
#endif
#if VP8_TEMPORAL_ALT_REF
John Koleszar's avatar
John Koleszar committed
615
    YV12_BUFFER_CONFIG alt_ref_buffer;
616
617
    YV12_BUFFER_CONFIG *frames[MAX_LAG_BUFFERS];
    int fixed_divide[512];
John Koleszar's avatar
John Koleszar committed
618
619
#endif

620
#if CONFIG_INTERNAL_STATS
John Koleszar's avatar
John Koleszar committed
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
    int    count;
    double total_y;
    double total_u;
    double total_v;
    double total ;
    double total_sq_error;
    double totalp_y;
    double totalp_u;
    double totalp_v;
    double totalp;
    double total_sq_error2;
    int    bytes;
    double summed_quality;
    double summed_weights;
    unsigned int tot_recode_hits;


    double total_ssimg_y;
    double total_ssimg_u;
    double total_ssimg_v;
    double total_ssimg_all;

    int b_calculate_ssimg;
#endif
    int b_calculate_psnr;
646

647
648
649
650
    // Per MB activity measurement
    unsigned int activity_avg;
    unsigned int * mb_activity_map;
    int * mb_norm_activity_map;
651

652
653
654
    // Record of which MBs still refer to last golden frame either
    // directly or through 0,0
    unsigned char *gf_active_flags;
655
656
    int gf_active_count;

657
658
    int output_partition;

659
660
661
662
    //Store last frame's MV info for next frame MV prediction
    int_mv *lfmv;
    int *lf_ref_frame_sign_bias;
    int *lf_ref_frame;
663

Adrian Grange's avatar
Adrian Grange committed
664
665
    /* force next frame to intra when kf_auto says so */
    int force_next_frame_intra;
666

John Koleszar's avatar
John Koleszar committed
667
    int droppable;
Adrian Grange's avatar
Adrian Grange committed
668
669
670
671
672
673
674

    // Global store for SB left contexts, one for each MB row in the SB
    ENTROPY_CONTEXT_PLANES left_context[2];

    // TODO Do we still need this??
    int update_context;

675
676
    int dummy_packing;    /* flag to indicate if packing is dummy */

John Koleszar's avatar
John Koleszar committed
677
678
679
680
681
682
683
684
} VP8_COMP;

void control_data_rate(VP8_COMP *cpi);

void vp8_encode_frame(VP8_COMP *cpi);

void vp8_pack_bitstream(VP8_COMP *cpi, unsigned char *dest, unsigned long *size);

685
void vp8_activity_masking(VP8_COMP *cpi, MACROBLOCK *x);
686

John Koleszar's avatar
John Koleszar committed
687
688
689
690
691
int rd_cost_intra_mb(MACROBLOCKD *x);

void vp8_tokenize_mb(VP8_COMP *, MACROBLOCKD *, TOKENEXTRA **);

void vp8_set_speed_features(VP8_COMP *cpi);
Yaowu Xu's avatar
Yaowu Xu committed
692

John Koleszar's avatar
John Koleszar committed
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
#if CONFIG_DEBUG
#define CHECK_MEM_ERROR(lval,expr) do {\
        lval = (expr); \
        if(!lval) \
            vpx_internal_error(&cpi->common.error, VPX_CODEC_MEM_ERROR,\
                               "Failed to allocate "#lval" at %s:%d", \
                               __FILE__,__LINE__);\
    } while(0)
#else
#define CHECK_MEM_ERROR(lval,expr) do {\
        lval = (expr); \
        if(!lval) \
            vpx_internal_error(&cpi->common.error, VPX_CODEC_MEM_ERROR,\
                               "Failed to allocate "#lval);\
    } while(0)
#endif
#endif