onyx_int.h 19.4 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
 */


#ifndef __INC_VP8_INT_H
#define __INC_VP8_INT_H

#include <stdio.h>
16
#include "vpx_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
26
#include "vp8/common/entropy.h"
#include "vp8/common/threading.h"
John Koleszar's avatar
John Koleszar committed
27
#include "vpx_ports/mem.h"
28
#include "vpx/internal/vpx_codec_internal.h"
John Koleszar's avatar
John Koleszar committed
29
#include "mcomp.h"
Johann's avatar
Johann committed
30
#include "temporal_filter.h"
John Koleszar's avatar
John Koleszar committed
31
#include "vp8/common/findnearmv.h"
John Koleszar's avatar
John Koleszar committed
32
#include "lookahead.h"
John Koleszar's avatar
John Koleszar committed
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

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

#define KEY_FRAME_CONTEXT 5

#define MAX_LAG_BUFFERS (CONFIG_REALTIME_ONLY? 1 : 25)

#define AF_THRESH   25
#define AF_THRESH2  100
#define ARF_DECAY_THRESH 12
#define MAX_MODES 20

#define MIN_THRESHMULT  32
#define MAX_THRESHMULT  512

50
51
#define GF_ZEROMV_ZBIN_BOOST 12
#define LF_ZEROMV_ZBIN_BOOST 6
52
#define MV_ZBIN_BOOST        4
John Koleszar's avatar
John Koleszar committed
53
54
#define ZBIN_OQ_MAX 192

55
#if !(CONFIG_REALTIME_ONLY)
John Koleszar's avatar
John Koleszar committed
56
#define VP8_TEMPORAL_ALT_REF 1
57
#endif
John Koleszar's avatar
John Koleszar committed
58

59
60
#define MAX_PERIODICITY 16

Yunqing Wang's avatar
Yunqing Wang committed
61
62
63
#define MAX(x,y) (((x)>(y))?(x):(y))
#define MIN(x,y) (((x)<(y))?(x):(y))

John Koleszar's avatar
John Koleszar committed
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
typedef struct
{
    int kf_indicated;
    unsigned int frames_since_key;
    unsigned int frames_since_golden;
    int filter_level;
    int frames_till_gf_update_due;
    int recent_ref_frame_usage[MAX_REF_FRAMES];

    MV_CONTEXT mvc[2];
    int mvcosts[2][MVvals+1];

#ifdef MODE_STATS
    // Stats
    int y_modes[5];
    int uv_modes[4];
    int b_modes[10];
    int inter_y_modes[10];
    int inter_uv_modes[4];
    int inter_b_modes[10];
#endif

    vp8_prob ymode_prob[4], uv_mode_prob[3];   /* interframe intra mode probs */
    vp8_prob kf_ymode_prob[4], kf_uv_mode_prob[3];   /* keyframe "" */

    int ymode_count[5], uv_mode_count[4];  /* intra MB type cts this frame */

    int count_mb_ref_frame_usage[MAX_REF_FRAMES];

    int this_frame_percent_intra;
    int last_frame_percent_intra;


} CODING_CONTEXT;

typedef struct
{
    double frame;
    double intra_error;
    double coded_error;
    double ssim_weighted_pred_err;
    double pcnt_inter;
    double pcnt_motion;
    double pcnt_second_ref;
Paul Wilkins's avatar
Paul Wilkins committed
108
    double pcnt_neutral;
John Koleszar's avatar
John Koleszar committed
109
110
111
112
113
114
115
    double MVr;
    double mvr_abs;
    double MVc;
    double mvc_abs;
    double MVrv;
    double MVcv;
    double mv_in_out_count;
Paul Wilkins's avatar
Paul Wilkins committed
116
    double new_mv_count;
John Koleszar's avatar
John Koleszar committed
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
    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;


typedef enum
{
139
    THR_ZERO1          = 0,
John Koleszar's avatar
John Koleszar committed
140
141
    THR_DC             = 1,

142
143
    THR_NEAREST1       = 2,
    THR_NEAR1          = 3,
John Koleszar's avatar
John Koleszar committed
144

145
146
    THR_ZERO2          = 4,
    THR_NEAREST2       = 5,
John Koleszar's avatar
John Koleszar committed
147

148
149
    THR_ZERO3          = 6,
    THR_NEAREST3       = 7,
John Koleszar's avatar
John Koleszar committed
150

151
152
    THR_NEAR2          = 8,
    THR_NEAR3          = 9,
John Koleszar's avatar
John Koleszar committed
153
154
155
156
157

    THR_V_PRED         = 10,
    THR_H_PRED         = 11,
    THR_TM             = 12,

158
159
160
    THR_NEW1           = 13,
    THR_NEW2           = 14,
    THR_NEW3           = 15,
John Koleszar's avatar
John Koleszar committed
161

162
163
164
    THR_SPLIT1         = 16,
    THR_SPLIT2         = 17,
    THR_SPLIT3         = 18,
John Koleszar's avatar
John Koleszar committed
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192

    THR_B_PRED         = 19,
}
THR_MODES;

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

typedef struct
{
    int RD;
    SEARCH_METHODS search_method;
    int improved_quant;
    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;

193
    int use_fastquant_for_pick;
194
    int no_skip_block4x4_search;
195
    int improved_mv_pred;
196

John Koleszar's avatar
John Koleszar committed
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
} SPEED_FEATURES;

typedef struct
{
    MACROBLOCK  mb;
    int segment_counts[MAX_MB_SEGMENTS];
    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_quantize_rtcd_vtable_t  quantize;
    vp8_search_rtcd_vtable_t    search;
Johann's avatar
Johann committed
233
    vp8_temporal_rtcd_vtable_t  temporal;
John Koleszar's avatar
John Koleszar committed
234
235
} VP8_ENCODER_RTCD;

236
237
238
239
240
241
242
243
244
245
enum
{
    BLOCK_16X8,
    BLOCK_8X16,
    BLOCK_8X8,
    BLOCK_4X4,
    BLOCK_16X16,
    BLOCK_MAX_SEGMENTS
};

246
247
248
249
250
251
252
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
287
288
289
290
291
typedef struct
{
    // Layer configuration
    double frame_rate;
    int target_bandwidth;

    // Layer specific coding parameters
    int starting_buffer_level;
    int optimal_buffer_level;
    int maximum_buffer_size;

    int avg_frame_size_for_layer;

    int buffer_level;
    int bits_off_target;

    long long total_actual_bits;
    int total_target_vs_actual;

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

    int ni_av_qi;
    int ni_tot_qi;
    int ni_frames;
    int avg_frame_qindex;

    double rate_correction_factor;
    double key_frame_rate_correction_factor;
    double gf_rate_correction_factor;

    int zbin_over_quant;

    int inter_frame_target;
    INT64 total_byte_count;

    int filter_level;

    int last_frame_percent_intra;

    int count_mb_ref_frame_usage[MAX_REF_FRAMES];

} LAYER_CONTEXT;

292
typedef struct VP8_COMP
John Koleszar's avatar
John Koleszar committed
293
294
{

295
    DECLARE_ALIGNED(16, short, Y1quant[QINDEX_RANGE][16]);
Johann's avatar
Johann committed
296
    DECLARE_ALIGNED(16, unsigned char, Y1quant_shift[QINDEX_RANGE][16]);
297
298
299
300
    DECLARE_ALIGNED(16, short, Y1zbin[QINDEX_RANGE][16]);
    DECLARE_ALIGNED(16, short, Y1round[QINDEX_RANGE][16]);

    DECLARE_ALIGNED(16, short, Y2quant[QINDEX_RANGE][16]);
Johann's avatar
Johann committed
301
    DECLARE_ALIGNED(16, unsigned char, Y2quant_shift[QINDEX_RANGE][16]);
302
303
304
305
    DECLARE_ALIGNED(16, short, Y2zbin[QINDEX_RANGE][16]);
    DECLARE_ALIGNED(16, short, Y2round[QINDEX_RANGE][16]);

    DECLARE_ALIGNED(16, short, UVquant[QINDEX_RANGE][16]);
Johann's avatar
Johann committed
306
    DECLARE_ALIGNED(16, unsigned char, UVquant_shift[QINDEX_RANGE][16]);
307
308
    DECLARE_ALIGNED(16, short, UVzbin[QINDEX_RANGE][16]);
    DECLARE_ALIGNED(16, short, UVround[QINDEX_RANGE][16]);
John Koleszar's avatar
John Koleszar committed
309
310
311
312

    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]);
313
314
315
    DECLARE_ALIGNED(16, short, Y1quant_fast[QINDEX_RANGE][16]);
    DECLARE_ALIGNED(16, short, Y2quant_fast[QINDEX_RANGE][16]);
    DECLARE_ALIGNED(16, short, UVquant_fast[QINDEX_RANGE][16]);
John Koleszar's avatar
John Koleszar committed
316
317
318
319


    MACROBLOCK mb;
    VP8_COMMON common;
320
    vp8_writer bc[9]; // one boolcoder for each partition
John Koleszar's avatar
John Koleszar committed
321
322
323

    VP8_CONFIG oxcf;

John Koleszar's avatar
John Koleszar committed
324
325
326
327
    struct lookahead_ctx    *lookahead;
    struct lookahead_entry  *source;
    struct lookahead_entry  *alt_ref_source;

John Koleszar's avatar
John Koleszar committed
328
329
330
331
    YV12_BUFFER_CONFIG *Source;
    YV12_BUFFER_CONFIG *un_scaled_source;
    YV12_BUFFER_CONFIG scaled_source;

Fritz Koenig's avatar
Fritz Koenig committed
332
333
334
335
    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
336
337
338
339
340
341

    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;
342
    YV12_BUFFER_CONFIG pick_lf_lvl_frame;
John Koleszar's avatar
John Koleszar committed
343
344
345
346
347
348
349

    TOKENEXTRA *tok;
    unsigned int tok_count;


    unsigned int frames_since_key;
    unsigned int key_frame_frequency;
350
351
    unsigned int this_key_frame_forced;
    unsigned int next_key_frame_forced;
John Koleszar's avatar
John Koleszar committed
352

353
354
355
    // Ambient reconstruction err target for force key frames
    int ambient_err;

John Koleszar's avatar
John Koleszar committed
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
    unsigned int mode_check_freq[MAX_MODES];
    unsigned int mode_test_hit_counts[MAX_MODES];
    unsigned int mode_chosen_counts[MAX_MODES];
    unsigned int mbs_tested_so_far;

    int rd_thresh_mult[MAX_MODES];
    int rd_baseline_thresh[MAX_MODES];
    int rd_threshes[MAX_MODES];

    int RDMULT;
    int RDDIV ;

    CODING_CONTEXT coding_context;

    // Rate targetting variables
371
372
373
374
    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
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394

    int this_frame_target;
    int projected_frame_size;
    int last_q[2];                   // Separate values for Intra/Inter

    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;
395
    int active_arnr_frames;           // <= cpi->oxcf.arnr_max_frames
John Koleszar's avatar
John Koleszar committed
396

397
    int64_t key_frame_count;
John Koleszar's avatar
John Koleszar committed
398
399
400
401
402
403
    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;
404
405
406
    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
407
408
409
410
411
412
413
414
415

    int ni_av_qi;
    int ni_tot_qi;
    int ni_frames;
    int avg_frame_qindex;

    int zbin_over_quant;
    int zbin_mode_boost;
    int zbin_mode_boost_enabled;
416
417
    int last_zbin_over_quant;
    int last_zbin_mode_boost;
John Koleszar's avatar
John Koleszar committed
418

419
    int64_t total_byte_count;
John Koleszar's avatar
John Koleszar committed
420
421
422

    int buffered_mode;

423
    double frame_rate;
424
    int64_t buffer_level;
John Koleszar's avatar
John Koleszar committed
425
426
427
428
429
430
431
432
    int bits_off_target;

    int rolling_target_bits;
    int rolling_actual_bits;

    int long_rolling_target_bits;
    int long_rolling_actual_bits;

433
    int64_t total_actual_bits;
John Koleszar's avatar
John Koleszar committed
434
435
436
437
438
439
440
    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
441
    int cq_target_quality;
442

John Koleszar's avatar
John Koleszar committed
443
444
445
446
447
448
449
450
451
452
453
454
    int drop_frames_allowed;          // Are we permitted to drop frames?
    int drop_frame;                  // Drop this frame?
    int drop_count;                  // How many frames have we dropped?
    int max_drop_count;               // How many frames should we drop?
    int max_consec_dropped_frames;     // Limit number of consecutive frames that can be dropped.


    int ymode_count [VP8_YMODES];        /* intra MB type cts this frame */
    int uv_mode_count[VP8_UV_MODES];       /* intra MB type cts this frame */

    unsigned int MVcount [2] [MVvals];  /* (row,col) MV cts this frame */

455
456
    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
457
    //save vp8_tree_probs_from_distribution result for each frame to avoid repeat calculation
458
459
    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];
John Koleszar's avatar
John Koleszar committed
460
461
462
463
464
465
466

    int gfu_boost;
    int kf_boost;
    int last_boost;

    int target_bandwidth;
    struct vpx_codec_pkt_list  *output_pkt_list;
467

John Koleszar's avatar
John Koleszar committed
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
#if 0
    // Experimental code for lagged and one pass
    ONEPASS_FRAMESTATS one_pass_frame_stats[MAX_LAG_BUFFERS];
    int one_pass_frame_index;
#endif

    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 auto_gold;
    int auto_adjust_gold_quantizer;
    int goldfreq;
    int auto_worst_q;
    int cpu_used;
    int horiz_scale;
    int vert_scale;
    int pass;


    int prob_intra_coded;
    int prob_last_coded;
    int prob_gf_coded;
    int prob_skip_false;
    int last_skip_false_probs[3];
    int last_skip_probs_q[3];
    int recent_ref_frame_usage[MAX_REF_FRAMES];

    int count_mb_ref_frame_usage[MAX_REF_FRAMES];
    int this_frame_percent_intra;
    int last_frame_percent_intra;

    int ref_frame_flags;

    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;
    int skip_true_count;
    int skip_false_count;

    unsigned char *segmentation_map;
    signed char segment_feature_data[MB_LVL_MAX][MAX_MB_SEGMENTS];            // Segment data (can be deltas or absolute values)
    int  segment_encode_breakout[MAX_MB_SEGMENTS];                    // segment threashold for encode breakout

    unsigned char *active_map;
    unsigned int active_map_enabled;
    // Video conferencing cyclic refresh mode flags etc
    // This is a mode designed to clean up the background over time in live encoding scenarious. It uses segmentation
    int cyclic_refresh_mode_enabled;
    int cyclic_refresh_mode_max_mbs_perframe;
    int cyclic_refresh_mode_index;
    int cyclic_refresh_q;
    signed char *cyclic_refresh_map;

533
#if CONFIG_MULTITHREAD
John Koleszar's avatar
John Koleszar committed
534
    // multithread data
Attila Nagy's avatar
Attila Nagy committed
535
536
    int * mt_current_mb_col;
    int mt_sync_range;
John Koleszar's avatar
John Koleszar committed
537
538
539
540
    int b_multi_threaded;
    int encoding_thread_count;

    pthread_t *h_encoding_thread;
541
542
    pthread_t h_filter_thread;

John Koleszar's avatar
John Koleszar committed
543
544
    MB_ROW_COMP *mb_row_ei;
    ENCODETHREAD_DATA *en_thread_data;
545
    LPFTHREAD_DATA lpf_thread_data;
John Koleszar's avatar
John Koleszar committed
546
547

    //events
Attila Nagy's avatar
Attila Nagy committed
548
549
    sem_t *h_event_start_encoding;
    sem_t h_event_end_encoding;
550
551
    sem_t h_event_start_lpf;
    sem_t h_event_end_lpf;
John Koleszar's avatar
John Koleszar committed
552
553
554
#endif

    TOKENLIST *tplist;
555
    unsigned int partition_sz[MAX_PARTITIONS];
John Koleszar's avatar
John Koleszar committed
556
557
558
559
560
    // end of multithread data


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

    int base_skip_false_prob[128];

571
572
573
574
575
576
577
578
    struct twopass_rc
    {
        unsigned int section_intra_rating;
        double section_max_qfactor;
        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;
Paul Wilkins's avatar
Paul Wilkins committed
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
598
        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 gf_decay_rate;
        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
599
        int64_t kf_group_bits;
600
601

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

        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
606
        int alt_extra_bits;
607
608
        double est_max_qcorrection_factor;
    } twopass;
John Koleszar's avatar
John Koleszar committed
609
610
611
612
613

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

619
#if CONFIG_INTERNAL_STATS
John Koleszar's avatar
John Koleszar committed
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
    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;
645

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

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

656
657
    int output_partition;

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

663
    int force_next_frame_intra; /* force next frame to intra when kf_auto says so */
664

John Koleszar's avatar
John Koleszar committed
665
    int droppable;
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684

    // Coding layer state variables
    unsigned int current_layer;
    LAYER_CONTEXT layer_context[MAX_LAYERS];

    long long frames_in_layer[MAX_LAYERS];
    long long bytes_in_layer[MAX_LAYERS];
    double sum_psnr[MAX_LAYERS];
    double sum_psnr_p[MAX_LAYERS];
    double total_error2[MAX_LAYERS];
    double total_error2_p[MAX_LAYERS];
    double sum_ssim[MAX_LAYERS];
    double sum_weights[MAX_LAYERS];

    double total_ssimg_y_in_layer[MAX_LAYERS];
    double total_ssimg_u_in_layer[MAX_LAYERS];
    double total_ssimg_v_in_layer[MAX_LAYERS];
    double total_ssimg_all_in_layer[MAX_LAYERS];

Yunqing Wang's avatar
Yunqing Wang committed
685
686
687
688
689
#if CONFIG_MULTI_RES_ENCODING
    /* Number of MBs per row at lower-resolution level */
    int    mr_low_res_mb_cols;
#endif

John Koleszar's avatar
John Koleszar committed
690
691
692
693
694
695
} VP8_COMP;

void control_data_rate(VP8_COMP *cpi);

void vp8_encode_frame(VP8_COMP *cpi);

696
void vp8_pack_bitstream(VP8_COMP *cpi, unsigned char *dest, unsigned char *dest_end, unsigned long *size);
John Koleszar's avatar
John Koleszar committed
697

698
void vp8_activity_masking(VP8_COMP *cpi, MACROBLOCK *x);
699

John Koleszar's avatar
John Koleszar committed
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
int rd_cost_intra_mb(MACROBLOCKD *x);

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

void vp8_set_speed_features(VP8_COMP *cpi);

#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