2 * Copyright (c) 2010 The WebM project authors. All Rights Reserved.
4 * Use of this source code is governed by a BSD-style license
5 * that can be found in the LICENSE file in the root of the source
6 * 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.
12 #include "vp8/common/onyxc_int.h"
14 #include "vp8/common/systemdependent.h"
16 #include "vp8/common/alloccommon.h"
18 #include "firstpass.h"
20 #include "vpx_scale/vpxscale.h"
21 #include "vp8/common/extend.h"
23 #include "vp8/common/quant_common.h"
24 #include "segmentation.h"
25 #include "vp8/common/g_common.h"
26 #include "vpx_scale/yv12extend.h"
27 #include "vp8/common/postproc.h"
28 #include "vpx_mem/vpx_mem.h"
29 #include "vp8/common/swapyv12buffer.h"
30 #include "vp8/common/threading.h"
31 #include "vpx_ports/vpx_timer.h"
32 #include "temporal_filter.h"
34 #include "vpx_ports/arm.h"
41 #if CONFIG_RUNTIME_CPU_DETECT
42 #define IF_RTCD(x) (x)
43 #define RTCD(x) &cpi->common.rtcd.x
45 #define IF_RTCD(x) NULL
49 extern void vp8cx_pick_filter_level_fast(YV12_BUFFER_CONFIG *sd, VP8_COMP *cpi);
50 extern void vp8cx_set_alt_lf_level(VP8_COMP *cpi, int filt_val);
51 extern void vp8cx_pick_filter_level(YV12_BUFFER_CONFIG *sd, VP8_COMP *cpi);
53 extern void vp8_init_loop_filter(VP8_COMMON *cm);
54 extern void vp8_loop_filter_frame(VP8_COMMON *cm, MACROBLOCKD *mbd, int filt_val);
55 extern void vp8_loop_filter_frame_yonly(VP8_COMMON *cm, MACROBLOCKD *mbd, int filt_val, int sharpness_lvl);
56 extern void vp8_dmachine_specific_config(VP8_COMP *cpi);
57 extern void vp8_cmachine_specific_config(VP8_COMP *cpi);
58 extern void vp8_deblock_frame(YV12_BUFFER_CONFIG *source, YV12_BUFFER_CONFIG *post, int filt_lvl, int low_var_thresh, int flag);
59 extern void print_parms(VP8_CONFIG *ocf, char *filenam);
60 extern unsigned int vp8_get_processor_freq();
61 extern void print_tree_update_probs();
62 extern void vp8cx_create_encoder_threads(VP8_COMP *cpi);
63 extern void vp8cx_remove_encoder_threads(VP8_COMP *cpi);
65 extern void vp8_yv12_copy_frame_func_neon(YV12_BUFFER_CONFIG *src_ybc, YV12_BUFFER_CONFIG *dst_ybc);
66 extern void vp8_yv12_copy_src_frame_func_neon(YV12_BUFFER_CONFIG *src_ybc, YV12_BUFFER_CONFIG *dst_ybc);
69 int vp8_estimate_entropy_savings(VP8_COMP *cpi);
70 int vp8_calc_ss_err(YV12_BUFFER_CONFIG *source, YV12_BUFFER_CONFIG *dest, const vp8_variance_rtcd_vtable_t *rtcd);
72 extern void vp8_temporal_filter_prepare_c(VP8_COMP *cpi, int distance);
74 static void set_default_lf_deltas(VP8_COMP *cpi);
76 extern const int vp8_gf_interval_table[101];
78 #if CONFIG_INTERNAL_STATS
81 extern double vp8_calc_ssim
83 YV12_BUFFER_CONFIG *source,
84 YV12_BUFFER_CONFIG *dest,
87 const vp8_variance_rtcd_vtable_t *rtcd
91 extern double vp8_calc_ssimg
93 YV12_BUFFER_CONFIG *source,
94 YV12_BUFFER_CONFIG *dest,
98 const vp8_variance_rtcd_vtable_t *rtcd
105 #ifdef OUTPUT_YUV_SRC
116 extern int skip_true_count;
117 extern int skip_false_count;
122 extern int intra_mode_stats[10][10][10];
126 unsigned int frames_at_speed[16] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
127 unsigned int tot_pm = 0;
128 unsigned int cnt_pm = 0;
129 unsigned int tot_ef = 0;
130 unsigned int cnt_ef = 0;
134 extern unsigned __int64 Sectionbits[50];
135 extern int y_modes[5] ;
136 extern int uv_modes[4] ;
137 extern int b_modes[10] ;
139 extern int inter_y_modes[10] ;
140 extern int inter_uv_modes[4] ;
141 extern unsigned int inter_b_modes[15];
144 extern void (*vp8_short_fdct4x4)(short *input, short *output, int pitch);
145 extern void (*vp8_short_fdct8x4)(short *input, short *output, int pitch);
147 extern const int vp8_bits_per_mb[2][QINDEX_RANGE];
149 extern const int qrounding_factors[129];
150 extern const int qzbin_factors[129];
151 extern void vp8cx_init_quantizer(VP8_COMP *cpi);
152 extern const int vp8cx_base_skip_false_prob[128];
154 // Tables relating active max Q to active min Q
155 static const int kf_low_motion_minq[QINDEX_RANGE] =
157 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
158 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
159 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
160 0,0,0,0,1,1,1,1,1,1,1,1,2,2,2,2,
161 3,3,3,3,3,3,4,4,4,5,5,5,5,5,6,6,
162 6,6,7,7,8,8,8,8,9,9,10,10,10,10,11,11,
163 11,11,12,12,13,13,13,13,14,14,15,15,15,15,16,16,
164 16,16,17,17,18,18,18,18,19,20,20,21,21,22,23,23
166 static const int kf_high_motion_minq[QINDEX_RANGE] =
168 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
169 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
170 1,1,1,1,1,1,1,1,2,2,2,2,3,3,3,3,
171 3,3,3,3,4,4,4,4,5,5,5,5,5,5,6,6,
172 6,6,7,7,8,8,8,8,9,9,10,10,10,10,11,11,
173 11,11,12,12,13,13,13,13,14,14,15,15,15,15,16,16,
174 16,16,17,17,18,18,18,18,19,19,20,20,20,20,21,21,
175 21,21,22,22,23,23,24,25,25,26,26,27,28,28,29,30
177 static const int gf_low_motion_minq[QINDEX_RANGE] =
179 0,0,0,0,1,1,1,1,1,1,1,1,2,2,2,2,
180 3,3,3,3,4,4,4,4,5,5,5,5,6,6,6,6,
181 7,7,7,7,8,8,8,8,9,9,9,9,10,10,10,10,
182 11,11,12,12,13,13,14,14,15,15,16,16,17,17,18,18,
183 19,19,20,20,21,21,22,22,23,23,24,24,25,25,26,26,
184 27,27,28,28,29,29,30,30,31,31,32,32,33,33,34,34,
185 35,35,36,36,37,37,38,38,39,39,40,40,41,41,42,42,
186 43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58
188 static const int gf_mid_motion_minq[QINDEX_RANGE] =
190 0,0,0,0,1,1,1,1,1,1,2,2,3,3,3,4,
191 4,4,5,5,5,6,6,6,7,7,7,8,8,8,9,9,
192 9,10,10,10,10,11,11,11,12,12,12,12,13,13,13,14,
193 14,14,15,15,16,16,17,17,18,18,19,19,20,20,21,21,
194 22,22,23,23,24,24,25,25,26,26,27,27,28,28,29,29,
195 30,30,31,31,32,32,33,33,34,34,35,35,36,36,37,37,
196 38,39,39,40,40,41,41,42,42,43,43,44,45,46,47,48,
197 49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64
199 static const int gf_high_motion_minq[QINDEX_RANGE] =
201 0,0,0,0,1,1,1,1,1,2,2,2,3,3,3,4,
202 4,4,5,5,5,6,6,6,7,7,7,8,8,8,9,9,
203 9,10,10,10,11,11,12,12,13,13,14,14,15,15,16,16,
204 17,17,18,18,19,19,20,20,21,21,22,22,23,23,24,24,
205 25,25,26,26,27,27,28,28,29,29,30,30,31,31,32,32,
206 33,33,34,34,35,35,36,36,37,37,38,38,39,39,40,40,
207 41,41,42,42,43,44,45,46,47,48,49,50,51,52,53,54,
208 55,56,57,58,59,60,62,64,66,68,70,72,74,76,78,80
210 static const int inter_minq[QINDEX_RANGE] =
212 0,0,1,1,2,3,3,4,4,5,6,6,7,8,8,9,
213 9,10,11,11,12,13,13,14,15,15,16,17,17,18,19,20,
214 20,21,22,22,23,24,24,25,26,27,27,28,29,30,30,31,
215 32,33,33,34,35,36,36,37,38,39,39,40,41,42,42,43,
216 44,45,46,46,47,48,49,50,50,51,52,53,54,55,55,56,
217 57,58,59,60,60,61,62,63,64,65,66,67,67,68,69,70,
218 71,72,73,74,75,75,76,77,78,79,80,81,82,83,84,85,
219 86,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100
222 void vp8_initialize()
224 static int init_done = 0;
228 vp8_scale_machine_specific_config();
229 vp8_initialize_common();
230 //vp8_dmachine_specific_config();
231 vp8_tokenize_initialize();
236 #ifdef PACKET_TESTING
237 extern FILE *vpxlogc;
240 static void setup_features(VP8_COMP *cpi)
242 // Set up default state for MB feature flags
243 cpi->mb.e_mbd.segmentation_enabled = 0;
244 cpi->mb.e_mbd.update_mb_segmentation_map = 0;
245 cpi->mb.e_mbd.update_mb_segmentation_data = 0;
246 vpx_memset(cpi->mb.e_mbd.mb_segment_tree_probs, 255, sizeof(cpi->mb.e_mbd.mb_segment_tree_probs));
247 vpx_memset(cpi->mb.e_mbd.segment_feature_data, 0, sizeof(cpi->mb.e_mbd.segment_feature_data));
249 cpi->mb.e_mbd.mode_ref_lf_delta_enabled = 0;
250 cpi->mb.e_mbd.mode_ref_lf_delta_update = 0;
251 vpx_memset(cpi->mb.e_mbd.ref_lf_deltas, 0, sizeof(cpi->mb.e_mbd.ref_lf_deltas));
252 vpx_memset(cpi->mb.e_mbd.mode_lf_deltas, 0, sizeof(cpi->mb.e_mbd.mode_lf_deltas));
253 vpx_memset(cpi->mb.e_mbd.last_ref_lf_deltas, 0, sizeof(cpi->mb.e_mbd.ref_lf_deltas));
254 vpx_memset(cpi->mb.e_mbd.last_mode_lf_deltas, 0, sizeof(cpi->mb.e_mbd.mode_lf_deltas));
256 set_default_lf_deltas(cpi);
261 static void dealloc_compressor_data(VP8_COMP *cpi)
263 vpx_free(cpi->tplist);
266 // Delete last frame MV storage buffers
270 vpx_free(cpi->lf_ref_frame_sign_bias);
271 cpi->lf_ref_frame_sign_bias = 0;
273 vpx_free(cpi->lf_ref_frame);
274 cpi->lf_ref_frame = 0;
276 // Delete sementation map
277 vpx_free(cpi->segmentation_map);
278 cpi->segmentation_map = 0;
280 vpx_free(cpi->active_map);
283 vp8_de_alloc_frame_buffers(&cpi->common);
285 vp8_yv12_de_alloc_frame_buffer(&cpi->last_frame_uf);
286 vp8_yv12_de_alloc_frame_buffer(&cpi->scaled_source);
287 #if VP8_TEMPORAL_ALT_REF
288 vp8_yv12_de_alloc_frame_buffer(&cpi->alt_ref_buffer);
290 vp8_lookahead_destroy(cpi->lookahead);
295 // Structure used to monitor GF usage
296 vpx_free(cpi->gf_active_flags);
297 cpi->gf_active_flags = 0;
299 // Activity mask based per mb zbin adjustments
300 vpx_free(cpi->mb_activity_map);
301 cpi->mb_activity_map = 0;
302 vpx_free(cpi->mb_norm_activity_map);
303 cpi->mb_norm_activity_map = 0;
305 vpx_free(cpi->mb.pip);
308 #if !(CONFIG_REALTIME_ONLY)
309 vpx_free(cpi->twopass.total_stats);
310 cpi->twopass.total_stats = 0;
312 vpx_free(cpi->twopass.this_frame_stats);
313 cpi->twopass.this_frame_stats = 0;
317 static void enable_segmentation(VP8_PTR ptr)
319 VP8_COMP *cpi = (VP8_COMP *)(ptr);
321 // Set the appropriate feature bit
322 cpi->mb.e_mbd.segmentation_enabled = 1;
323 cpi->mb.e_mbd.update_mb_segmentation_map = 1;
324 cpi->mb.e_mbd.update_mb_segmentation_data = 1;
326 static void disable_segmentation(VP8_PTR ptr)
328 VP8_COMP *cpi = (VP8_COMP *)(ptr);
330 // Clear the appropriate feature bit
331 cpi->mb.e_mbd.segmentation_enabled = 0;
334 // Valid values for a segment are 0 to 3
335 // Segmentation map is arrange as [Rows][Columns]
336 static void set_segmentation_map(VP8_PTR ptr, unsigned char *segmentation_map)
338 VP8_COMP *cpi = (VP8_COMP *)(ptr);
340 // Copy in the new segmentation map
341 vpx_memcpy(cpi->segmentation_map, segmentation_map, (cpi->common.mb_rows * cpi->common.mb_cols));
343 // Signal that the map should be updated.
344 cpi->mb.e_mbd.update_mb_segmentation_map = 1;
345 cpi->mb.e_mbd.update_mb_segmentation_data = 1;
348 // The values given for each segment can be either deltas (from the default value chosen for the frame) or absolute values.
350 // Valid range for abs values is (0-127 for MB_LVL_ALT_Q) , (0-63 for SEGMENT_ALT_LF)
351 // Valid range for delta values are (+/-127 for MB_LVL_ALT_Q) , (+/-63 for SEGMENT_ALT_LF)
353 // abs_delta = SEGMENT_DELTADATA (deltas) abs_delta = SEGMENT_ABSDATA (use the absolute values given).
356 static void set_segment_data(VP8_PTR ptr, signed char *feature_data, unsigned char abs_delta)
358 VP8_COMP *cpi = (VP8_COMP *)(ptr);
360 cpi->mb.e_mbd.mb_segement_abs_delta = abs_delta;
361 vpx_memcpy(cpi->segment_feature_data, feature_data, sizeof(cpi->segment_feature_data));
365 static void segmentation_test_function(VP8_PTR ptr)
367 VP8_COMP *cpi = (VP8_COMP *)(ptr);
369 unsigned char *seg_map;
370 signed char feature_data[MB_LVL_MAX][MAX_MB_SEGMENTS];
372 // Create a temporary map for segmentation data.
373 CHECK_MEM_ERROR(seg_map, vpx_calloc(cpi->common.mb_rows * cpi->common.mb_cols, 1));
375 // MB loop to set local segmentation map
376 /*for ( i = 0; i < cpi->common.mb_rows; i++ )
378 for ( j = 0; j < cpi->common.mb_cols; j++ )
380 //seg_map[(i*cpi->common.mb_cols) + j] = (j % 2) + ((i%2)* 2);
381 //if ( j < cpi->common.mb_cols/2 )
383 // Segment 1 around the edge else 0
384 if ( (i == 0) || (j == 0) || (i == (cpi->common.mb_rows-1)) || (j == (cpi->common.mb_cols-1)) )
385 seg_map[(i*cpi->common.mb_cols) + j] = 1;
386 //else if ( (i < 2) || (j < 2) || (i > (cpi->common.mb_rows-3)) || (j > (cpi->common.mb_cols-3)) )
387 // seg_map[(i*cpi->common.mb_cols) + j] = 2;
388 //else if ( (i < 5) || (j < 5) || (i > (cpi->common.mb_rows-6)) || (j > (cpi->common.mb_cols-6)) )
389 // seg_map[(i*cpi->common.mb_cols) + j] = 3;
391 seg_map[(i*cpi->common.mb_cols) + j] = 0;
395 // Set the segmentation Map
396 set_segmentation_map(ptr, seg_map);
398 // Activate segmentation.
399 enable_segmentation(ptr);
401 // Set up the quant segment data
402 feature_data[MB_LVL_ALT_Q][0] = 0;
403 feature_data[MB_LVL_ALT_Q][1] = 4;
404 feature_data[MB_LVL_ALT_Q][2] = 0;
405 feature_data[MB_LVL_ALT_Q][3] = 0;
406 // Set up the loop segment data
407 feature_data[MB_LVL_ALT_LF][0] = 0;
408 feature_data[MB_LVL_ALT_LF][1] = 0;
409 feature_data[MB_LVL_ALT_LF][2] = 0;
410 feature_data[MB_LVL_ALT_LF][3] = 0;
412 // Initialise the feature data structure
413 // SEGMENT_DELTADATA 0, SEGMENT_ABSDATA 1
414 set_segment_data(ptr, &feature_data[0][0], SEGMENT_DELTADATA);
416 // Delete sementation map
423 // A simple function to cyclically refresh the background at a lower Q
424 static void cyclic_background_refresh(VP8_COMP *cpi, int Q, int lf_adjustment)
426 unsigned char *seg_map;
427 signed char feature_data[MB_LVL_MAX][MAX_MB_SEGMENTS];
429 int block_count = cpi->cyclic_refresh_mode_max_mbs_perframe;
430 int mbs_in_frame = cpi->common.mb_rows * cpi->common.mb_cols;
432 // Create a temporary map for segmentation data.
433 CHECK_MEM_ERROR(seg_map, vpx_calloc(cpi->common.mb_rows * cpi->common.mb_cols, 1));
435 cpi->cyclic_refresh_q = Q;
437 for (i = Q; i > 0; i--)
439 if (vp8_bits_per_mb[cpi->common.frame_type][i] >= ((vp8_bits_per_mb[cpi->common.frame_type][Q]*(Q + 128)) / 64))
440 //if ( vp8_bits_per_mb[cpi->common.frame_type][i] >= ((vp8_bits_per_mb[cpi->common.frame_type][Q]*((2*Q)+96))/64) )
446 cpi->cyclic_refresh_q = i;
448 // Only update for inter frames
449 if (cpi->common.frame_type != KEY_FRAME)
451 // Cycle through the macro_block rows
452 // MB loop to set local segmentation map
453 for (i = cpi->cyclic_refresh_mode_index; i < mbs_in_frame; i++)
455 // If the MB is as a candidate for clean up then mark it for possible boost/refresh (segment 1)
456 // The segment id may get reset to 0 later if the MB gets coded anything other than last frame 0,0
457 // as only (last frame 0,0) MBs are eligable for refresh : that is to say Mbs likely to be background blocks.
458 if (cpi->cyclic_refresh_map[i] == 0)
466 // Skip blocks that have been refreshed recently anyway.
467 if (cpi->cyclic_refresh_map[i] < 0)
468 //cpi->cyclic_refresh_map[i] = cpi->cyclic_refresh_map[i] / 16;
469 cpi->cyclic_refresh_map[i]++;
480 // If we have gone through the frame reset to the start
481 cpi->cyclic_refresh_mode_index = i;
483 if (cpi->cyclic_refresh_mode_index >= mbs_in_frame)
484 cpi->cyclic_refresh_mode_index = 0;
487 // Set the segmentation Map
488 set_segmentation_map((VP8_PTR)cpi, seg_map);
490 // Activate segmentation.
491 enable_segmentation((VP8_PTR)cpi);
493 // Set up the quant segment data
494 feature_data[MB_LVL_ALT_Q][0] = 0;
495 feature_data[MB_LVL_ALT_Q][1] = (cpi->cyclic_refresh_q - Q);
496 feature_data[MB_LVL_ALT_Q][2] = 0;
497 feature_data[MB_LVL_ALT_Q][3] = 0;
499 // Set up the loop segment data
500 feature_data[MB_LVL_ALT_LF][0] = 0;
501 feature_data[MB_LVL_ALT_LF][1] = lf_adjustment;
502 feature_data[MB_LVL_ALT_LF][2] = 0;
503 feature_data[MB_LVL_ALT_LF][3] = 0;
505 // Initialise the feature data structure
506 // SEGMENT_DELTADATA 0, SEGMENT_ABSDATA 1
507 set_segment_data((VP8_PTR)cpi, &feature_data[0][0], SEGMENT_DELTADATA);
509 // Delete sementation map
516 static void set_default_lf_deltas(VP8_COMP *cpi)
518 cpi->mb.e_mbd.mode_ref_lf_delta_enabled = 1;
519 cpi->mb.e_mbd.mode_ref_lf_delta_update = 1;
521 vpx_memset(cpi->mb.e_mbd.ref_lf_deltas, 0, sizeof(cpi->mb.e_mbd.ref_lf_deltas));
522 vpx_memset(cpi->mb.e_mbd.mode_lf_deltas, 0, sizeof(cpi->mb.e_mbd.mode_lf_deltas));
524 // Test of ref frame deltas
525 cpi->mb.e_mbd.ref_lf_deltas[INTRA_FRAME] = 2;
526 cpi->mb.e_mbd.ref_lf_deltas[LAST_FRAME] = 0;
527 cpi->mb.e_mbd.ref_lf_deltas[GOLDEN_FRAME] = -2;
528 cpi->mb.e_mbd.ref_lf_deltas[ALTREF_FRAME] = -2;
530 cpi->mb.e_mbd.mode_lf_deltas[0] = 4; // BPRED
531 cpi->mb.e_mbd.mode_lf_deltas[1] = -2; // Zero
532 cpi->mb.e_mbd.mode_lf_deltas[2] = 2; // New mv
533 cpi->mb.e_mbd.mode_lf_deltas[3] = 4; // Split mv
536 void vp8_set_speed_features(VP8_COMP *cpi)
538 SPEED_FEATURES *sf = &cpi->sf;
539 int Mode = cpi->compressor_speed;
540 int Speed = cpi->Speed;
542 VP8_COMMON *cm = &cpi->common;
543 int last_improved_quant = sf->improved_quant;
545 // Initialise default mode frequency sampling variables
546 for (i = 0; i < MAX_MODES; i ++)
548 cpi->mode_check_freq[i] = 0;
549 cpi->mode_test_hit_counts[i] = 0;
550 cpi->mode_chosen_counts[i] = 0;
553 cpi->mbs_tested_so_far = 0;
555 // best quality defaults
557 sf->search_method = NSTEP;
558 sf->improved_quant = 1;
559 sf->improved_dct = 1;
562 sf->quarter_pixel_search = 1;
563 sf->half_pixel_search = 1;
564 sf->full_freq[0] = 7;
565 sf->full_freq[1] = 7;
566 sf->min_fs_radius = 8;
567 sf->max_fs_radius = 32;
568 sf->iterative_sub_pixel = 1;
569 sf->optimize_coefficients = 1;
570 sf->use_fastquant_for_pick = 0;
571 sf->no_skip_block4x4_search = 1;
574 sf->max_step_search_steps = MAX_MVSEARCH_STEPS;
575 sf->improved_mv_pred = 1;
577 // default thresholds to 0
578 for (i = 0; i < MAX_MODES; i++)
579 sf->thresh_mult[i] = 0;
583 #if !(CONFIG_REALTIME_ONLY)
584 case 0: // best quality mode
585 sf->thresh_mult[THR_ZEROMV ] = 0;
586 sf->thresh_mult[THR_ZEROG ] = 0;
587 sf->thresh_mult[THR_ZEROA ] = 0;
588 sf->thresh_mult[THR_NEARESTMV] = 0;
589 sf->thresh_mult[THR_NEARESTG ] = 0;
590 sf->thresh_mult[THR_NEARESTA ] = 0;
591 sf->thresh_mult[THR_NEARMV ] = 0;
592 sf->thresh_mult[THR_NEARG ] = 0;
593 sf->thresh_mult[THR_NEARA ] = 0;
595 sf->thresh_mult[THR_DC ] = 0;
597 sf->thresh_mult[THR_V_PRED ] = 1000;
598 sf->thresh_mult[THR_H_PRED ] = 1000;
599 sf->thresh_mult[THR_B_PRED ] = 2000;
600 sf->thresh_mult[THR_TM ] = 1000;
602 sf->thresh_mult[THR_NEWMV ] = 1000;
603 sf->thresh_mult[THR_NEWG ] = 1000;
604 sf->thresh_mult[THR_NEWA ] = 1000;
606 sf->thresh_mult[THR_SPLITMV ] = 2500;
607 sf->thresh_mult[THR_SPLITG ] = 5000;
608 sf->thresh_mult[THR_SPLITA ] = 5000;
610 sf->full_freq[0] = 7;
611 sf->full_freq[1] = 15;
614 sf->max_step_search_steps = MAX_MVSEARCH_STEPS;
618 sf->thresh_mult[THR_NEARESTMV] = 0;
619 sf->thresh_mult[THR_ZEROMV ] = 0;
620 sf->thresh_mult[THR_DC ] = 0;
621 sf->thresh_mult[THR_NEARMV ] = 0;
622 sf->thresh_mult[THR_V_PRED ] = 1000;
623 sf->thresh_mult[THR_H_PRED ] = 1000;
624 sf->thresh_mult[THR_B_PRED ] = 2500;
625 sf->thresh_mult[THR_TM ] = 1000;
627 sf->thresh_mult[THR_NEARESTG ] = 1000;
628 sf->thresh_mult[THR_NEARESTA ] = 1000;
630 sf->thresh_mult[THR_ZEROG ] = 1000;
631 sf->thresh_mult[THR_ZEROA ] = 1000;
632 sf->thresh_mult[THR_NEARG ] = 1000;
633 sf->thresh_mult[THR_NEARA ] = 1000;
636 sf->thresh_mult[THR_ZEROMV ] = 0;
637 sf->thresh_mult[THR_ZEROG ] = 0;
638 sf->thresh_mult[THR_ZEROA ] = 0;
639 sf->thresh_mult[THR_NEARESTMV] = 0;
640 sf->thresh_mult[THR_NEARESTG ] = 0;
641 sf->thresh_mult[THR_NEARESTA ] = 0;
642 sf->thresh_mult[THR_NEARMV ] = 0;
643 sf->thresh_mult[THR_NEARG ] = 0;
644 sf->thresh_mult[THR_NEARA ] = 0;
646 // sf->thresh_mult[THR_DC ] = 0;
648 // sf->thresh_mult[THR_V_PRED ] = 1000;
649 // sf->thresh_mult[THR_H_PRED ] = 1000;
650 // sf->thresh_mult[THR_B_PRED ] = 2000;
651 // sf->thresh_mult[THR_TM ] = 1000;
653 sf->thresh_mult[THR_NEWMV ] = 1000;
654 sf->thresh_mult[THR_NEWG ] = 1000;
655 sf->thresh_mult[THR_NEWA ] = 1000;
657 sf->thresh_mult[THR_SPLITMV ] = 1700;
658 sf->thresh_mult[THR_SPLITG ] = 4500;
659 sf->thresh_mult[THR_SPLITA ] = 4500;
661 sf->thresh_mult[THR_NEWMV ] = 1500;
662 sf->thresh_mult[THR_NEWG ] = 1500;
663 sf->thresh_mult[THR_NEWA ] = 1500;
665 sf->thresh_mult[THR_SPLITMV ] = 5000;
666 sf->thresh_mult[THR_SPLITG ] = 10000;
667 sf->thresh_mult[THR_SPLITA ] = 10000;
669 sf->full_freq[0] = 15;
670 sf->full_freq[1] = 31;
674 /* Disable coefficient optimization above speed 0 */
675 sf->optimize_coefficients = 0;
676 sf->use_fastquant_for_pick = 1;
677 sf->no_skip_block4x4_search = 0;
681 cpi->mode_check_freq[THR_SPLITG] = 2;
682 cpi->mode_check_freq[THR_SPLITA] = 2;
683 cpi->mode_check_freq[THR_SPLITMV] = 0;
688 cpi->mode_check_freq[THR_SPLITG] = 4;
689 cpi->mode_check_freq[THR_SPLITA] = 4;
690 cpi->mode_check_freq[THR_SPLITMV] = 2;
692 sf->thresh_mult[THR_TM ] = 1500;
693 sf->thresh_mult[THR_V_PRED ] = 1500;
694 sf->thresh_mult[THR_H_PRED ] = 1500;
695 sf->thresh_mult[THR_B_PRED ] = 5000;
697 if (cpi->ref_frame_flags & VP8_LAST_FLAG)
699 sf->thresh_mult[THR_NEWMV ] = 2000;
700 sf->thresh_mult[THR_SPLITMV ] = 10000;
703 if (cpi->ref_frame_flags & VP8_GOLD_FLAG)
705 sf->thresh_mult[THR_NEARESTG ] = 1500;
706 sf->thresh_mult[THR_ZEROG ] = 1500;
707 sf->thresh_mult[THR_NEARG ] = 1500;
708 sf->thresh_mult[THR_NEWG ] = 2000;
709 sf->thresh_mult[THR_SPLITG ] = 20000;
712 if (cpi->ref_frame_flags & VP8_ALT_FLAG)
714 sf->thresh_mult[THR_NEARESTA ] = 1500;
715 sf->thresh_mult[THR_ZEROA ] = 1500;
716 sf->thresh_mult[THR_NEARA ] = 1500;
717 sf->thresh_mult[THR_NEWA ] = 2000;
718 sf->thresh_mult[THR_SPLITA ] = 20000;
724 cpi->mode_check_freq[THR_SPLITG] = 15;
725 cpi->mode_check_freq[THR_SPLITA] = 15;
726 cpi->mode_check_freq[THR_SPLITMV] = 7;
728 sf->thresh_mult[THR_TM ] = 2000;
729 sf->thresh_mult[THR_V_PRED ] = 2000;
730 sf->thresh_mult[THR_H_PRED ] = 2000;
731 sf->thresh_mult[THR_B_PRED ] = 7500;
733 if (cpi->ref_frame_flags & VP8_LAST_FLAG)
735 sf->thresh_mult[THR_NEWMV ] = 2000;
736 sf->thresh_mult[THR_SPLITMV ] = 25000;
739 if (cpi->ref_frame_flags & VP8_GOLD_FLAG)
741 sf->thresh_mult[THR_NEARESTG ] = 2000;
742 sf->thresh_mult[THR_ZEROG ] = 2000;
743 sf->thresh_mult[THR_NEARG ] = 2000;
744 sf->thresh_mult[THR_NEWG ] = 2500;
745 sf->thresh_mult[THR_SPLITG ] = 50000;
748 if (cpi->ref_frame_flags & VP8_ALT_FLAG)
750 sf->thresh_mult[THR_NEARESTA ] = 2000;
751 sf->thresh_mult[THR_ZEROA ] = 2000;
752 sf->thresh_mult[THR_NEARA ] = 2000;
753 sf->thresh_mult[THR_NEWA ] = 2500;
754 sf->thresh_mult[THR_SPLITA ] = 50000;
757 sf->improved_quant = 0;
758 sf->improved_dct = 0;
760 // Only do recode loop on key frames, golden frames and
764 sf->full_freq[0] = 31;
765 sf->full_freq[1] = 63;
770 sf->thresh_mult[THR_SPLITA ] = INT_MAX;
771 sf->thresh_mult[THR_SPLITG ] = INT_MAX;
772 sf->thresh_mult[THR_SPLITMV ] = INT_MAX;
774 cpi->mode_check_freq[THR_V_PRED] = 0;
775 cpi->mode_check_freq[THR_H_PRED] = 0;
776 cpi->mode_check_freq[THR_B_PRED] = 0;
777 cpi->mode_check_freq[THR_NEARG] = 0;
778 cpi->mode_check_freq[THR_NEWG] = 0;
779 cpi->mode_check_freq[THR_NEARA] = 0;
780 cpi->mode_check_freq[THR_NEWA] = 0;
783 sf->recode_loop = 0; // recode loop off
784 sf->RD = 0; // Turn rd off
786 sf->full_freq[0] = 63;
787 sf->full_freq[1] = 127;
792 sf->auto_filter = 0; // Faster selection of loop filter
793 sf->full_freq[0] = INT_MAX;
794 sf->full_freq[1] = INT_MAX;
796 cpi->mode_check_freq[THR_V_PRED] = 2;
797 cpi->mode_check_freq[THR_H_PRED] = 2;
798 cpi->mode_check_freq[THR_B_PRED] = 2;
800 if (cpi->ref_frame_flags & VP8_GOLD_FLAG)
802 cpi->mode_check_freq[THR_NEARG] = 2;
803 cpi->mode_check_freq[THR_NEWG] = 4;
806 if (cpi->ref_frame_flags & VP8_ALT_FLAG)
808 cpi->mode_check_freq[THR_NEARA] = 2;
809 cpi->mode_check_freq[THR_NEWA] = 4;
812 if (cpi->ref_frame_flags & VP8_GOLD_FLAG)
814 sf->thresh_mult[THR_NEARESTG ] = 2000;
815 sf->thresh_mult[THR_ZEROG ] = 2000;
816 sf->thresh_mult[THR_NEARG ] = 2000;
817 sf->thresh_mult[THR_NEWG ] = 4000;
820 if (cpi->ref_frame_flags & VP8_ALT_FLAG)
822 sf->thresh_mult[THR_NEARESTA ] = 2000;
823 sf->thresh_mult[THR_ZEROA ] = 2000;
824 sf->thresh_mult[THR_NEARA ] = 2000;
825 sf->thresh_mult[THR_NEWA ] = 4000;
832 sf->optimize_coefficients = 0;
835 sf->iterative_sub_pixel = 1;
836 sf->thresh_mult[THR_NEARESTMV] = 0;
837 sf->thresh_mult[THR_ZEROMV ] = 0;
838 sf->thresh_mult[THR_DC ] = 0;
839 sf->thresh_mult[THR_TM ] = 0;
840 sf->thresh_mult[THR_NEARMV ] = 0;
841 sf->thresh_mult[THR_V_PRED ] = 1000;
842 sf->thresh_mult[THR_H_PRED ] = 1000;
843 sf->thresh_mult[THR_B_PRED ] = 2500;
844 sf->thresh_mult[THR_NEARESTG ] = 1000;
845 sf->thresh_mult[THR_ZEROG ] = 1000;
846 sf->thresh_mult[THR_NEARG ] = 1000;
847 sf->thresh_mult[THR_NEARESTA ] = 1000;
848 sf->thresh_mult[THR_ZEROA ] = 1000;
849 sf->thresh_mult[THR_NEARA ] = 1000;
850 sf->thresh_mult[THR_NEWMV ] = 2000;
851 sf->thresh_mult[THR_NEWG ] = 2000;
852 sf->thresh_mult[THR_NEWA ] = 2000;
853 sf->thresh_mult[THR_SPLITMV ] = 5000;
854 sf->thresh_mult[THR_SPLITG ] = 10000;
855 sf->thresh_mult[THR_SPLITA ] = 10000;
856 sf->full_freq[0] = 15;
857 sf->full_freq[1] = 31;
858 sf->search_method = NSTEP;
862 cpi->mode_check_freq[THR_SPLITG] = 4;
863 cpi->mode_check_freq[THR_SPLITA] = 4;
864 cpi->mode_check_freq[THR_SPLITMV] = 2;
866 sf->thresh_mult[THR_DC ] = 0;
867 sf->thresh_mult[THR_TM ] = 1000;
868 sf->thresh_mult[THR_V_PRED ] = 2000;
869 sf->thresh_mult[THR_H_PRED ] = 2000;
870 sf->thresh_mult[THR_B_PRED ] = 5000;
872 if (cpi->ref_frame_flags & VP8_LAST_FLAG)
874 sf->thresh_mult[THR_NEARESTMV] = 0;
875 sf->thresh_mult[THR_ZEROMV ] = 0;
876 sf->thresh_mult[THR_NEARMV ] = 0;
877 sf->thresh_mult[THR_NEWMV ] = 2000;
878 sf->thresh_mult[THR_SPLITMV ] = 10000;
881 if (cpi->ref_frame_flags & VP8_GOLD_FLAG)
883 sf->thresh_mult[THR_NEARESTG ] = 1000;
884 sf->thresh_mult[THR_ZEROG ] = 1000;
885 sf->thresh_mult[THR_NEARG ] = 1000;
886 sf->thresh_mult[THR_NEWG ] = 2000;
887 sf->thresh_mult[THR_SPLITG ] = 20000;
890 if (cpi->ref_frame_flags & VP8_ALT_FLAG)
892 sf->thresh_mult[THR_NEARESTA ] = 1000;
893 sf->thresh_mult[THR_ZEROA ] = 1000;
894 sf->thresh_mult[THR_NEARA ] = 1000;
895 sf->thresh_mult[THR_NEWA ] = 2000;
896 sf->thresh_mult[THR_SPLITA ] = 20000;
899 sf->improved_quant = 0;
900 sf->improved_dct = 0;
905 cpi->mode_check_freq[THR_SPLITMV] = 7;
906 cpi->mode_check_freq[THR_SPLITG] = 15;
907 cpi->mode_check_freq[THR_SPLITA] = 15;
909 sf->thresh_mult[THR_TM ] = 2000;
910 sf->thresh_mult[THR_V_PRED ] = 2000;
911 sf->thresh_mult[THR_H_PRED ] = 2000;
912 sf->thresh_mult[THR_B_PRED ] = 5000;
914 if (cpi->ref_frame_flags & VP8_LAST_FLAG)
916 sf->thresh_mult[THR_NEWMV ] = 2000;
917 sf->thresh_mult[THR_SPLITMV ] = 25000;
920 if (cpi->ref_frame_flags & VP8_GOLD_FLAG)
922 sf->thresh_mult[THR_NEARESTG ] = 2000;
923 sf->thresh_mult[THR_ZEROG ] = 2000;
924 sf->thresh_mult[THR_NEARG ] = 2000;
925 sf->thresh_mult[THR_NEWG ] = 2500;
926 sf->thresh_mult[THR_SPLITG ] = 50000;
929 if (cpi->ref_frame_flags & VP8_ALT_FLAG)
931 sf->thresh_mult[THR_NEARESTA ] = 2000;
932 sf->thresh_mult[THR_ZEROA ] = 2000;
933 sf->thresh_mult[THR_NEARA ] = 2000;
934 sf->thresh_mult[THR_NEWA ] = 2500;
935 sf->thresh_mult[THR_SPLITA ] = 50000;
938 sf->full_freq[0] = 31;
939 sf->full_freq[1] = 63;
944 sf->auto_filter = 0; // Faster selection of loop filter
946 cpi->mode_check_freq[THR_V_PRED] = 2;
947 cpi->mode_check_freq[THR_H_PRED] = 2;
948 cpi->mode_check_freq[THR_B_PRED] = 2;
950 if (cpi->ref_frame_flags & VP8_GOLD_FLAG)
952 cpi->mode_check_freq[THR_NEARG] = 2;
953 cpi->mode_check_freq[THR_NEWG] = 4;
956 if (cpi->ref_frame_flags & VP8_ALT_FLAG)
958 cpi->mode_check_freq[THR_NEARA] = 2;
959 cpi->mode_check_freq[THR_NEWA] = 4;
962 sf->thresh_mult[THR_SPLITMV ] = INT_MAX;
963 sf->thresh_mult[THR_SPLITG ] = INT_MAX;
964 sf->thresh_mult[THR_SPLITA ] = INT_MAX;
966 sf->full_freq[0] = 63;
967 sf->full_freq[1] = 127;
973 sf->full_freq[0] = INT_MAX;
974 sf->full_freq[1] = INT_MAX;
981 sf->auto_filter = 0; // Faster selection of loop filter
983 #if CONFIG_REALTIME_ONLY
984 sf->search_method = HEX;
986 sf->search_method = DIAMOND;
988 sf->iterative_sub_pixel = 0;
990 cpi->mode_check_freq[THR_V_PRED] = 4;
991 cpi->mode_check_freq[THR_H_PRED] = 4;
992 cpi->mode_check_freq[THR_B_PRED] = 4;
994 if (cpi->ref_frame_flags & VP8_GOLD_FLAG)
996 cpi->mode_check_freq[THR_NEARG] = 2;
997 cpi->mode_check_freq[THR_NEWG] = 4;
1000 if (cpi->ref_frame_flags & VP8_ALT_FLAG)
1002 cpi->mode_check_freq[THR_NEARA] = 2;
1003 cpi->mode_check_freq[THR_NEWA] = 4;
1006 sf->thresh_mult[THR_TM ] = 2000;
1007 sf->thresh_mult[THR_B_PRED ] = 5000;
1009 if (cpi->ref_frame_flags & VP8_GOLD_FLAG)
1011 sf->thresh_mult[THR_NEARESTG ] = 2000;
1012 sf->thresh_mult[THR_ZEROG ] = 2000;
1013 sf->thresh_mult[THR_NEARG ] = 2000;
1014 sf->thresh_mult[THR_NEWG ] = 4000;
1017 if (cpi->ref_frame_flags & VP8_ALT_FLAG)
1019 sf->thresh_mult[THR_NEARESTA ] = 2000;
1020 sf->thresh_mult[THR_ZEROA ] = 2000;
1021 sf->thresh_mult[THR_NEARA ] = 2000;
1022 sf->thresh_mult[THR_NEWA ] = 4000;
1028 // Disable split MB intra prediction mode
1029 sf->thresh_mult[THR_B_PRED] = INT_MAX;
1034 unsigned int i, sum = 0;
1035 unsigned int total_mbs = cm->MBs;
1041 if (cpi->oxcf.encode_breakout > 2000)
1042 min = cpi->oxcf.encode_breakout;
1046 for (i = 0; i < min; i++)
1048 sum += cpi->error_bins[i];
1054 // i starts from 2 to make sure thresh started from 2048
1055 for (; i < 1024; i++)
1057 sum += cpi->error_bins[i];
1059 if (10 * sum >= (unsigned int)(cpi->Speed - 6)*(total_mbs - total_skip))
1069 if (cpi->ref_frame_flags & VP8_LAST_FLAG)
1071 sf->thresh_mult[THR_NEWMV] = thresh;
1072 sf->thresh_mult[THR_NEARESTMV ] = thresh >> 1;
1073 sf->thresh_mult[THR_NEARMV ] = thresh >> 1;
1076 if (cpi->ref_frame_flags & VP8_GOLD_FLAG)
1078 sf->thresh_mult[THR_NEWG] = thresh << 1;
1079 sf->thresh_mult[THR_NEARESTG ] = thresh;
1080 sf->thresh_mult[THR_NEARG ] = thresh;
1083 if (cpi->ref_frame_flags & VP8_ALT_FLAG)
1085 sf->thresh_mult[THR_NEWA] = thresh << 1;
1086 sf->thresh_mult[THR_NEARESTA ] = thresh;
1087 sf->thresh_mult[THR_NEARA ] = thresh;
1090 // Disable other intra prediction modes
1091 sf->thresh_mult[THR_TM] = INT_MAX;
1092 sf->thresh_mult[THR_V_PRED] = INT_MAX;
1093 sf->thresh_mult[THR_H_PRED] = INT_MAX;
1095 sf->improved_mv_pred = 0;
1100 sf->quarter_pixel_search = 0;
1105 int Tmp = cpi->Speed - 8;
1110 if (cpi->ref_frame_flags & VP8_GOLD_FLAG)
1112 cpi->mode_check_freq[THR_ZEROG] = 1 << (Tmp - 1);
1113 cpi->mode_check_freq[THR_NEARESTG] = 1 << (Tmp - 1);
1114 cpi->mode_check_freq[THR_NEARG] = 1 << Tmp;
1115 cpi->mode_check_freq[THR_NEWG] = 1 << (Tmp + 1);
1118 if (cpi->ref_frame_flags & VP8_ALT_FLAG)
1120 cpi->mode_check_freq[THR_ZEROA] = 1 << (Tmp - 1);
1121 cpi->mode_check_freq[THR_NEARESTA] = 1 << (Tmp - 1);
1122 cpi->mode_check_freq[THR_NEARA] = 1 << Tmp;
1123 cpi->mode_check_freq[THR_NEWA] = 1 << (Tmp + 1);
1126 cpi->mode_check_freq[THR_NEWMV] = 1 << (Tmp - 1);
1129 cm->filter_type = NORMAL_LOOPFILTER;
1132 cm->filter_type = SIMPLE_LOOPFILTER;
1136 sf->half_pixel_search = 0; // This has a big hit on quality. Last resort
1139 vpx_memset(cpi->error_bins, 0, sizeof(cpi->error_bins));
1143 /* disable frame modes if flags not set */
1144 if (!(cpi->ref_frame_flags & VP8_LAST_FLAG))
1146 sf->thresh_mult[THR_NEWMV ] = INT_MAX;
1147 sf->thresh_mult[THR_NEARESTMV] = INT_MAX;
1148 sf->thresh_mult[THR_ZEROMV ] = INT_MAX;
1149 sf->thresh_mult[THR_NEARMV ] = INT_MAX;
1150 sf->thresh_mult[THR_SPLITMV ] = INT_MAX;
1153 if (!(cpi->ref_frame_flags & VP8_GOLD_FLAG))
1155 sf->thresh_mult[THR_NEARESTG ] = INT_MAX;
1156 sf->thresh_mult[THR_ZEROG ] = INT_MAX;
1157 sf->thresh_mult[THR_NEARG ] = INT_MAX;
1158 sf->thresh_mult[THR_NEWG ] = INT_MAX;
1159 sf->thresh_mult[THR_SPLITG ] = INT_MAX;
1162 if (!(cpi->ref_frame_flags & VP8_ALT_FLAG))
1164 sf->thresh_mult[THR_NEARESTA ] = INT_MAX;
1165 sf->thresh_mult[THR_ZEROA ] = INT_MAX;
1166 sf->thresh_mult[THR_NEARA ] = INT_MAX;
1167 sf->thresh_mult[THR_NEWA ] = INT_MAX;
1168 sf->thresh_mult[THR_SPLITA ] = INT_MAX;
1172 // Slow quant, dct and trellis not worthwhile for first pass
1173 // so make sure they are always turned off.
1174 if ( cpi->pass == 1 )
1176 sf->improved_quant = 0;
1177 sf->optimize_coefficients = 0;
1178 sf->improved_dct = 0;
1181 if (cpi->sf.search_method == NSTEP)
1183 vp8_init3smotion_compensation(&cpi->mb, cm->yv12_fb[cm->lst_fb_idx].y_stride);
1185 else if (cpi->sf.search_method == DIAMOND)
1187 vp8_init_dsmotion_compensation(&cpi->mb, cm->yv12_fb[cm->lst_fb_idx].y_stride);
1190 if (cpi->sf.improved_dct)
1192 cpi->mb.vp8_short_fdct8x4 = FDCT_INVOKE(&cpi->rtcd.fdct, short8x4);
1193 cpi->mb.vp8_short_fdct4x4 = FDCT_INVOKE(&cpi->rtcd.fdct, short4x4);
1197 cpi->mb.vp8_short_fdct8x4 = FDCT_INVOKE(&cpi->rtcd.fdct, fast8x4);
1198 cpi->mb.vp8_short_fdct4x4 = FDCT_INVOKE(&cpi->rtcd.fdct, fast4x4);
1201 cpi->mb.short_walsh4x4 = FDCT_INVOKE(&cpi->rtcd.fdct, walsh_short4x4);
1203 if (cpi->sf.improved_quant)
1205 cpi->mb.quantize_b = QUANTIZE_INVOKE(&cpi->rtcd.quantize, quantb);
1209 cpi->mb.quantize_b = QUANTIZE_INVOKE(&cpi->rtcd.quantize, fastquantb);
1211 if (cpi->sf.improved_quant != last_improved_quant)
1212 vp8cx_init_quantizer(cpi);
1214 #if CONFIG_RUNTIME_CPU_DETECT
1215 cpi->mb.e_mbd.rtcd = &cpi->common.rtcd;
1218 if (cpi->sf.iterative_sub_pixel == 1)
1220 cpi->find_fractional_mv_step = vp8_find_best_sub_pixel_step_iteratively;
1222 else if (cpi->sf.quarter_pixel_search)
1224 cpi->find_fractional_mv_step = vp8_find_best_sub_pixel_step;
1226 else if (cpi->sf.half_pixel_search)
1228 cpi->find_fractional_mv_step = vp8_find_best_half_pixel_step;
1232 cpi->find_fractional_mv_step = vp8_skip_fractional_mv_step;
1235 if (cpi->sf.optimize_coefficients == 1)
1236 cpi->mb.optimize = 1;
1238 cpi->mb.optimize = 0;
1240 if (cpi->common.full_pixel)
1241 cpi->find_fractional_mv_step = vp8_skip_fractional_mv_step;
1244 frames_at_speed[cpi->Speed]++;
1247 static void alloc_raw_frame_buffers(VP8_COMP *cpi)
1249 int width = (cpi->oxcf.Width + 15) & ~15;
1250 int height = (cpi->oxcf.Height + 15) & ~15;
1252 cpi->lookahead = vp8_lookahead_init(cpi->oxcf.Width, cpi->oxcf.Height,
1253 cpi->oxcf.lag_in_frames);
1255 vpx_internal_error(&cpi->common.error, VPX_CODEC_MEM_ERROR,
1256 "Failed to allocate lag buffers");
1258 #if VP8_TEMPORAL_ALT_REF
1260 if (vp8_yv12_alloc_frame_buffer(&cpi->alt_ref_buffer,
1262 vpx_internal_error(&cpi->common.error, VPX_CODEC_MEM_ERROR,
1263 "Failed to allocate altref buffer");
1268 static int vp8_alloc_partition_data(VP8_COMP *cpi)
1270 vpx_free(cpi->mb.pip);
1272 cpi->mb.pip = vpx_calloc((cpi->common.mb_cols + 1) *
1273 (cpi->common.mb_rows + 1),
1274 sizeof(PARTITION_INFO));
1278 cpi->mb.pi = cpi->mb.pip + cpi->common.mode_info_stride + 1;
1283 void vp8_alloc_compressor_data(VP8_COMP *cpi)
1285 VP8_COMMON *cm = & cpi->common;
1287 int width = cm->Width;
1288 int height = cm->Height;
1290 if (vp8_alloc_frame_buffers(cm, width, height))
1291 vpx_internal_error(&cpi->common.error, VPX_CODEC_MEM_ERROR,
1292 "Failed to allocate frame buffers");
1294 if (vp8_alloc_partition_data(cpi))
1295 vpx_internal_error(&cpi->common.error, VPX_CODEC_MEM_ERROR,
1296 "Failed to allocate partition data");
1299 if ((width & 0xf) != 0)
1300 width += 16 - (width & 0xf);
1302 if ((height & 0xf) != 0)
1303 height += 16 - (height & 0xf);
1306 if (vp8_yv12_alloc_frame_buffer(&cpi->last_frame_uf,
1307 width, height, VP8BORDERINPIXELS))
1308 vpx_internal_error(&cpi->common.error, VPX_CODEC_MEM_ERROR,
1309 "Failed to allocate last frame buffer");
1311 if (vp8_yv12_alloc_frame_buffer(&cpi->scaled_source, width, height, 16))
1312 vpx_internal_error(&cpi->common.error, VPX_CODEC_MEM_ERROR,
1313 "Failed to allocate scaled source buffer");
1319 unsigned int tokens = cm->mb_rows * cm->mb_cols * 24 * 16;
1321 CHECK_MEM_ERROR(cpi->tok, vpx_calloc(tokens, sizeof(*cpi->tok)));
1324 // Data used for real time vc mode to see if gf needs refreshing
1325 cpi->inter_zz_count = 0;
1326 cpi->gf_bad_count = 0;
1327 cpi->gf_update_recommended = 0;
1330 // Structures used to minitor GF usage
1331 vpx_free(cpi->gf_active_flags);
1332 CHECK_MEM_ERROR(cpi->gf_active_flags,
1333 vpx_calloc(1, cm->mb_rows * cm->mb_cols));
1334 cpi->gf_active_count = cm->mb_rows * cm->mb_cols;
1336 vpx_free(cpi->mb_activity_map);
1337 CHECK_MEM_ERROR(cpi->mb_activity_map,
1338 vpx_calloc(sizeof(unsigned int),
1339 cm->mb_rows * cm->mb_cols));
1341 vpx_free(cpi->mb_norm_activity_map);
1342 CHECK_MEM_ERROR(cpi->mb_norm_activity_map,
1343 vpx_calloc(sizeof(unsigned int),
1344 cm->mb_rows * cm->mb_cols));
1346 #if !(CONFIG_REALTIME_ONLY)
1347 vpx_free(cpi->twopass.total_stats);
1349 cpi->twopass.total_stats = vpx_calloc(1, sizeof(FIRSTPASS_STATS));
1351 vpx_free(cpi->twopass.this_frame_stats);
1353 cpi->twopass.this_frame_stats = vpx_calloc(1, sizeof(FIRSTPASS_STATS));
1355 if(!cpi->twopass.total_stats || !cpi->twopass.this_frame_stats)
1356 vpx_internal_error(&cpi->common.error, VPX_CODEC_MEM_ERROR,
1357 "Failed to allocate firstpass stats");
1360 #if CONFIG_MULTITHREAD
1362 cpi->mt_sync_range = 1;
1363 else if (width <= 1280)
1364 cpi->mt_sync_range = 4;
1365 else if (width <= 2560)
1366 cpi->mt_sync_range = 8;
1368 cpi->mt_sync_range = 16;
1371 vpx_free(cpi->tplist);
1373 CHECK_MEM_ERROR(cpi->tplist, vpx_malloc(sizeof(TOKENLIST) * cpi->common.mb_rows));
1378 static const int q_trans[] =
1380 0, 1, 2, 3, 4, 5, 7, 8,
1381 9, 10, 12, 13, 15, 17, 18, 19,
1382 20, 21, 23, 24, 25, 26, 27, 28,
1383 29, 30, 31, 33, 35, 37, 39, 41,
1384 43, 45, 47, 49, 51, 53, 55, 57,
1385 59, 61, 64, 67, 70, 73, 76, 79,
1386 82, 85, 88, 91, 94, 97, 100, 103,
1387 106, 109, 112, 115, 118, 121, 124, 127,
1390 int vp8_reverse_trans(int x)
1394 for (i = 0; i < 64; i++)
1395 if (q_trans[i] >= x)
1400 void vp8_new_frame_rate(VP8_COMP *cpi, double framerate)
1405 cpi->oxcf.frame_rate = framerate;
1406 cpi->output_frame_rate = cpi->oxcf.frame_rate;
1407 cpi->per_frame_bandwidth = (int)(cpi->oxcf.target_bandwidth / cpi->output_frame_rate);
1408 cpi->av_per_frame_bandwidth = (int)(cpi->oxcf.target_bandwidth / cpi->output_frame_rate);
1409 cpi->min_frame_bandwidth = (int)(cpi->av_per_frame_bandwidth * cpi->oxcf.two_pass_vbrmin_section / 100);
1411 // Set Maximum gf/arf interval
1412 cpi->max_gf_interval = ((int)(cpi->output_frame_rate / 2.0) + 2);
1414 if(cpi->max_gf_interval < 12)
1415 cpi->max_gf_interval = 12;
1417 // Extended interval for genuinely static scenes
1418 cpi->twopass.static_scene_max_gf_interval = cpi->key_frame_frequency >> 1;
1420 // Special conditions when altr ref frame enabled in lagged compress mode
1421 if (cpi->oxcf.play_alternate && cpi->oxcf.lag_in_frames)
1423 if (cpi->max_gf_interval > cpi->oxcf.lag_in_frames - 1)
1424 cpi->max_gf_interval = cpi->oxcf.lag_in_frames - 1;
1426 if (cpi->twopass.static_scene_max_gf_interval > cpi->oxcf.lag_in_frames - 1)
1427 cpi->twopass.static_scene_max_gf_interval = cpi->oxcf.lag_in_frames - 1;
1430 if ( cpi->max_gf_interval > cpi->twopass.static_scene_max_gf_interval )
1431 cpi->max_gf_interval = cpi->twopass.static_scene_max_gf_interval;
1436 rescale(int val, int num, int denom)
1438 int64_t llnum = num;
1439 int64_t llden = denom;
1440 int64_t llval = val;
1442 return llval * llnum / llden;
1446 static void init_config(VP8_PTR ptr, VP8_CONFIG *oxcf)
1448 VP8_COMP *cpi = (VP8_COMP *)(ptr);
1449 VP8_COMMON *cm = &cpi->common;
1454 cpi->auto_adjust_gold_quantizer = 1;
1457 cm->version = oxcf->Version;
1458 vp8_setup_version(cm);
1460 // change includes all joint functionality
1461 vp8_change_config(ptr, oxcf);
1463 // Initialize active best and worst q and average q values.
1464 cpi->active_worst_quality = cpi->oxcf.worst_allowed_q;
1465 cpi->active_best_quality = cpi->oxcf.best_allowed_q;
1466 cpi->avg_frame_qindex = cpi->oxcf.worst_allowed_q;
1468 // Initialise the starting buffer levels
1469 cpi->buffer_level = cpi->oxcf.starting_buffer_level;
1470 cpi->bits_off_target = cpi->oxcf.starting_buffer_level;
1472 cpi->rolling_target_bits = cpi->av_per_frame_bandwidth;
1473 cpi->rolling_actual_bits = cpi->av_per_frame_bandwidth;
1474 cpi->long_rolling_target_bits = cpi->av_per_frame_bandwidth;
1475 cpi->long_rolling_actual_bits = cpi->av_per_frame_bandwidth;
1477 cpi->total_actual_bits = 0;
1478 cpi->total_target_vs_actual = 0;
1480 #if VP8_TEMPORAL_ALT_REF
1484 cpi->fixed_divide[0] = 0;
1486 for (i = 1; i < 512; i++)
1487 cpi->fixed_divide[i] = 0x80000 / i;
1493 void vp8_change_config(VP8_PTR ptr, VP8_CONFIG *oxcf)
1495 VP8_COMP *cpi = (VP8_COMP *)(ptr);
1496 VP8_COMMON *cm = &cpi->common;
1504 if (cm->version != oxcf->Version)
1506 cm->version = oxcf->Version;
1507 vp8_setup_version(cm);
1512 switch (cpi->oxcf.Mode)
1517 cpi->compressor_speed = 2;
1519 if (cpi->oxcf.cpu_used < -16)
1521 cpi->oxcf.cpu_used = -16;
1524 if (cpi->oxcf.cpu_used > 16)
1525 cpi->oxcf.cpu_used = 16;
1529 case MODE_GOODQUALITY:
1531 cpi->compressor_speed = 1;
1533 if (cpi->oxcf.cpu_used < -5)
1535 cpi->oxcf.cpu_used = -5;
1538 if (cpi->oxcf.cpu_used > 5)
1539 cpi->oxcf.cpu_used = 5;
1543 case MODE_BESTQUALITY:
1545 cpi->compressor_speed = 0;
1548 case MODE_FIRSTPASS:
1550 cpi->compressor_speed = 1;
1552 case MODE_SECONDPASS:
1554 cpi->compressor_speed = 1;
1556 if (cpi->oxcf.cpu_used < -5)
1558 cpi->oxcf.cpu_used = -5;
1561 if (cpi->oxcf.cpu_used > 5)
1562 cpi->oxcf.cpu_used = 5;
1565 case MODE_SECONDPASS_BEST:
1567 cpi->compressor_speed = 0;
1572 cpi->auto_worst_q = 1;
1574 cpi->oxcf.worst_allowed_q = q_trans[oxcf->worst_allowed_q];
1575 cpi->oxcf.best_allowed_q = q_trans[oxcf->best_allowed_q];
1576 cpi->oxcf.cq_level = q_trans[cpi->oxcf.cq_level];
1578 if (oxcf->fixed_q >= 0)
1580 if (oxcf->worst_allowed_q < 0)
1581 cpi->oxcf.fixed_q = q_trans[0];
1583 cpi->oxcf.fixed_q = q_trans[oxcf->worst_allowed_q];
1585 if (oxcf->alt_q < 0)
1586 cpi->oxcf.alt_q = q_trans[0];
1588 cpi->oxcf.alt_q = q_trans[oxcf->alt_q];
1590 if (oxcf->key_q < 0)
1591 cpi->oxcf.key_q = q_trans[0];
1593 cpi->oxcf.key_q = q_trans[oxcf->key_q];
1595 if (oxcf->gold_q < 0)
1596 cpi->oxcf.gold_q = q_trans[0];
1598 cpi->oxcf.gold_q = q_trans[oxcf->gold_q];
1602 cpi->baseline_gf_interval =
1603 cpi->oxcf.alt_freq ? cpi->oxcf.alt_freq : DEFAULT_GF_INTERVAL;
1605 cpi->ref_frame_flags = VP8_ALT_FLAG | VP8_GOLD_FLAG | VP8_LAST_FLAG;
1607 //cpi->use_golden_frame_only = 0;
1608 //cpi->use_last_frame_only = 0;
1609 cm->refresh_golden_frame = 0;
1610 cm->refresh_last_frame = 1;
1611 cm->refresh_entropy_probs = 1;
1613 if (cpi->oxcf.token_partitions >= 0 && cpi->oxcf.token_partitions <= 3)
1614 cm->multi_token_partition =
1615 (TOKEN_PARTITION) cpi->oxcf.token_partitions;
1617 setup_features(cpi);
1622 for (i = 0; i < MAX_MB_SEGMENTS; i++)
1623 cpi->segment_encode_breakout[i] = cpi->oxcf.encode_breakout;
1626 // At the moment the first order values may not be > MAXQ
1627 if (cpi->oxcf.fixed_q > MAXQ)
1628 cpi->oxcf.fixed_q = MAXQ;
1630 // local file playback mode == really big buffer
1631 if (cpi->oxcf.end_usage == USAGE_LOCAL_FILE_PLAYBACK)
1633 cpi->oxcf.starting_buffer_level = 60000;
1634 cpi->oxcf.optimal_buffer_level = 60000;
1635 cpi->oxcf.maximum_buffer_size = 240000;
1638 // Convert target bandwidth from Kbit/s to Bit/s
1639 cpi->oxcf.target_bandwidth *= 1000;
1641 cpi->oxcf.starting_buffer_level =
1642 rescale(cpi->oxcf.starting_buffer_level,
1643 cpi->oxcf.target_bandwidth, 1000);
1645 // Set or reset optimal and maximum buffer levels.
1646 if (cpi->oxcf.optimal_buffer_level == 0)
1647 cpi->oxcf.optimal_buffer_level = cpi->oxcf.target_bandwidth / 8;
1649 cpi->oxcf.optimal_buffer_level =
1650 rescale(cpi->oxcf.optimal_buffer_level,
1651 cpi->oxcf.target_bandwidth, 1000);
1653 if (cpi->oxcf.maximum_buffer_size == 0)
1654 cpi->oxcf.maximum_buffer_size = cpi->oxcf.target_bandwidth / 8;
1656 cpi->oxcf.maximum_buffer_size =
1657 rescale(cpi->oxcf.maximum_buffer_size,
1658 cpi->oxcf.target_bandwidth, 1000);
1660 // Set up frame rate and related parameters rate control values.
1661 vp8_new_frame_rate(cpi, cpi->oxcf.frame_rate);
1663 // Set absolute upper and lower quality limits
1664 cpi->worst_quality = cpi->oxcf.worst_allowed_q;
1665 cpi->best_quality = cpi->oxcf.best_allowed_q;
1667 // active values should only be modified if out of new range
1668 if (cpi->active_worst_quality > cpi->oxcf.worst_allowed_q)
1670 cpi->active_worst_quality = cpi->oxcf.worst_allowed_q;
1673 else if (cpi->active_worst_quality < cpi->oxcf.best_allowed_q)
1675 cpi->active_worst_quality = cpi->oxcf.best_allowed_q;
1677 if (cpi->active_best_quality < cpi->oxcf.best_allowed_q)
1679 cpi->active_best_quality = cpi->oxcf.best_allowed_q;
1682 else if (cpi->active_best_quality > cpi->oxcf.worst_allowed_q)
1684 cpi->active_best_quality = cpi->oxcf.worst_allowed_q;
1687 cpi->buffered_mode = (cpi->oxcf.optimal_buffer_level > 0) ? TRUE : FALSE;
1689 cpi->cq_target_quality = cpi->oxcf.cq_level;
1691 // Only allow dropped frames in buffered mode
1692 cpi->drop_frames_allowed = cpi->oxcf.allow_df && cpi->buffered_mode;
1694 if (!cm->use_bilinear_mc_filter)
1695 cm->mcomp_filter_type = SIXTAP;
1697 cm->mcomp_filter_type = BILINEAR;
1699 cpi->target_bandwidth = cpi->oxcf.target_bandwidth;
1701 cm->Width = cpi->oxcf.Width ;
1702 cm->Height = cpi->oxcf.Height ;
1704 cm->horiz_scale = cpi->horiz_scale;
1705 cm->vert_scale = cpi->vert_scale ;
1707 // VP8 sharpness level mapping 0-7 (vs 0-10 in general VPx dialogs)
1708 if (cpi->oxcf.Sharpness > 7)
1709 cpi->oxcf.Sharpness = 7;
1711 cm->sharpness_level = cpi->oxcf.Sharpness;
1713 if (cm->horiz_scale != NORMAL || cm->vert_scale != NORMAL)
1715 int UNINITIALIZED_IS_SAFE(hr), UNINITIALIZED_IS_SAFE(hs);
1716 int UNINITIALIZED_IS_SAFE(vr), UNINITIALIZED_IS_SAFE(vs);
1718 Scale2Ratio(cm->horiz_scale, &hr, &hs);
1719 Scale2Ratio(cm->vert_scale, &vr, &vs);
1721 // always go to the next whole number
1722 cm->Width = (hs - 1 + cpi->oxcf.Width * hr) / hs;
1723 cm->Height = (vs - 1 + cpi->oxcf.Height * vr) / vs;
1726 if (((cm->Width + 15) & 0xfffffff0) !=
1727 cm->yv12_fb[cm->lst_fb_idx].y_width ||
1728 ((cm->Height + 15) & 0xfffffff0) !=
1729 cm->yv12_fb[cm->lst_fb_idx].y_height ||
1730 cm->yv12_fb[cm->lst_fb_idx].y_width == 0)
1732 alloc_raw_frame_buffers(cpi);
1733 vp8_alloc_compressor_data(cpi);
1736 if (cpi->oxcf.fixed_q >= 0)
1738 cpi->last_q[0] = cpi->oxcf.fixed_q;
1739 cpi->last_q[1] = cpi->oxcf.fixed_q;
1742 cpi->Speed = cpi->oxcf.cpu_used;
1744 // force to allowlag to 0 if lag_in_frames is 0;
1745 if (cpi->oxcf.lag_in_frames == 0)
1747 cpi->oxcf.allow_lag = 0;
1749 // Limit on lag buffers as these are not currently dynamically allocated
1750 else if (cpi->oxcf.lag_in_frames > MAX_LAG_BUFFERS)
1751 cpi->oxcf.lag_in_frames = MAX_LAG_BUFFERS;
1754 cpi->alt_ref_source = NULL;
1755 cpi->is_src_frame_alt_ref = 0;
1759 // Experimental RD Code
1760 cpi->frame_distortion = 0;
1761 cpi->last_frame_distortion = 0;
1766 #define M_LOG2_E 0.693147180559945309417
1767 #define log2f(x) (log (x) / (float) M_LOG2_E)
1768 static void cal_mvsadcosts(int *mvsadcost[2])
1772 mvsadcost [0] [0] = 300;
1773 mvsadcost [1] [0] = 300;
1777 double z = 256 * (2 * (log2f(8 * i) + .6));
1778 mvsadcost [0][i] = (int) z;
1779 mvsadcost [1][i] = (int) z;
1780 mvsadcost [0][-i] = (int) z;
1781 mvsadcost [1][-i] = (int) z;
1783 while (++i <= mvfp_max);
1786 VP8_PTR vp8_create_compressor(VP8_CONFIG *oxcf)
1798 cpi = ctx.cpi = vpx_memalign(32, sizeof(VP8_COMP));
1799 // Check that the CPI instance is valid
1805 vpx_memset(cpi, 0, sizeof(VP8_COMP));
1807 if (setjmp(cm->error.jmp))
1809 VP8_PTR ptr = ctx.ptr;
1811 ctx.cpi->common.error.setjmp = 0;
1812 vp8_remove_compressor(&ptr);
1816 cpi->common.error.setjmp = 1;
1818 CHECK_MEM_ERROR(cpi->mb.ss, vpx_calloc(sizeof(search_site), (MAX_MVSEARCH_STEPS * 8) + 1));
1820 vp8_create_common(&cpi->common);
1821 vp8_cmachine_specific_config(cpi);
1823 init_config((VP8_PTR)cpi, oxcf);
1825 memcpy(cpi->base_skip_false_prob, vp8cx_base_skip_false_prob, sizeof(vp8cx_base_skip_false_prob));
1826 cpi->common.current_video_frame = 0;
1827 cpi->kf_overspend_bits = 0;
1828 cpi->kf_bitrate_adjustment = 0;
1829 cpi->frames_till_gf_update_due = 0;
1830 cpi->gf_overspend_bits = 0;
1831 cpi->non_gf_bitrate_adjustment = 0;
1832 cpi->prob_last_coded = 128;
1833 cpi->prob_gf_coded = 128;
1834 cpi->prob_intra_coded = 63;
1836 // Prime the recent reference frame useage counters.
1837 // Hereafter they will be maintained as a sort of moving average
1838 cpi->recent_ref_frame_usage[INTRA_FRAME] = 1;
1839 cpi->recent_ref_frame_usage[LAST_FRAME] = 1;
1840 cpi->recent_ref_frame_usage[GOLDEN_FRAME] = 1;
1841 cpi->recent_ref_frame_usage[ALTREF_FRAME] = 1;
1843 // Set reference frame sign bias for ALTREF frame to 1 (for now)
1844 cpi->common.ref_frame_sign_bias[ALTREF_FRAME] = 1;
1846 cpi->twopass.gf_decay_rate = 0;
1847 cpi->baseline_gf_interval = DEFAULT_GF_INTERVAL;
1849 cpi->gold_is_last = 0 ;
1850 cpi->alt_is_last = 0 ;
1851 cpi->gold_is_alt = 0 ;
1853 // allocate memory for storing last frame's MVs for MV prediction.
1854 CHECK_MEM_ERROR(cpi->lfmv, vpx_calloc((cpi->common.mb_rows+2) * (cpi->common.mb_cols+2), sizeof(int_mv)));
1855 CHECK_MEM_ERROR(cpi->lf_ref_frame_sign_bias, vpx_calloc((cpi->common.mb_rows+2) * (cpi->common.mb_cols+2), sizeof(int)));
1856 CHECK_MEM_ERROR(cpi->lf_ref_frame, vpx_calloc((cpi->common.mb_rows+2) * (cpi->common.mb_cols+2), sizeof(int)));
1858 // Create the encoder segmentation map and set all entries to 0
1859 CHECK_MEM_ERROR(cpi->segmentation_map, vpx_calloc(cpi->common.mb_rows * cpi->common.mb_cols, 1));
1860 CHECK_MEM_ERROR(cpi->active_map, vpx_calloc(cpi->common.mb_rows * cpi->common.mb_cols, 1));
1861 vpx_memset(cpi->active_map , 1, (cpi->common.mb_rows * cpi->common.mb_cols));
1862 cpi->active_map_enabled = 0;
1865 // Experimental code for lagged and one pass
1866 // Initialise one_pass GF frames stats
1867 // Update stats used for GF selection
1870 cpi->one_pass_frame_index = 0;
1872 for (i = 0; i < MAX_LAG_BUFFERS; i++)
1874 cpi->one_pass_frame_stats[i].frames_so_far = 0;
1875 cpi->one_pass_frame_stats[i].frame_intra_error = 0.0;
1876 cpi->one_pass_frame_stats[i].frame_coded_error = 0.0;
1877 cpi->one_pass_frame_stats[i].frame_pcnt_inter = 0.0;
1878 cpi->one_pass_frame_stats[i].frame_pcnt_motion = 0.0;
1879 cpi->one_pass_frame_stats[i].frame_mvr = 0.0;
1880 cpi->one_pass_frame_stats[i].frame_mvr_abs = 0.0;
1881 cpi->one_pass_frame_stats[i].frame_mvc = 0.0;
1882 cpi->one_pass_frame_stats[i].frame_mvc_abs = 0.0;
1887 // Should we use the cyclic refresh method.
1888 // Currently this is tied to error resilliant mode
1889 cpi->cyclic_refresh_mode_enabled = cpi->oxcf.error_resilient_mode;
1890 cpi->cyclic_refresh_mode_max_mbs_perframe = (cpi->common.mb_rows * cpi->common.mb_cols) / 40;
1891 cpi->cyclic_refresh_mode_index = 0;
1892 cpi->cyclic_refresh_q = 32;
1894 if (cpi->cyclic_refresh_mode_enabled)
1896 CHECK_MEM_ERROR(cpi->cyclic_refresh_map, vpx_calloc((cpi->common.mb_rows * cpi->common.mb_cols), 1));
1899 cpi->cyclic_refresh_map = (signed char *) NULL;
1901 // Test function for segmentation
1902 //segmentation_test_function((VP8_PTR) cpi);
1904 #ifdef ENTROPY_STATS
1905 init_context_counters();
1908 /*Initialize the feed-forward activity masking.*/
1909 cpi->activity_avg = 90<<12;
1911 cpi->frames_since_key = 8; // Give a sensible default for the first frame.
1912 cpi->key_frame_frequency = cpi->oxcf.key_freq;
1913 cpi->this_key_frame_forced = FALSE;
1914 cpi->next_key_frame_forced = FALSE;
1916 cpi->source_alt_ref_pending = FALSE;
1917 cpi->source_alt_ref_active = FALSE;
1918 cpi->common.refresh_alt_ref_frame = 0;
1920 cpi->b_calculate_psnr = CONFIG_INTERNAL_STATS;
1921 #if CONFIG_INTERNAL_STATS
1922 cpi->b_calculate_ssimg = 0;
1927 if (cpi->b_calculate_psnr)
1929 cpi->total_sq_error = 0.0;
1930 cpi->total_sq_error2 = 0.0;
1935 cpi->totalp_y = 0.0;
1936 cpi->totalp_u = 0.0;
1937 cpi->totalp_v = 0.0;
1939 cpi->tot_recode_hits = 0;
1940 cpi->summed_quality = 0;
1941 cpi->summed_weights = 0;
1944 if (cpi->b_calculate_ssimg)
1946 cpi->total_ssimg_y = 0;
1947 cpi->total_ssimg_u = 0;
1948 cpi->total_ssimg_v = 0;
1949 cpi->total_ssimg_all = 0;
1953 #define LLONG_MAX 9223372036854775807LL
1955 cpi->first_time_stamp_ever = LLONG_MAX;
1959 cpi->frames_till_gf_update_due = 0;
1960 cpi->key_frame_count = 1;
1962 cpi->ni_av_qi = cpi->oxcf.worst_allowed_q;
1965 cpi->total_byte_count = 0;
1967 cpi->drop_frame = 0;
1968 cpi->drop_count = 0;
1969 cpi->max_drop_count = 0;
1970 cpi->max_consec_dropped_frames = 4;
1972 cpi->rate_correction_factor = 1.0;
1973 cpi->key_frame_rate_correction_factor = 1.0;
1974 cpi->gf_rate_correction_factor = 1.0;
1975 cpi->twopass.est_max_qcorrection_factor = 1.0;
1977 cpi->mb.mvcost[0] = &cpi->mb.mvcosts[0][mv_max+1];
1978 cpi->mb.mvcost[1] = &cpi->mb.mvcosts[1][mv_max+1];
1979 cpi->mb.mvsadcost[0] = &cpi->mb.mvsadcosts[0][mvfp_max+1];
1980 cpi->mb.mvsadcost[1] = &cpi->mb.mvsadcosts[1][mvfp_max+1];
1982 cal_mvsadcosts(cpi->mb.mvsadcost);
1984 for (i = 0; i < KEY_FRAME_CONTEXT; i++)
1986 cpi->prior_key_frame_distance[i] = (int)cpi->output_frame_rate;
1989 #ifdef OUTPUT_YUV_SRC
1990 yuv_file = fopen("bd.yuv", "ab");
1994 framepsnr = fopen("framepsnr.stt", "a");
1995 kf_list = fopen("kf_list.stt", "w");
1998 cpi->output_pkt_list = oxcf->output_pkt_list;
2000 #if !(CONFIG_REALTIME_ONLY)
2004 vp8_init_first_pass(cpi);
2006 else if (cpi->pass == 2)
2008 size_t packet_sz = sizeof(FIRSTPASS_STATS);
2009 int packets = oxcf->two_pass_stats_in.sz / packet_sz;
2011 cpi->twopass.stats_in = oxcf->two_pass_stats_in.buf;
2012 cpi->twopass.stats_in_end = (void*)((char *)cpi->twopass.stats_in
2013 + (packets - 1) * packet_sz);
2014 vp8_init_second_pass(cpi);
2019 if (cpi->compressor_speed == 2)
2021 cpi->cpu_freq = 0; //vp8_get_processor_freq();
2022 cpi->avg_encode_time = 0;
2023 cpi->avg_pick_mode_time = 0;
2026 vp8_set_speed_features(cpi);
2028 // Set starting values of RD threshold multipliers (128 = *1)
2029 for (i = 0; i < MAX_MODES; i++)
2031 cpi->rd_thresh_mult[i] = 128;
2034 #ifdef ENTROPY_STATS
2035 init_mv_ref_counts();
2038 #if CONFIG_MULTITHREAD
2039 vp8cx_create_encoder_threads(cpi);
2042 cpi->fn_ptr[BLOCK_16X16].sdf = VARIANCE_INVOKE(&cpi->rtcd.variance, sad16x16);
2043 cpi->fn_ptr[BLOCK_16X16].vf = VARIANCE_INVOKE(&cpi->rtcd.variance, var16x16);
2044 cpi->fn_ptr[BLOCK_16X16].svf = VARIANCE_INVOKE(&cpi->rtcd.variance, subpixvar16x16);
2045 cpi->fn_ptr[BLOCK_16X16].svf_halfpix_h = VARIANCE_INVOKE(&cpi->rtcd.variance, halfpixvar16x16_h);
2046 cpi->fn_ptr[BLOCK_16X16].svf_halfpix_v = VARIANCE_INVOKE(&cpi->rtcd.variance, halfpixvar16x16_v);
2047 cpi->fn_ptr[BLOCK_16X16].svf_halfpix_hv = VARIANCE_INVOKE(&cpi->rtcd.variance, halfpixvar16x16_hv);
2048 cpi->fn_ptr[BLOCK_16X16].sdx3f = VARIANCE_INVOKE(&cpi->rtcd.variance, sad16x16x3);
2049 cpi->fn_ptr[BLOCK_16X16].sdx8f = VARIANCE_INVOKE(&cpi->rtcd.variance, sad16x16x8);
2050 cpi->fn_ptr[BLOCK_16X16].sdx4df = VARIANCE_INVOKE(&cpi->rtcd.variance, sad16x16x4d);
2052 cpi->fn_ptr[BLOCK_16X8].sdf = VARIANCE_INVOKE(&cpi->rtcd.variance, sad16x8);
2053 cpi->fn_ptr[BLOCK_16X8].vf = VARIANCE_INVOKE(&cpi->rtcd.variance, var16x8);
2054 cpi->fn_ptr[BLOCK_16X8].svf = VARIANCE_INVOKE(&cpi->rtcd.variance, subpixvar16x8);
2055 cpi->fn_ptr[BLOCK_16X8].svf_halfpix_h = NULL;
2056 cpi->fn_ptr[BLOCK_16X8].svf_halfpix_v = NULL;
2057 cpi->fn_ptr[BLOCK_16X8].svf_halfpix_hv = NULL;
2058 cpi->fn_ptr[BLOCK_16X8].sdx3f = VARIANCE_INVOKE(&cpi->rtcd.variance, sad16x8x3);
2059 cpi->fn_ptr[BLOCK_16X8].sdx8f = VARIANCE_INVOKE(&cpi->rtcd.variance, sad16x8x8);
2060 cpi->fn_ptr[BLOCK_16X8].sdx4df = VARIANCE_INVOKE(&cpi->rtcd.variance, sad16x8x4d);
2062 cpi->fn_ptr[BLOCK_8X16].sdf = VARIANCE_INVOKE(&cpi->rtcd.variance, sad8x16);
2063 cpi->fn_ptr[BLOCK_8X16].vf = VARIANCE_INVOKE(&cpi->rtcd.variance, var8x16);
2064 cpi->fn_ptr[BLOCK_8X16].svf = VARIANCE_INVOKE(&cpi->rtcd.variance, subpixvar8x16);
2065 cpi->fn_ptr[BLOCK_8X16].svf_halfpix_h = NULL;
2066 cpi->fn_ptr[BLOCK_8X16].svf_halfpix_v = NULL;
2067 cpi->fn_ptr[BLOCK_8X16].svf_halfpix_hv = NULL;
2068 cpi->fn_ptr[BLOCK_8X16].sdx3f = VARIANCE_INVOKE(&cpi->rtcd.variance, sad8x16x3);
2069 cpi->fn_ptr[BLOCK_8X16].sdx8f = VARIANCE_INVOKE(&cpi->rtcd.variance, sad8x16x8);
2070 cpi->fn_ptr[BLOCK_8X16].sdx4df = VARIANCE_INVOKE(&cpi->rtcd.variance, sad8x16x4d);
2072 cpi->fn_ptr[BLOCK_8X8].sdf = VARIANCE_INVOKE(&cpi->rtcd.variance, sad8x8);
2073 cpi->fn_ptr[BLOCK_8X8].vf = VARIANCE_INVOKE(&cpi->rtcd.variance, var8x8);
2074 cpi->fn_ptr[BLOCK_8X8].svf = VARIANCE_INVOKE(&cpi->rtcd.variance, subpixvar8x8);
2075 cpi->fn_ptr[BLOCK_8X8].svf_halfpix_h = NULL;
2076 cpi->fn_ptr[BLOCK_8X8].svf_halfpix_v = NULL;
2077 cpi->fn_ptr[BLOCK_8X8].svf_halfpix_hv = NULL;
2078 cpi->fn_ptr[BLOCK_8X8].sdx3f = VARIANCE_INVOKE(&cpi->rtcd.variance, sad8x8x3);
2079 cpi->fn_ptr[BLOCK_8X8].sdx8f = VARIANCE_INVOKE(&cpi->rtcd.variance, sad8x8x8);
2080 cpi->fn_ptr[BLOCK_8X8].sdx4df = VARIANCE_INVOKE(&cpi->rtcd.variance, sad8x8x4d);
2082 cpi->fn_ptr[BLOCK_4X4].sdf = VARIANCE_INVOKE(&cpi->rtcd.variance, sad4x4);
2083 cpi->fn_ptr[BLOCK_4X4].vf = VARIANCE_INVOKE(&cpi->rtcd.variance, var4x4);
2084 cpi->fn_ptr[BLOCK_4X4].svf = VARIANCE_INVOKE(&cpi->rtcd.variance, subpixvar4x4);
2085 cpi->fn_ptr[BLOCK_4X4].svf_halfpix_h = NULL;
2086 cpi->fn_ptr[BLOCK_4X4].svf_halfpix_v = NULL;
2087 cpi->fn_ptr[BLOCK_4X4].svf_halfpix_hv = NULL;
2088 cpi->fn_ptr[BLOCK_4X4].sdx3f = VARIANCE_INVOKE(&cpi->rtcd.variance, sad4x4x3);
2089 cpi->fn_ptr[BLOCK_4X4].sdx8f = VARIANCE_INVOKE(&cpi->rtcd.variance, sad4x4x8);
2090 cpi->fn_ptr[BLOCK_4X4].sdx4df = VARIANCE_INVOKE(&cpi->rtcd.variance, sad4x4x4d);
2092 cpi->full_search_sad = SEARCH_INVOKE(&cpi->rtcd.search, full_search);
2093 cpi->diamond_search_sad = SEARCH_INVOKE(&cpi->rtcd.search, diamond_search);
2094 cpi->refining_search_sad = SEARCH_INVOKE(&cpi->rtcd.search, refining_search);
2096 // make sure frame 1 is okay
2097 cpi->error_bins[0] = cpi->common.MBs;
2099 //vp8cx_init_quantizer() is first called here. Add check in vp8cx_frame_init_quantizer() so that vp8cx_init_quantizer is only called later
2100 //when needed. This will avoid unnecessary calls of vp8cx_init_quantizer() for every frame.
2101 vp8cx_init_quantizer(cpi);
2103 vp8_init_loop_filter(cm);
2104 cm->last_frame_type = KEY_FRAME;
2105 cm->last_filter_type = cm->filter_type;
2106 cm->last_sharpness_level = cm->sharpness_level;
2108 cpi->common.error.setjmp = 0;
2109 return (VP8_PTR) cpi;
2114 void vp8_remove_compressor(VP8_PTR *ptr)
2116 VP8_COMP *cpi = (VP8_COMP *)(*ptr);
2121 if (cpi && (cpi->common.current_video_frame > 0))
2123 #if !(CONFIG_REALTIME_ONLY)
2127 vp8_end_second_pass(cpi);
2132 #ifdef ENTROPY_STATS
2133 print_context_counters();
2134 print_tree_update_probs();
2135 print_mode_context();
2138 #if CONFIG_INTERNAL_STATS
2142 FILE *f = fopen("opsnr.stt", "a");
2143 double time_encoded = (cpi->last_end_time_stamp_seen
2144 - cpi->first_time_stamp_ever) / 10000000.000;
2145 double total_encode_time = (cpi->time_receive_data + cpi->time_compress_data) / 1000.000;
2146 double dr = (double)cpi->bytes * (double) 8 / (double)1000 / time_encoded;
2148 if (cpi->b_calculate_psnr)
2150 YV12_BUFFER_CONFIG *lst_yv12 = &cpi->common.yv12_fb[cpi->common.lst_fb_idx];
2151 double samples = 3.0 / 2 * cpi->count * lst_yv12->y_width * lst_yv12->y_height;
2152 double total_psnr = vp8_mse2psnr(samples, 255.0, cpi->total_sq_error);
2153 double total_psnr2 = vp8_mse2psnr(samples, 255.0, cpi->total_sq_error2);
2154 double total_ssim = 100 * pow(cpi->summed_quality / cpi->summed_weights, 8.0);
2156 fprintf(f, "Bitrate\tAVGPsnr\tGLBPsnr\tAVPsnrP\tGLPsnrP\tVPXSSIM\t Time(us)\n");
2157 fprintf(f, "%7.3f\t%7.3f\t%7.3f\t%7.3f\t%7.3f\t%7.3f\t%8.0f\n",
2158 dr, cpi->total / cpi->count, total_psnr, cpi->totalp / cpi->count, total_psnr2, total_ssim,
2162 if (cpi->b_calculate_ssimg)
2164 fprintf(f, "BitRate\tSSIM_Y\tSSIM_U\tSSIM_V\tSSIM_A\t Time(us)\n");
2165 fprintf(f, "%7.3f\t%6.4f\t%6.4f\t%6.4f\t%6.4f\t%8.0f\n", dr,
2166 cpi->total_ssimg_y / cpi->count, cpi->total_ssimg_u / cpi->count,
2167 cpi->total_ssimg_v / cpi->count, cpi->total_ssimg_all / cpi->count, total_encode_time);
2172 f = fopen("qskip.stt", "a");
2173 fprintf(f, "minq:%d -maxq:%d skipture:skipfalse = %d:%d\n", cpi->oxcf.best_allowed_q, cpi->oxcf.worst_allowed_q, skiptruecount, skipfalsecount);
2184 if (cpi->compressor_speed == 2)
2187 FILE *f = fopen("cxspeed.stt", "a");
2188 cnt_pm /= cpi->common.MBs;
2190 for (i = 0; i < 16; i++)
2191 fprintf(f, "%5d", frames_at_speed[i]);
2194 //fprintf(f, "%10d PM %10d %10d %10d EF %10d %10d %10d\n", cpi->Speed, cpi->avg_pick_mode_time, (tot_pm/cnt_pm), cnt_pm, cpi->avg_encode_time, 0, 0);
2203 extern int count_mb_seg[4];
2204 FILE *f = fopen("modes.stt", "a");
2205 double dr = (double)cpi->oxcf.frame_rate * (double)bytes * (double)8 / (double)count / (double)1000 ;
2206 fprintf(f, "intra_mode in Intra Frames:\n");
2207 fprintf(f, "Y: %8d, %8d, %8d, %8d, %8d\n", y_modes[0], y_modes[1], y_modes[2], y_modes[3], y_modes[4]);
2208 fprintf(f, "UV:%8d, %8d, %8d, %8d\n", uv_modes[0], uv_modes[1], uv_modes[2], uv_modes[3]);
2213 for (i = 0; i < 10; i++)
2214 fprintf(f, "%8d, ", b_modes[i]);
2220 fprintf(f, "Modes in Inter Frames:\n");
2221 fprintf(f, "Y: %8d, %8d, %8d, %8d, %8d, %8d, %8d, %8d, %8d, %8d\n",
2222 inter_y_modes[0], inter_y_modes[1], inter_y_modes[2], inter_y_modes[3], inter_y_modes[4],
2223 inter_y_modes[5], inter_y_modes[6], inter_y_modes[7], inter_y_modes[8], inter_y_modes[9]);
2224 fprintf(f, "UV:%8d, %8d, %8d, %8d\n", inter_uv_modes[0], inter_uv_modes[1], inter_uv_modes[2], inter_uv_modes[3]);
2229 for (i = 0; i < 15; i++)
2230 fprintf(f, "%8d, ", inter_b_modes[i]);
2235 fprintf(f, "P:%8d, %8d, %8d, %8d\n", count_mb_seg[0], count_mb_seg[1], count_mb_seg[2], count_mb_seg[3]);
2236 fprintf(f, "PB:%8d, %8d, %8d, %8d\n", inter_b_modes[LEFT4X4], inter_b_modes[ABOVE4X4], inter_b_modes[ZERO4X4], inter_b_modes[NEW4X4]);
2244 #ifdef ENTROPY_STATS
2247 FILE *fmode = fopen("modecontext.c", "w");
2249 fprintf(fmode, "\n#include \"entropymode.h\"\n\n");
2250 fprintf(fmode, "const unsigned int vp8_kf_default_bmode_counts ");
2251 fprintf(fmode, "[VP8_BINTRAMODES] [VP8_BINTRAMODES] [VP8_BINTRAMODES] =\n{\n");
2253 for (i = 0; i < 10; i++)
2256 fprintf(fmode, " { //Above Mode : %d\n", i);
2258 for (j = 0; j < 10; j++)
2261 fprintf(fmode, " {");
2263 for (k = 0; k < 10; k++)
2265 if (!intra_mode_stats[i][j][k])
2266 fprintf(fmode, " %5d, ", 1);
2268 fprintf(fmode, " %5d, ", intra_mode_stats[i][j][k]);
2271 fprintf(fmode, "}, // left_mode %d\n", j);
2275 fprintf(fmode, " },\n");
2279 fprintf(fmode, "};\n");
2285 #if defined(SECTIONBITS_OUTPUT)
2290 FILE *f = fopen("tokenbits.stt", "a");
2292 for (i = 0; i < 28; i++)
2293 fprintf(f, "%8d", (int)(Sectionbits[i] / 256));
2303 printf("\n_pick_loop_filter_level:%d\n", cpi->time_pick_lpf / 1000);
2304 printf("\n_frames recive_data encod_mb_row compress_frame Total\n");
2305 printf("%6d %10ld %10ld %10ld %10ld\n", cpi->common.current_video_frame, cpi->time_receive_data / 1000, cpi->time_encode_mb_row / 1000, cpi->time_compress_data / 1000, (cpi->time_receive_data + cpi->time_compress_data) / 1000);
2311 #if CONFIG_MULTITHREAD
2312 vp8cx_remove_encoder_threads(cpi);
2315 dealloc_compressor_data(cpi);
2316 vpx_free(cpi->mb.ss);
2318 vpx_free(cpi->cyclic_refresh_map);
2320 vp8_remove_common(&cpi->common);
2324 #ifdef OUTPUT_YUV_SRC
2344 static uint64_t calc_plane_error(unsigned char *orig, int orig_stride,
2345 unsigned char *recon, int recon_stride,
2346 unsigned int cols, unsigned int rows,
2347 vp8_variance_rtcd_vtable_t *rtcd)
2349 unsigned int row, col;
2350 uint64_t total_sse = 0;
2353 for (row = 0; row + 16 <= rows; row += 16)
2355 for (col = 0; col + 16 <= cols; col += 16)
2359 VARIANCE_INVOKE(rtcd, mse16x16)(orig + col, orig_stride,
2360 recon + col, recon_stride,
2365 /* Handle odd-sized width */
2368 unsigned int border_row, border_col;
2369 unsigned char *border_orig = orig;
2370 unsigned char *border_recon = recon;
2372 for (border_row = 0; border_row < 16; border_row++)
2374 for (border_col = col; border_col < cols; border_col++)
2376 diff = border_orig[border_col] - border_recon[border_col];
2377 total_sse += diff * diff;
2380 border_orig += orig_stride;
2381 border_recon += recon_stride;
2385 orig += orig_stride * 16;
2386 recon += recon_stride * 16;
2389 /* Handle odd-sized height */
2390 for (; row < rows; row++)
2392 for (col = 0; col < cols; col++)
2394 diff = orig[col] - recon[col];
2395 total_sse += diff * diff;
2398 orig += orig_stride;
2399 recon += recon_stride;
2406 static void generate_psnr_packet(VP8_COMP *cpi)
2408 YV12_BUFFER_CONFIG *orig = cpi->Source;
2409 YV12_BUFFER_CONFIG *recon = cpi->common.frame_to_show;
2410 struct vpx_codec_cx_pkt pkt;
2413 unsigned int width = cpi->common.Width;
2414 unsigned int height = cpi->common.Height;
2416 pkt.kind = VPX_CODEC_PSNR_PKT;
2417 sse = calc_plane_error(orig->y_buffer, orig->y_stride,
2418 recon->y_buffer, recon->y_stride,
2420 IF_RTCD(&cpi->rtcd.variance));
2421 pkt.data.psnr.sse[0] = sse;
2422 pkt.data.psnr.sse[1] = sse;
2423 pkt.data.psnr.samples[0] = width * height;
2424 pkt.data.psnr.samples[1] = width * height;
2426 width = (width + 1) / 2;
2427 height = (height + 1) / 2;
2429 sse = calc_plane_error(orig->u_buffer, orig->uv_stride,
2430 recon->u_buffer, recon->uv_stride,
2432 IF_RTCD(&cpi->rtcd.variance));
2433 pkt.data.psnr.sse[0] += sse;
2434 pkt.data.psnr.sse[2] = sse;
2435 pkt.data.psnr.samples[0] += width * height;
2436 pkt.data.psnr.samples[2] = width * height;
2438 sse = calc_plane_error(orig->v_buffer, orig->uv_stride,
2439 recon->v_buffer, recon->uv_stride,
2441 IF_RTCD(&cpi->rtcd.variance));
2442 pkt.data.psnr.sse[0] += sse;
2443 pkt.data.psnr.sse[3] = sse;
2444 pkt.data.psnr.samples[0] += width * height;
2445 pkt.data.psnr.samples[3] = width * height;
2447 for (i = 0; i < 4; i++)
2448 pkt.data.psnr.psnr[i] = vp8_mse2psnr(pkt.data.psnr.samples[i], 255.0,
2449 pkt.data.psnr.sse[i]);
2451 vpx_codec_pkt_list_add(cpi->output_pkt_list, &pkt);
2455 int vp8_use_as_reference(VP8_PTR ptr, int ref_frame_flags)
2457 VP8_COMP *cpi = (VP8_COMP *)(ptr);
2459 if (ref_frame_flags > 7)
2462 cpi->ref_frame_flags = ref_frame_flags;
2465 int vp8_update_reference(VP8_PTR ptr, int ref_frame_flags)
2467 VP8_COMP *cpi = (VP8_COMP *)(ptr);
2469 if (ref_frame_flags > 7)
2472 cpi->common.refresh_golden_frame = 0;
2473 cpi->common.refresh_alt_ref_frame = 0;
2474 cpi->common.refresh_last_frame = 0;
2476 if (ref_frame_flags & VP8_LAST_FLAG)
2477 cpi->common.refresh_last_frame = 1;
2479 if (ref_frame_flags & VP8_GOLD_FLAG)
2480 cpi->common.refresh_golden_frame = 1;
2482 if (ref_frame_flags & VP8_ALT_FLAG)
2483 cpi->common.refresh_alt_ref_frame = 1;
2488 int vp8_get_reference(VP8_PTR ptr, VP8_REFFRAME ref_frame_flag, YV12_BUFFER_CONFIG *sd)
2490 VP8_COMP *cpi = (VP8_COMP *)(ptr);
2491 VP8_COMMON *cm = &cpi->common;
2494 if (ref_frame_flag == VP8_LAST_FLAG)
2495 ref_fb_idx = cm->lst_fb_idx;
2496 else if (ref_frame_flag == VP8_GOLD_FLAG)
2497 ref_fb_idx = cm->gld_fb_idx;
2498 else if (ref_frame_flag == VP8_ALT_FLAG)
2499 ref_fb_idx = cm->alt_fb_idx;
2503 vp8_yv12_copy_frame_ptr(&cm->yv12_fb[ref_fb_idx], sd);
2507 int vp8_set_reference(VP8_PTR ptr, VP8_REFFRAME ref_frame_flag, YV12_BUFFER_CONFIG *sd)
2509 VP8_COMP *cpi = (VP8_COMP *)(ptr);
2510 VP8_COMMON *cm = &cpi->common;
2514 if (ref_frame_flag == VP8_LAST_FLAG)
2515 ref_fb_idx = cm->lst_fb_idx;
2516 else if (ref_frame_flag == VP8_GOLD_FLAG)
2517 ref_fb_idx = cm->gld_fb_idx;
2518 else if (ref_frame_flag == VP8_ALT_FLAG)
2519 ref_fb_idx = cm->alt_fb_idx;
2523 vp8_yv12_copy_frame_ptr(sd, &cm->yv12_fb[ref_fb_idx]);
2527 int vp8_update_entropy(VP8_PTR comp, int update)
2529 VP8_COMP *cpi = (VP8_COMP *) comp;
2530 VP8_COMMON *cm = &cpi->common;
2531 cm->refresh_entropy_probs = update;
2538 void vp8_write_yuv_frame(const char *name, YV12_BUFFER_CONFIG *s)
2540 FILE *yuv_file = fopen(name, "ab");
2541 unsigned char *src = s->y_buffer;
2542 int h = s->y_height;
2546 fwrite(src, s->y_width, 1, yuv_file);
2556 fwrite(src, s->uv_width, 1, yuv_file);
2557 src += s->uv_stride;
2566 fwrite(src, s->uv_width, 1, yuv_file);
2567 src += s->uv_stride;
2576 static void scale_and_extend_source(YV12_BUFFER_CONFIG *sd, VP8_COMP *cpi)
2578 VP8_COMMON *cm = &cpi->common;
2580 // are we resizing the image
2581 if (cm->horiz_scale != 0 || cm->vert_scale != 0)
2583 #if CONFIG_SPATIAL_RESAMPLING
2584 int UNINITIALIZED_IS_SAFE(hr), UNINITIALIZED_IS_SAFE(hs);
2585 int UNINITIALIZED_IS_SAFE(vr), UNINITIALIZED_IS_SAFE(vs);
2588 if (cm->vert_scale == 3)
2593 Scale2Ratio(cm->horiz_scale, &hr, &hs);
2594 Scale2Ratio(cm->vert_scale, &vr, &vs);
2596 vp8_scale_frame(sd, &cpi->scaled_source, cm->temp_scale_frame.y_buffer,
2597 tmp_height, hs, hr, vs, vr, 0);
2599 vp8_yv12_extend_frame_borders(&cpi->scaled_source);
2600 cpi->Source = &cpi->scaled_source;
2606 static void resize_key_frame(VP8_COMP *cpi)
2608 #if CONFIG_SPATIAL_RESAMPLING
2609 VP8_COMMON *cm = &cpi->common;
2611 // Do we need to apply resampling for one pass cbr.
2612 // In one pass this is more limited than in two pass cbr
2613 // The test and any change is only made one per key frame sequence
2614 if (cpi->oxcf.allow_spatial_resampling && (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER))
2616 int UNINITIALIZED_IS_SAFE(hr), UNINITIALIZED_IS_SAFE(hs);
2617 int UNINITIALIZED_IS_SAFE(vr), UNINITIALIZED_IS_SAFE(vs);
2618 int new_width, new_height;
2620 // If we are below the resample DOWN watermark then scale down a notch.
2621 if (cpi->buffer_level < (cpi->oxcf.resample_down_water_mark * cpi->oxcf.optimal_buffer_level / 100))
2623 cm->horiz_scale = (cm->horiz_scale < ONETWO) ? cm->horiz_scale + 1 : ONETWO;
2624 cm->vert_scale = (cm->vert_scale < ONETWO) ? cm->vert_scale + 1 : ONETWO;
2626 // Should we now start scaling back up
2627 else if (cpi->buffer_level > (cpi->oxcf.resample_up_water_mark * cpi->oxcf.optimal_buffer_level / 100))
2629 cm->horiz_scale = (cm->horiz_scale > NORMAL) ? cm->horiz_scale - 1 : NORMAL;
2630 cm->vert_scale = (cm->vert_scale > NORMAL) ? cm->vert_scale - 1 : NORMAL;
2633 // Get the new hieght and width
2634 Scale2Ratio(cm->horiz_scale, &hr, &hs);
2635 Scale2Ratio(cm->vert_scale, &vr, &vs);
2636 new_width = ((hs - 1) + (cpi->oxcf.Width * hr)) / hs;
2637 new_height = ((vs - 1) + (cpi->oxcf.Height * vr)) / vs;
2639 // If the image size has changed we need to reallocate the buffers
2640 // and resample the source image
2641 if ((cm->Width != new_width) || (cm->Height != new_height))
2643 cm->Width = new_width;
2644 cm->Height = new_height;
2645 vp8_alloc_compressor_data(cpi);
2646 scale_and_extend_source(cpi->un_scaled_source, cpi);
2654 static void update_alt_ref_frame_and_stats(VP8_COMP *cpi)
2656 VP8_COMMON *cm = &cpi->common;
2658 // Update the golden frame buffer
2659 vp8_yv12_copy_frame_ptr(cm->frame_to_show, &cm->yv12_fb[cm->alt_fb_idx]);
2661 // Select an interval before next GF or altref
2662 if (!cpi->auto_gold)
2663 cpi->frames_till_gf_update_due = cpi->goldfreq;
2665 if ((cpi->pass != 2) && cpi->frames_till_gf_update_due)
2667 cpi->current_gf_interval = cpi->frames_till_gf_update_due;
2669 // Set the bits per frame that we should try and recover in subsequent inter frames
2670 // to account for the extra GF spend... note that his does not apply for GF updates
2671 // that occur coincident with a key frame as the extra cost of key frames is dealt
2674 cpi->gf_overspend_bits += cpi->projected_frame_size;
2675 cpi->non_gf_bitrate_adjustment = cpi->gf_overspend_bits / cpi->frames_till_gf_update_due;
2678 // Update data structure that monitors level of reference to last GF
2679 vpx_memset(cpi->gf_active_flags, 1, (cm->mb_rows * cm->mb_cols));
2680 cpi->gf_active_count = cm->mb_rows * cm->mb_cols;
2682 // this frame refreshes means next frames don't unless specified by user
2683 cpi->common.frames_since_golden = 0;
2685 // Clear the alternate reference update pending flag.
2686 cpi->source_alt_ref_pending = FALSE;
2688 // Set the alternate refernce frame active flag
2689 cpi->source_alt_ref_active = TRUE;
2693 static void update_golden_frame_and_stats(VP8_COMP *cpi)
2695 VP8_COMMON *cm = &cpi->common;
2697 // Update the Golden frame reconstruction buffer if signalled and the GF usage counts.
2698 if (cm->refresh_golden_frame)
2700 if (cm->frame_type != KEY_FRAME)
2702 // Update the golden frame buffer
2703 vp8_yv12_copy_frame_ptr(cm->frame_to_show, &cm->yv12_fb[cm->gld_fb_idx]);
2706 // Select an interval before next GF
2707 if (!cpi->auto_gold)
2708 cpi->frames_till_gf_update_due = cpi->goldfreq;
2710 if ((cpi->pass != 2) && (cpi->frames_till_gf_update_due > 0))
2712 cpi->current_gf_interval = cpi->frames_till_gf_update_due;
2714 // Set the bits per frame that we should try and recover in subsequent inter frames
2715 // to account for the extra GF spend... note that his does not apply for GF updates
2716 // that occur coincident with a key frame as the extra cost of key frames is dealt
2718 if ((cm->frame_type != KEY_FRAME) && !cpi->source_alt_ref_active)
2720 // Calcluate GF bits to be recovered
2721 // Projected size - av frame bits available for inter frames for clip as a whole
2722 cpi->gf_overspend_bits += (cpi->projected_frame_size - cpi->inter_frame_target);
2725 cpi->non_gf_bitrate_adjustment = cpi->gf_overspend_bits / cpi->frames_till_gf_update_due;
2729 // Update data structure that monitors level of reference to last GF
2730 vpx_memset(cpi->gf_active_flags, 1, (cm->mb_rows * cm->mb_cols));
2731 cpi->gf_active_count = cm->mb_rows * cm->mb_cols;
2733 // this frame refreshes means next frames don't unless specified by user
2734 cm->refresh_golden_frame = 0;
2735 cpi->common.frames_since_golden = 0;
2737 //if ( cm->frame_type == KEY_FRAME )
2739 cpi->recent_ref_frame_usage[INTRA_FRAME] = 1;
2740 cpi->recent_ref_frame_usage[LAST_FRAME] = 1;
2741 cpi->recent_ref_frame_usage[GOLDEN_FRAME] = 1;
2742 cpi->recent_ref_frame_usage[ALTREF_FRAME] = 1;
2746 // // Carry a potrtion of count over to begining of next gf sequence
2747 // cpi->recent_ref_frame_usage[INTRA_FRAME] >>= 5;
2748 // cpi->recent_ref_frame_usage[LAST_FRAME] >>= 5;
2749 // cpi->recent_ref_frame_usage[GOLDEN_FRAME] >>= 5;
2750 // cpi->recent_ref_frame_usage[ALTREF_FRAME] >>= 5;
2753 // ******** Fixed Q test code only ************
2754 // If we are going to use the ALT reference for the next group of frames set a flag to say so.
2755 if (cpi->oxcf.fixed_q >= 0 &&
2756 cpi->oxcf.play_alternate && !cpi->common.refresh_alt_ref_frame)
2758 cpi->source_alt_ref_pending = TRUE;
2759 cpi->frames_till_gf_update_due = cpi->baseline_gf_interval;
2762 if (!cpi->source_alt_ref_pending)
2763 cpi->source_alt_ref_active = FALSE;
2765 // Decrement count down till next gf
2766 if (cpi->frames_till_gf_update_due > 0)
2767 cpi->frames_till_gf_update_due--;
2770 else if (!cpi->common.refresh_alt_ref_frame)
2772 // Decrement count down till next gf
2773 if (cpi->frames_till_gf_update_due > 0)
2774 cpi->frames_till_gf_update_due--;
2776 if (cpi->common.frames_till_alt_ref_frame)
2777 cpi->common.frames_till_alt_ref_frame --;
2779 cpi->common.frames_since_golden ++;
2781 if (cpi->common.frames_since_golden > 1)
2783 cpi->recent_ref_frame_usage[INTRA_FRAME] += cpi->count_mb_ref_frame_usage[INTRA_FRAME];
2784 cpi->recent_ref_frame_usage[LAST_FRAME] += cpi->count_mb_ref_frame_usage[LAST_FRAME];
2785 cpi->recent_ref_frame_usage[GOLDEN_FRAME] += cpi->count_mb_ref_frame_usage[GOLDEN_FRAME];
2786 cpi->recent_ref_frame_usage[ALTREF_FRAME] += cpi->count_mb_ref_frame_usage[ALTREF_FRAME];
2791 // This function updates the reference frame probability estimates that
2792 // will be used during mode selection
2793 static void update_rd_ref_frame_probs(VP8_COMP *cpi)
2795 VP8_COMMON *cm = &cpi->common;
2798 const int *const rfct = cpi->recent_ref_frame_usage;
2799 const int rf_intra = rfct[INTRA_FRAME];
2800 const int rf_inter = rfct[LAST_FRAME] + rfct[GOLDEN_FRAME] + rfct[ALTREF_FRAME];
2802 if (cm->frame_type == KEY_FRAME)
2804 cpi->prob_intra_coded = 255;
2805 cpi->prob_last_coded = 128;
2806 cpi->prob_gf_coded = 128;
2808 else if (!(rf_intra + rf_inter))
2810 // This is a trap in case this function is called with cpi->recent_ref_frame_usage[] blank.
2811 cpi->prob_intra_coded = 63;
2812 cpi->prob_last_coded = 128;
2813 cpi->prob_gf_coded = 128;
2817 cpi->prob_intra_coded = (rf_intra * 255) / (rf_intra + rf_inter);
2819 if (cpi->prob_intra_coded < 1)
2820 cpi->prob_intra_coded = 1;
2822 if ((cm->frames_since_golden > 0) || cpi->source_alt_ref_active)
2824 cpi->prob_last_coded = rf_inter ? (rfct[LAST_FRAME] * 255) / rf_inter : 128;
2826 if (cpi->prob_last_coded < 1)
2827 cpi->prob_last_coded = 1;
2829 cpi->prob_gf_coded = (rfct[GOLDEN_FRAME] + rfct[ALTREF_FRAME])
2830 ? (rfct[GOLDEN_FRAME] * 255) / (rfct[GOLDEN_FRAME] + rfct[ALTREF_FRAME]) : 128;
2832 if (cpi->prob_gf_coded < 1)
2833 cpi->prob_gf_coded = 1;
2838 const int *const rfct = cpi->count_mb_ref_frame_usage;
2839 const int rf_intra = rfct[INTRA_FRAME];
2840 const int rf_inter = rfct[LAST_FRAME] + rfct[GOLDEN_FRAME] + rfct[ALTREF_FRAME];
2842 if (cm->frame_type == KEY_FRAME)
2844 cpi->prob_intra_coded = 255;
2845 cpi->prob_last_coded = 128;
2846 cpi->prob_gf_coded = 128;
2848 else if (!(rf_intra + rf_inter))
2850 // This is a trap in case this function is called with cpi->recent_ref_frame_usage[] blank.
2851 cpi->prob_intra_coded = 63;
2852 cpi->prob_last_coded = 128;
2853 cpi->prob_gf_coded = 128;
2857 cpi->prob_intra_coded = (rf_intra * 255) / (rf_intra + rf_inter);
2859 if (cpi->prob_intra_coded < 1)
2860 cpi->prob_intra_coded = 1;
2862 cpi->prob_last_coded = rf_inter ? (rfct[LAST_FRAME] * 255) / rf_inter : 128;
2864 if (cpi->prob_last_coded < 1)
2865 cpi->prob_last_coded = 1;
2867 cpi->prob_gf_coded = (rfct[GOLDEN_FRAME] + rfct[ALTREF_FRAME])
2868 ? (rfct[GOLDEN_FRAME] * 255) / (rfct[GOLDEN_FRAME] + rfct[ALTREF_FRAME]) : 128;
2870 if (cpi->prob_gf_coded < 1)
2871 cpi->prob_gf_coded = 1;
2874 // update reference frame costs since we can do better than what we got last frame.
2876 if (cpi->common.refresh_alt_ref_frame)
2878 cpi->prob_intra_coded += 40;
2879 cpi->prob_last_coded = 200;
2880 cpi->prob_gf_coded = 1;
2882 else if (cpi->common.frames_since_golden == 0)
2884 cpi->prob_last_coded = 214;
2885 cpi->prob_gf_coded = 1;
2887 else if (cpi->common.frames_since_golden == 1)
2889 cpi->prob_last_coded = 192;
2890 cpi->prob_gf_coded = 220;
2892 else if (cpi->source_alt_ref_active)
2894 //int dist = cpi->common.frames_till_alt_ref_frame + cpi->common.frames_since_golden;
2895 cpi->prob_gf_coded -= 20;
2897 if (cpi->prob_gf_coded < 10)
2898 cpi->prob_gf_coded = 10;
2905 // 1 = key, 0 = inter
2906 static int decide_key_frame(VP8_COMP *cpi)
2908 VP8_COMMON *cm = &cpi->common;
2910 int code_key_frame = FALSE;
2914 if (cpi->Speed > 11)
2917 // Clear down mmx registers
2918 vp8_clear_system_state(); //__asm emms;
2920 if ((cpi->compressor_speed == 2) && (cpi->Speed >= 5) && (cpi->sf.RD == 0))
2922 double change = 1.0 * abs((int)(cpi->intra_error - cpi->last_intra_error)) / (1 + cpi->last_intra_error);
2923 double change2 = 1.0 * abs((int)(cpi->prediction_error - cpi->last_prediction_error)) / (1 + cpi->last_prediction_error);
2924 double minerror = cm->MBs * 256;
2928 if (10 * cpi->intra_error / (1 + cpi->prediction_error) < 15
2929 && cpi->prediction_error > minerror
2930 && (change > .25 || change2 > .25))
2932 FILE *f = fopen("intra_inter.stt", "a");
2934 if (cpi->prediction_error <= 0)
2935 cpi->prediction_error = 1;
2937 fprintf(f, "%d %d %d %d %14.4f\n",
2938 cm->current_video_frame,
2939 (int) cpi->prediction_error,
2940 (int) cpi->intra_error,
2941 (int)((10 * cpi->intra_error) / cpi->prediction_error),
2949 cpi->last_intra_error = cpi->intra_error;
2950 cpi->last_prediction_error = cpi->prediction_error;
2952 if (10 * cpi->intra_error / (1 + cpi->prediction_error) < 15
2953 && cpi->prediction_error > minerror
2954 && (change > .25 || change2 > .25))
2956 /*(change > 1.4 || change < .75)&& cpi->this_frame_percent_intra > cpi->last_frame_percent_intra + 3*/
2964 // If the following are true we might as well code a key frame
2965 if (((cpi->this_frame_percent_intra == 100) &&
2966 (cpi->this_frame_percent_intra > (cpi->last_frame_percent_intra + 2))) ||
2967 ((cpi->this_frame_percent_intra > 95) &&
2968 (cpi->this_frame_percent_intra >= (cpi->last_frame_percent_intra + 5))))
2970 code_key_frame = TRUE;
2972 // in addition if the following are true and this is not a golden frame then code a key frame
2973 // Note that on golden frames there often seems to be a pop in intra useage anyway hence this
2974 // restriction is designed to prevent spurious key frames. The Intra pop needs to be investigated.
2975 else if (((cpi->this_frame_percent_intra > 60) &&
2976 (cpi->this_frame_percent_intra > (cpi->last_frame_percent_intra * 2))) ||
2977 ((cpi->this_frame_percent_intra > 75) &&
2978 (cpi->this_frame_percent_intra > (cpi->last_frame_percent_intra * 3 / 2))) ||
2979 ((cpi->this_frame_percent_intra > 90) &&
2980 (cpi->this_frame_percent_intra > (cpi->last_frame_percent_intra + 10))))
2982 if (!cm->refresh_golden_frame)
2983 code_key_frame = TRUE;
2986 return code_key_frame;
2990 #if !(CONFIG_REALTIME_ONLY)
2991 static void Pass1Encode(VP8_COMP *cpi, unsigned long *size, unsigned char *dest, unsigned int *frame_flags)
2996 vp8_set_quantizer(cpi, 26);
2998 scale_and_extend_source(cpi->un_scaled_source, cpi);
2999 vp8_first_pass(cpi);
3004 void write_cx_frame_to_file(YV12_BUFFER_CONFIG *frame, int this_frame)
3012 sprintf(filename, "cx\\y%04d.raw", this_frame);
3013 yframe = fopen(filename, "wb");
3015 for (i = 0; i < frame->y_height; i++)
3016 fwrite(frame->y_buffer + i * frame->y_stride, frame->y_width, 1, yframe);
3019 sprintf(filename, "cx\\u%04d.raw", this_frame);
3020 yframe = fopen(filename, "wb");
3022 for (i = 0; i < frame->uv_height; i++)
3023 fwrite(frame->u_buffer + i * frame->uv_stride, frame->uv_width, 1, yframe);
3026 sprintf(filename, "cx\\v%04d.raw", this_frame);
3027 yframe = fopen(filename, "wb");
3029 for (i = 0; i < frame->uv_height; i++)
3030 fwrite(frame->v_buffer + i * frame->uv_stride, frame->uv_width, 1, yframe);
3035 // return of 0 means drop frame
3037 // Function to test for conditions that indeicate we should loop
3038 // back and recode a frame.
3039 static BOOL recode_loop_test( VP8_COMP *cpi,
3040 int high_limit, int low_limit,
3041 int q, int maxq, int minq )
3043 BOOL force_recode = FALSE;
3044 VP8_COMMON *cm = &cpi->common;
3046 // Is frame recode allowed at all
3047 // Yes if either recode mode 1 is selected or mode two is selcted
3048 // and the frame is a key frame. golden frame or alt_ref_frame
3049 if ( (cpi->sf.recode_loop == 1) ||
3050 ( (cpi->sf.recode_loop == 2) &&
3051 ( (cm->frame_type == KEY_FRAME) ||
3052 cm->refresh_golden_frame ||
3053 cm->refresh_alt_ref_frame ) ) )
3055 // General over and under shoot tests
3056 if ( ((cpi->projected_frame_size > high_limit) && (q < maxq)) ||
3057 ((cpi->projected_frame_size < low_limit) && (q > minq)) )
3059 force_recode = TRUE;
3061 // Special Constrained quality tests
3062 else if (cpi->oxcf.end_usage == USAGE_CONSTRAINED_QUALITY)
3064 // Undershoot and below auto cq level
3065 if ( (q > cpi->cq_target_quality) &&
3066 (cpi->projected_frame_size <
3067 ((cpi->this_frame_target * 7) >> 3)))
3069 force_recode = TRUE;
3071 // Severe undershoot and between auto and user cq level
3072 else if ( (q > cpi->oxcf.cq_level) &&
3073 (cpi->projected_frame_size < cpi->min_frame_bandwidth) &&
3074 (cpi->active_best_quality > cpi->oxcf.cq_level))
3076 force_recode = TRUE;
3077 cpi->active_best_quality = cpi->oxcf.cq_level;
3082 return force_recode;
3085 void loopfilter_frame(VP8_COMP *cpi, VP8_COMMON *cm)
3089 cm->filter_level = 0;
3093 struct vpx_usec_timer timer;
3095 vp8_clear_system_state();
3097 vpx_usec_timer_start(&timer);
3098 if (cpi->sf.auto_filter == 0)
3099 vp8cx_pick_filter_level_fast(cpi->Source, cpi);
3102 vp8cx_pick_filter_level(cpi->Source, cpi);
3104 vpx_usec_timer_mark(&timer);
3105 cpi->time_pick_lpf += vpx_usec_timer_elapsed(&timer);
3108 #if CONFIG_MULTITHREAD
3109 if (cpi->b_multi_threaded)
3110 sem_post(&cpi->h_event_end_lpf); /* signal that we have set filter_level */
3113 if (cm->filter_level > 0)
3115 vp8cx_set_alt_lf_level(cpi, cm->filter_level);
3116 vp8_loop_filter_frame(cm, &cpi->mb.e_mbd, cm->filter_level);
3117 cm->last_filter_type = cm->filter_type;
3118 cm->last_sharpness_level = cm->sharpness_level;
3121 vp8_yv12_extend_frame_borders_ptr(cm->frame_to_show);
3124 YV12_BUFFER_CONFIG *lst_yv12 = &cm->yv12_fb[cm->lst_fb_idx];
3125 YV12_BUFFER_CONFIG *new_yv12 = &cm->yv12_fb[cm->new_fb_idx];
3126 YV12_BUFFER_CONFIG *gld_yv12 = &cm->yv12_fb[cm->gld_fb_idx];
3127 YV12_BUFFER_CONFIG *alt_yv12 = &cm->yv12_fb[cm->alt_fb_idx];
3128 // At this point the new frame has been encoded.
3129 // If any buffer copy / swapping is signaled it should be done here.
3130 if (cm->frame_type == KEY_FRAME)
3132 vp8_yv12_copy_frame_ptr(cm->frame_to_show, gld_yv12);
3133 vp8_yv12_copy_frame_ptr(cm->frame_to_show, alt_yv12);
3135 else // For non key frames
3137 // Code to copy between reference buffers
3138 if (cm->copy_buffer_to_arf)
3140 if (cm->copy_buffer_to_arf == 1)
3142 if (cm->refresh_last_frame)
3143 // We copy new_frame here because last and new buffers will already have been swapped if cm->refresh_last_frame is set.
3144 vp8_yv12_copy_frame_ptr(new_yv12, alt_yv12);
3146 vp8_yv12_copy_frame_ptr(lst_yv12, alt_yv12);
3148 else if (cm->copy_buffer_to_arf == 2)
3149 vp8_yv12_copy_frame_ptr(gld_yv12, alt_yv12);
3152 if (cm->copy_buffer_to_gf)
3154 if (cm->copy_buffer_to_gf == 1)
3156 if (cm->refresh_last_frame)
3157 // We copy new_frame here because last and new buffers will already have been swapped if cm->refresh_last_frame is set.
3158 vp8_yv12_copy_frame_ptr(new_yv12, gld_yv12);
3160 vp8_yv12_copy_frame_ptr(lst_yv12, gld_yv12);
3162 else if (cm->copy_buffer_to_gf == 2)
3163 vp8_yv12_copy_frame_ptr(alt_yv12, gld_yv12);
3169 static void encode_frame_to_data_rate
3172 unsigned long *size,
3173 unsigned char *dest,
3174 unsigned int *frame_flags
3178 int frame_over_shoot_limit;
3179 int frame_under_shoot_limit;
3189 int zbin_oq_low = 0;
3192 VP8_COMMON *cm = &cpi->common;
3193 int active_worst_qchanged = FALSE;
3195 int overshoot_seen = FALSE;
3196 int undershoot_seen = FALSE;
3197 int drop_mark = cpi->oxcf.drop_frames_water_mark * cpi->oxcf.optimal_buffer_level / 100;
3198 int drop_mark75 = drop_mark * 2 / 3;
3199 int drop_mark50 = drop_mark / 4;
3200 int drop_mark25 = drop_mark / 8;
3203 // Clear down mmx registers to allow floating point in what follows
3204 vp8_clear_system_state();
3206 // Test code for segmentation of gf/arf (0,0)
3207 //segmentation_test_function((VP8_PTR) cpi);
3209 #if CONFIG_REALTIME_ONLY
3210 if(cpi->oxcf.auto_key && cm->frame_type != KEY_FRAME)
3212 if(cpi->force_next_frame_intra)
3214 cm->frame_type = KEY_FRAME; /* delayed intra frame */
3217 cpi->force_next_frame_intra = 0;
3220 // For an alt ref frame in 2 pass we skip the call to the second pass function that sets the target bandwidth
3221 #if !(CONFIG_REALTIME_ONLY)
3225 if (cpi->common.refresh_alt_ref_frame)
3227 cpi->per_frame_bandwidth = cpi->twopass.gf_bits; // Per frame bit target for the alt ref frame
3228 cpi->target_bandwidth = cpi->twopass.gf_bits * cpi->output_frame_rate; // per second target bitrate
3233 cpi->per_frame_bandwidth = (int)(cpi->target_bandwidth / cpi->output_frame_rate);
3235 // Default turn off buffer to buffer copying
3236 cm->copy_buffer_to_gf = 0;
3237 cm->copy_buffer_to_arf = 0;
3239 // Clear zbin over-quant value and mode boost values.
3240 cpi->zbin_over_quant = 0;
3241 cpi->zbin_mode_boost = 0;
3243 // Enable or disable mode based tweaking of the zbin
3244 // For 2 Pass Only used where GF/ARF prediction quality
3245 // is above a threshold
3246 cpi->zbin_mode_boost = 0;
3247 cpi->zbin_mode_boost_enabled = TRUE;
3250 if ( cpi->gfu_boost <= 400 )
3252 cpi->zbin_mode_boost_enabled = FALSE;
3256 // Current default encoder behaviour for the altref sign bias
3257 if (cpi->source_alt_ref_active)
3258 cpi->common.ref_frame_sign_bias[ALTREF_FRAME] = 1;
3260 cpi->common.ref_frame_sign_bias[ALTREF_FRAME] = 0;
3262 // Check to see if a key frame is signalled
3263 // For two pass with auto key frame enabled cm->frame_type may already be set, but not for one pass.
3264 if ((cm->current_video_frame == 0) ||
3265 (cm->frame_flags & FRAMEFLAGS_KEY) ||
3266 (cpi->oxcf.auto_key && (cpi->frames_since_key % cpi->key_frame_frequency == 0)))
3268 // Key frame from VFW/auto-keyframe/first frame
3269 cm->frame_type = KEY_FRAME;
3272 // Set default state for segment and mode based loop filter update flags
3273 cpi->mb.e_mbd.update_mb_segmentation_map = 0;
3274 cpi->mb.e_mbd.update_mb_segmentation_data = 0;
3275 cpi->mb.e_mbd.mode_ref_lf_delta_update = 0;
3277 // Set various flags etc to special state if it is a key frame
3278 if (cm->frame_type == KEY_FRAME)
3282 // Reset the loop filter deltas and segmentation map
3283 setup_features(cpi);
3285 // If segmentation is enabled force a map update for key frames
3286 if (cpi->mb.e_mbd.segmentation_enabled)
3288 cpi->mb.e_mbd.update_mb_segmentation_map = 1;
3289 cpi->mb.e_mbd.update_mb_segmentation_data = 1;
3292 // The alternate reference frame cannot be active for a key frame
3293 cpi->source_alt_ref_active = FALSE;
3295 // Reset the RD threshold multipliers to default of * 1 (128)
3296 for (i = 0; i < MAX_MODES; i++)
3298 cpi->rd_thresh_mult[i] = 128;
3302 // Test code for segmentation
3303 //if ( (cm->frame_type == KEY_FRAME) || ((cm->current_video_frame % 2) == 0))
3304 //if ( (cm->current_video_frame % 2) == 0 )
3305 // enable_segmentation((VP8_PTR)cpi);
3307 // disable_segmentation((VP8_PTR)cpi);
3310 // Experimental code for lagged compress and one pass
3311 // Initialise one_pass GF frames stats
3312 // Update stats used for GF selection
3313 //if ( cpi->pass == 0 )
3315 cpi->one_pass_frame_index = cm->current_video_frame % MAX_LAG_BUFFERS;
3317 cpi->one_pass_frame_stats[cpi->one_pass_frame_index ].frames_so_far = 0;
3318 cpi->one_pass_frame_stats[cpi->one_pass_frame_index ].frame_intra_error = 0.0;
3319 cpi->one_pass_frame_stats[cpi->one_pass_frame_index ].frame_coded_error = 0.0;
3320 cpi->one_pass_frame_stats[cpi->one_pass_frame_index ].frame_pcnt_inter = 0.0;
3321 cpi->one_pass_frame_stats[cpi->one_pass_frame_index ].frame_pcnt_motion = 0.0;
3322 cpi->one_pass_frame_stats[cpi->one_pass_frame_index ].frame_mvr = 0.0;
3323 cpi->one_pass_frame_stats[cpi->one_pass_frame_index ].frame_mvr_abs = 0.0;
3324 cpi->one_pass_frame_stats[cpi->one_pass_frame_index ].frame_mvc = 0.0;
3325 cpi->one_pass_frame_stats[cpi->one_pass_frame_index ].frame_mvc_abs = 0.0;
3329 update_rd_ref_frame_probs(cpi);
3331 if (cpi->drop_frames_allowed)
3333 // The reset to decimation 0 is only done here for one pass.
3334 // Once it is set two pass leaves decimation on till the next kf.
3335 if ((cpi->buffer_level > drop_mark) && (cpi->decimation_factor > 0))
3336 cpi->decimation_factor --;
3338 if (cpi->buffer_level > drop_mark75 && cpi->decimation_factor > 0)
3339 cpi->decimation_factor = 1;
3341 else if (cpi->buffer_level < drop_mark25 && (cpi->decimation_factor == 2 || cpi->decimation_factor == 3))
3343 cpi->decimation_factor = 3;
3345 else if (cpi->buffer_level < drop_mark50 && (cpi->decimation_factor == 1 || cpi->decimation_factor == 2))
3347 cpi->decimation_factor = 2;
3349 else if (cpi->buffer_level < drop_mark75 && (cpi->decimation_factor == 0 || cpi->decimation_factor == 1))
3351 cpi->decimation_factor = 1;
3354 //vpx_log("Encoder: Decimation Factor: %d \n",cpi->decimation_factor);
3357 // The following decimates the frame rate according to a regular pattern (i.e. to 1/2 or 2/3 frame rate)
3358 // This can be used to help prevent buffer under-run in CBR mode. Alternatively it might be desirable in
3359 // some situations to drop frame rate but throw more bits at each frame.
3361 // Note that dropping a key frame can be problematic if spatial resampling is also active
3362 if (cpi->decimation_factor > 0)
3364 switch (cpi->decimation_factor)
3367 cpi->per_frame_bandwidth = cpi->per_frame_bandwidth * 3 / 2;
3370 cpi->per_frame_bandwidth = cpi->per_frame_bandwidth * 5 / 4;
3373 cpi->per_frame_bandwidth = cpi->per_frame_bandwidth * 5 / 4;
3377 // Note that we should not throw out a key frame (especially when spatial resampling is enabled).
3378 if ((cm->frame_type == KEY_FRAME)) // && cpi->oxcf.allow_spatial_resampling )
3380 cpi->decimation_count = cpi->decimation_factor;
3382 else if (cpi->decimation_count > 0)
3384 cpi->decimation_count --;
3385 cpi->bits_off_target += cpi->av_per_frame_bandwidth;
3386 cm->current_video_frame++;
3387 cpi->frames_since_key++;
3389 #if CONFIG_INTERNAL_STATS
3393 cpi->buffer_level = cpi->bits_off_target;
3398 cpi->decimation_count = cpi->decimation_factor;
3401 // Decide how big to make the frame
3402 if (!vp8_pick_frame_size(cpi))
3404 cm->current_video_frame++;
3405 cpi->frames_since_key++;
3409 // Reduce active_worst_allowed_q for CBR if our buffer is getting too full.
3410 // This has a knock on effect on active best quality as well.
3411 // For CBR if the buffer reaches its maximum level then we can no longer
3412 // save up bits for later frames so we might as well use them up
3413 // on the current frame.
3414 if ((cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER) &&
3415 (cpi->buffer_level >= cpi->oxcf.optimal_buffer_level) && cpi->buffered_mode)
3417 int Adjustment = cpi->active_worst_quality / 4; // Max adjustment is 1/4
3423 if (cpi->buffer_level < cpi->oxcf.maximum_buffer_size)
3425 buff_lvl_step = (cpi->oxcf.maximum_buffer_size - cpi->oxcf.optimal_buffer_level) / Adjustment;
3429 Adjustment = (cpi->buffer_level - cpi->oxcf.optimal_buffer_level) / buff_lvl_step;
3430 cpi->active_worst_quality -= Adjustment;
3435 cpi->active_worst_quality -= Adjustment;
3440 // Set an active best quality and if necessary active worst quality
3441 // There is some odd behaviour for one pass here that needs attention.
3442 if ( (cpi->pass == 2) || (cpi->ni_frames > 150))
3444 vp8_clear_system_state();
3446 Q = cpi->active_worst_quality;
3448 if ( cm->frame_type == KEY_FRAME )
3450 if ( cpi->pass == 2 )
3452 if (cpi->gfu_boost > 600)
3453 cpi->active_best_quality = kf_low_motion_minq[Q];
3455 cpi->active_best_quality = kf_high_motion_minq[Q];
3457 // Special case for key frames forced because we have reached
3458 // the maximum key frame interval. Here force the Q to a range
3459 // based on the ambient Q to reduce the risk of popping
3460 if ( cpi->this_key_frame_forced )
3462 if ( cpi->active_best_quality > cpi->avg_frame_qindex * 7/8)
3463 cpi->active_best_quality = cpi->avg_frame_qindex * 7/8;
3464 else if ( cpi->active_best_quality < cpi->avg_frame_qindex >> 2 )
3465 cpi->active_best_quality = cpi->avg_frame_qindex >> 2;
3468 // One pass more conservative
3470 cpi->active_best_quality = kf_high_motion_minq[Q];
3473 else if (cm->refresh_golden_frame || cpi->common.refresh_alt_ref_frame)
3475 // Use the lower of cpi->active_worst_quality and recent
3476 // average Q as basis for GF/ARF Q limit unless last frame was
3478 if ( (cpi->frames_since_key > 1) &&
3479 (cpi->avg_frame_qindex < cpi->active_worst_quality) )
3481 Q = cpi->avg_frame_qindex;
3483 if ( (cpi->oxcf.end_usage == USAGE_CONSTRAINED_QUALITY) &&
3484 (Q < cpi->oxcf.cq_level) )
3486 Q = cpi->oxcf.cq_level;
3490 if ( cpi->pass == 2 )
3492 if ( cpi->gfu_boost > 1000 )
3493 cpi->active_best_quality = gf_low_motion_minq[Q];
3494 else if ( cpi->gfu_boost < 400 )
3495 cpi->active_best_quality = gf_high_motion_minq[Q];
3497 cpi->active_best_quality = gf_mid_motion_minq[Q];
3499 // One pass more conservative
3501 cpi->active_best_quality = gf_high_motion_minq[Q];
3505 cpi->active_best_quality = inter_minq[Q];
3507 // For the constant/constrained quality mode we dont want
3508 // the quality to rise above the cq level.
3509 if ((cpi->oxcf.end_usage == USAGE_CONSTRAINED_QUALITY) &&
3510 (cpi->active_best_quality < cpi->cq_target_quality) )
3512 // If we are strongly undershooting the target rate in the last
3513 // frames then use the user passed in cq value not the auto
3515 if ( cpi->rolling_actual_bits < cpi->min_frame_bandwidth )
3516 cpi->active_best_quality = cpi->oxcf.cq_level;
3518 cpi->active_best_quality = cpi->cq_target_quality;
3522 // If CBR and the buffer is as full then it is reasonable to allow
3523 // higher quality on the frames to prevent bits just going to waste.
3524 if (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER)
3526 // Note that the use of >= here elliminates the risk of a devide
3527 // by 0 error in the else if clause
3528 if (cpi->buffer_level >= cpi->oxcf.maximum_buffer_size)
3529 cpi->active_best_quality = cpi->best_quality;
3531 else if (cpi->buffer_level > cpi->oxcf.optimal_buffer_level)
3533 int Fraction = ((cpi->buffer_level - cpi->oxcf.optimal_buffer_level) * 128) / (cpi->oxcf.maximum_buffer_size - cpi->oxcf.optimal_buffer_level);
3534 int min_qadjustment = ((cpi->active_best_quality - cpi->best_quality) * Fraction) / 128;
3536 cpi->active_best_quality -= min_qadjustment;
3540 // Make sure constrained quality mode limits are adhered to for the first
3541 // few frames of one pass encodes
3542 else if (cpi->oxcf.end_usage == USAGE_CONSTRAINED_QUALITY)
3544 if ( (cm->frame_type == KEY_FRAME) ||
3545 cm->refresh_golden_frame || cpi->common.refresh_alt_ref_frame )
3547 cpi->active_best_quality = cpi->best_quality;
3549 else if (cpi->active_best_quality < cpi->cq_target_quality)
3551 cpi->active_best_quality = cpi->cq_target_quality;
3555 // Clip the active best and worst quality values to limits
3556 if (cpi->active_worst_quality > cpi->worst_quality)
3557 cpi->active_worst_quality = cpi->worst_quality;
3559 if (cpi->active_best_quality < cpi->best_quality)
3560 cpi->active_best_quality = cpi->best_quality;
3561 else if (cpi->active_best_quality > cpi->active_worst_quality)
3562 cpi->active_best_quality = cpi->active_worst_quality;
3564 // Determine initial Q to try
3565 Q = vp8_regulate_q(cpi, cpi->this_frame_target);
3566 last_zbin_oq = cpi->zbin_over_quant;
3568 // Set highest allowed value for Zbin over quant
3569 if (cm->frame_type == KEY_FRAME)
3570 zbin_oq_high = 0; //ZBIN_OQ_MAX/16
3571 else if (cm->refresh_alt_ref_frame || (cm->refresh_golden_frame && !cpi->source_alt_ref_active))
3574 zbin_oq_high = ZBIN_OQ_MAX;
3576 // Setup background Q adjustment for error resilliant mode
3577 if (cpi->cyclic_refresh_mode_enabled)
3578 cyclic_background_refresh(cpi, Q, 0);
3580 vp8_compute_frame_size_bounds(cpi, &frame_under_shoot_limit, &frame_over_shoot_limit);
3582 // Limit Q range for the adaptive loop.
3583 bottom_index = cpi->active_best_quality;
3584 top_index = cpi->active_worst_quality;
3585 q_low = cpi->active_best_quality;
3586 q_high = cpi->active_worst_quality;
3588 vp8_save_coding_context(cpi);
3593 scale_and_extend_source(cpi->un_scaled_source, cpi);
3594 #if !(CONFIG_REALTIME_ONLY) && CONFIG_POSTPROC
3596 if (cpi->oxcf.noise_sensitivity > 0)
3601 switch (cpi->oxcf.noise_sensitivity)
3624 if (cm->frame_type == KEY_FRAME)
3626 vp8_de_noise(cpi->Source, cpi->Source, l , 1, 0, RTCD(postproc));
3630 vp8_de_noise(cpi->Source, cpi->Source, l , 1, 0, RTCD(postproc));
3632 src = cpi->Source->y_buffer;
3634 if (cpi->Source->y_stride < 0)
3636 src += cpi->Source->y_stride * (cpi->Source->y_height - 1);
3643 #ifdef OUTPUT_YUV_SRC
3644 vp8_write_yuv_frame(cpi->Source);
3649 vp8_clear_system_state(); //__asm emms;
3652 if(cpi->is_src_frame_alt_ref)
3656 vp8_set_quantizer(cpi, Q);
3659 // setup skip prob for costing in mode/mv decision
3660 if (cpi->common.mb_no_coeff_skip)
3662 cpi->prob_skip_false = cpi->base_skip_false_prob[Q];
3664 if (cm->frame_type != KEY_FRAME)
3666 if (cpi->common.refresh_alt_ref_frame)
3668 if (cpi->last_skip_false_probs[2] != 0)
3669 cpi->prob_skip_false = cpi->last_skip_false_probs[2];
3672 if(cpi->last_skip_false_probs[2]!=0 && abs(Q- cpi->last_skip_probs_q[2])<=16 )
3673 cpi->prob_skip_false = cpi->last_skip_false_probs[2];
3674 else if (cpi->last_skip_false_probs[2]!=0)
3675 cpi->prob_skip_false = (cpi->last_skip_false_probs[2] + cpi->prob_skip_false ) / 2;
3678 else if (cpi->common.refresh_golden_frame)
3680 if (cpi->last_skip_false_probs[1] != 0)
3681 cpi->prob_skip_false = cpi->last_skip_false_probs[1];
3684 if(cpi->last_skip_false_probs[1]!=0 && abs(Q- cpi->last_skip_probs_q[1])<=16 )
3685 cpi->prob_skip_false = cpi->last_skip_false_probs[1];
3686 else if (cpi->last_skip_false_probs[1]!=0)
3687 cpi->prob_skip_false = (cpi->last_skip_false_probs[1] + cpi->prob_skip_false ) / 2;
3692 if (cpi->last_skip_false_probs[0] != 0)
3693 cpi->prob_skip_false = cpi->last_skip_false_probs[0];
3696 if(cpi->last_skip_false_probs[0]!=0 && abs(Q- cpi->last_skip_probs_q[0])<=16 )
3697 cpi->prob_skip_false = cpi->last_skip_false_probs[0];
3698 else if(cpi->last_skip_false_probs[0]!=0)
3699 cpi->prob_skip_false = (cpi->last_skip_false_probs[0] + cpi->prob_skip_false ) / 2;
3703 //as this is for cost estimate, let's make sure it does not go extreme eitehr way
3704 if (cpi->prob_skip_false < 5)
3705 cpi->prob_skip_false = 5;
3707 if (cpi->prob_skip_false > 250)
3708 cpi->prob_skip_false = 250;
3710 if (cpi->is_src_frame_alt_ref)
3711 cpi->prob_skip_false = 1;
3720 FILE *f = fopen("skip.stt", "a");
3721 fprintf(f, "%d, %d, %4d ", cpi->common.refresh_golden_frame, cpi->common.refresh_alt_ref_frame, cpi->prob_skip_false);
3729 if (cm->frame_type == KEY_FRAME)
3731 resize_key_frame(cpi);
3732 vp8_setup_key_frame(cpi);
3735 // transform / motion compensation build reconstruction frame
3736 vp8_encode_frame(cpi);
3738 cpi->projected_frame_size -= vp8_estimate_entropy_savings(cpi);
3739 cpi->projected_frame_size = (cpi->projected_frame_size > 0) ? cpi->projected_frame_size : 0;
3741 vp8_clear_system_state(); //__asm emms;
3743 // Test to see if the stats generated for this frame indicate that we should have coded a key frame
3744 // (assuming that we didn't)!
3745 if (cpi->pass != 2 && cpi->oxcf.auto_key && cm->frame_type != KEY_FRAME)
3748 #if CONFIG_REALTIME_ONLY
3750 /* we don't do re-encoding in realtime mode
3751 * if key frame is decided than we force it on next frame */
3752 cpi->force_next_frame_intra = decide_key_frame(cpi);
3755 if (decide_key_frame(cpi))
3757 // Reset all our sizing numbers and recode
3758 cm->frame_type = KEY_FRAME;
3760 vp8_pick_frame_size(cpi);
3762 // Clear the Alt reference frame active flag when we have a key frame
3763 cpi->source_alt_ref_active = FALSE;
3765 // Reset the loop filter deltas and segmentation map
3766 setup_features(cpi);
3768 // If segmentation is enabled force a map update for key frames
3769 if (cpi->mb.e_mbd.segmentation_enabled)
3771 cpi->mb.e_mbd.update_mb_segmentation_map = 1;
3772 cpi->mb.e_mbd.update_mb_segmentation_data = 1;
3775 vp8_restore_coding_context(cpi);
3777 Q = vp8_regulate_q(cpi, cpi->this_frame_target);
3779 vp8_compute_frame_size_bounds(cpi, &frame_under_shoot_limit, &frame_over_shoot_limit);
3781 // Limit Q range for the adaptive loop.
3782 bottom_index = cpi->active_best_quality;
3783 top_index = cpi->active_worst_quality;
3784 q_low = cpi->active_best_quality;
3785 q_high = cpi->active_worst_quality;
3795 vp8_clear_system_state();
3797 if (frame_over_shoot_limit == 0)
3798 frame_over_shoot_limit = 1;
3800 // Are we are overshooting and up against the limit of active max Q.
3801 if (((cpi->pass != 2) || (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER)) &&
3802 (Q == cpi->active_worst_quality) &&
3803 (cpi->active_worst_quality < cpi->worst_quality) &&
3804 (cpi->projected_frame_size > frame_over_shoot_limit))
3806 int over_size_percent = ((cpi->projected_frame_size - frame_over_shoot_limit) * 100) / frame_over_shoot_limit;
3808 // If so is there any scope for relaxing it
3809 while ((cpi->active_worst_quality < cpi->worst_quality) && (over_size_percent > 0))
3811 cpi->active_worst_quality++;
3812 top_index = cpi->active_worst_quality;
3813 over_size_percent = (int)(over_size_percent * 0.96); // Assume 1 qstep = about 4% on frame size.
3816 // If we have updated the active max Q do not call vp8_update_rate_correction_factors() this loop.
3817 active_worst_qchanged = TRUE;
3820 active_worst_qchanged = FALSE;
3822 #if !(CONFIG_REALTIME_ONLY)
3823 // Special case handling for forced key frames
3824 if ( (cm->frame_type == KEY_FRAME) && cpi->this_key_frame_forced )
3827 int kf_err = vp8_calc_ss_err(cpi->Source,
3828 &cm->yv12_fb[cm->new_fb_idx],
3829 IF_RTCD(&cpi->rtcd.variance));
3831 // The key frame is not good enough
3832 if ( kf_err > ((cpi->ambient_err * 7) >> 3) )
3835 q_high = (Q > q_low) ? (Q - 1) : q_low;
3838 Q = (q_high + q_low) >> 1;
3840 // The key frame is much better than the previous frame
3841 else if ( kf_err < (cpi->ambient_err >> 1) )
3844 q_low = (Q < q_high) ? (Q + 1) : q_high;
3847 Q = (q_high + q_low + 1) >> 1;
3850 // Clamp Q to upper and lower limits:
3856 Loop = ((Q != last_q)) ? TRUE : FALSE;
3859 // Is the projected frame size out of range and are we allowed to attempt to recode.
3860 else if ( recode_loop_test( cpi,
3861 frame_over_shoot_limit, frame_under_shoot_limit,
3862 Q, top_index, bottom_index ) )
3867 // Frame size out of permitted range:
3868 // Update correction factor & compute new Q to try...
3870 // Frame is too large
3871 if (cpi->projected_frame_size > cpi->this_frame_target)
3873 //if ( cpi->zbin_over_quant == 0 )
3874 q_low = (Q < q_high) ? (Q + 1) : q_high; // Raise Qlow as to at least the current value
3876 if (cpi->zbin_over_quant > 0) // If we are using over quant do the same for zbin_oq_low
3877 zbin_oq_low = (cpi->zbin_over_quant < zbin_oq_high) ? (cpi->zbin_over_quant + 1) : zbin_oq_high;
3879 //if ( undershoot_seen || (Q == MAXQ) )
3880 if (undershoot_seen)
3882 // Update rate_correction_factor unless cpi->active_worst_quality has changed.
3883 if (!active_worst_qchanged)
3884 vp8_update_rate_correction_factors(cpi, 1);
3886 Q = (q_high + q_low + 1) / 2;
3888 // Adjust cpi->zbin_over_quant (only allowed when Q is max)
3890 cpi->zbin_over_quant = 0;
3893 zbin_oq_low = (cpi->zbin_over_quant < zbin_oq_high) ? (cpi->zbin_over_quant + 1) : zbin_oq_high;
3894 cpi->zbin_over_quant = (zbin_oq_high + zbin_oq_low) / 2;
3899 // Update rate_correction_factor unless cpi->active_worst_quality has changed.
3900 if (!active_worst_qchanged)
3901 vp8_update_rate_correction_factors(cpi, 0);
3903 Q = vp8_regulate_q(cpi, cpi->this_frame_target);
3905 while (((Q < q_low) || (cpi->zbin_over_quant < zbin_oq_low)) && (Retries < 10))
3907 vp8_update_rate_correction_factors(cpi, 0);
3908 Q = vp8_regulate_q(cpi, cpi->this_frame_target);
3913 overshoot_seen = TRUE;
3915 // Frame is too small
3918 if (cpi->zbin_over_quant == 0)
3919 q_high = (Q > q_low) ? (Q - 1) : q_low; // Lower q_high if not using over quant
3920 else // else lower zbin_oq_high
3921 zbin_oq_high = (cpi->zbin_over_quant > zbin_oq_low) ? (cpi->zbin_over_quant - 1) : zbin_oq_low;
3925 // Update rate_correction_factor unless cpi->active_worst_quality has changed.
3926 if (!active_worst_qchanged)
3927 vp8_update_rate_correction_factors(cpi, 1);
3929 Q = (q_high + q_low) / 2;
3931 // Adjust cpi->zbin_over_quant (only allowed when Q is max)
3933 cpi->zbin_over_quant = 0;
3935 cpi->zbin_over_quant = (zbin_oq_high + zbin_oq_low) / 2;
3939 // Update rate_correction_factor unless cpi->active_worst_quality has changed.
3940 if (!active_worst_qchanged)
3941 vp8_update_rate_correction_factors(cpi, 0);
3943 Q = vp8_regulate_q(cpi, cpi->this_frame_target);
3945 // Special case reset for qlow for constrained quality.
3946 // This should only trigger where there is very substantial
3947 // undershoot on a frame and the auto cq level is above
3948 // the user passsed in value.
3949 if ( (cpi->oxcf.end_usage == USAGE_CONSTRAINED_QUALITY) &&
3955 while (((Q > q_high) || (cpi->zbin_over_quant > zbin_oq_high)) && (Retries < 10))
3957 vp8_update_rate_correction_factors(cpi, 0);
3958 Q = vp8_regulate_q(cpi, cpi->this_frame_target);
3963 undershoot_seen = TRUE;
3966 // Clamp Q to upper and lower limits:
3972 // Clamp cpi->zbin_over_quant
3973 cpi->zbin_over_quant = (cpi->zbin_over_quant < zbin_oq_low) ? zbin_oq_low : (cpi->zbin_over_quant > zbin_oq_high) ? zbin_oq_high : cpi->zbin_over_quant;
3975 //Loop = ((Q != last_q) || (last_zbin_oq != cpi->zbin_over_quant)) ? TRUE : FALSE;
3976 Loop = ((Q != last_q)) ? TRUE : FALSE;
3977 last_zbin_oq = cpi->zbin_over_quant;
3983 if (cpi->is_src_frame_alt_ref)
3988 vp8_restore_coding_context(cpi);
3990 #if CONFIG_INTERNAL_STATS
3991 cpi->tot_recode_hits++;
3995 while (Loop == TRUE);
3998 // Experimental code for lagged and one pass
3999 // Update stats used for one pass GF selection
4003 double frame_intra_error;
4004 double frame_coded_error;
4005 double frame_pcnt_inter;
4006 double frame_pcnt_motion;
4008 double frame_mvr_abs;
4010 double frame_mvc_abs;
4013 cpi->one_pass_frame_stats[cpi->one_pass_frame_index].frame_coded_error = (double)cpi->prediction_error;
4014 cpi->one_pass_frame_stats[cpi->one_pass_frame_index].frame_intra_error = (double)cpi->intra_error;
4015 cpi->one_pass_frame_stats[cpi->one_pass_frame_index].frame_pcnt_inter = (double)(100 - cpi->this_frame_percent_intra) / 100.0;
4019 // Special case code to reduce pulsing when key frames are forced at a
4020 // fixed interval. Note the reconstruction error if it is the frame before
4021 // the force key frame
4022 if ( cpi->next_key_frame_forced && (cpi->twopass.frames_to_key == 0) )
4024 cpi->ambient_err = vp8_calc_ss_err(cpi->Source,
4025 &cm->yv12_fb[cm->new_fb_idx],
4026 IF_RTCD(&cpi->rtcd.variance));
4029 // This frame's MVs are saved and will be used in next frame's MV prediction.
4030 // Last frame has one more line(add to bottom) and one more column(add to right) than cm->mip. The edge elements are initialized to 0.
4031 if(cm->show_frame) //do not save for altref frame
4035 MODE_INFO *tmp = cm->mip; //point to beginning of allocated MODE_INFO arrays.
4037 if(cm->frame_type != KEY_FRAME)
4039 for (mb_row = 0; mb_row < cm->mb_rows+1; mb_row ++)
4041 for (mb_col = 0; mb_col < cm->mb_cols+1; mb_col ++)
4043 if(tmp->mbmi.ref_frame != INTRA_FRAME)
4044 cpi->lfmv[mb_col + mb_row*(cm->mode_info_stride+1)].as_int = tmp->mbmi.mv.as_int;
4046 cpi->lf_ref_frame_sign_bias[mb_col + mb_row*(cm->mode_info_stride+1)] = cm->ref_frame_sign_bias[tmp->mbmi.ref_frame];
4047 cpi->lf_ref_frame[mb_col + mb_row*(cm->mode_info_stride+1)] = tmp->mbmi.ref_frame;
4054 // Update the GF useage maps.
4055 // This is done after completing the compression of a frame when all modes etc. are finalized but before loop filter
4056 // This is done after completing the compression of a frame when all modes etc. are finalized but before loop filter
4057 vp8_update_gf_useage_maps(cpi, cm, &cpi->mb);
4059 if (cm->frame_type == KEY_FRAME)
4060 cm->refresh_last_frame = 1;
4064 FILE *f = fopen("gfactive.stt", "a");
4065 fprintf(f, "%8d %8d %8d %8d %8d\n", cm->current_video_frame, (100 * cpi->gf_active_count) / (cpi->common.mb_rows * cpi->common.mb_cols), cpi->this_iiratio, cpi->next_iiratio, cm->refresh_golden_frame);
4070 // For inter frames the current default behaviour is that when cm->refresh_golden_frame is set we copy the old GF over to the ARF buffer
4071 // This is purely an encoder descision at present.
4072 if (!cpi->oxcf.error_resilient_mode && cm->refresh_golden_frame)
4073 cm->copy_buffer_to_arf = 2;
4075 cm->copy_buffer_to_arf = 0;
4077 if (cm->refresh_last_frame)
4079 vp8_swap_yv12_buffer(&cm->yv12_fb[cm->lst_fb_idx], &cm->yv12_fb[cm->new_fb_idx]);
4080 cm->frame_to_show = &cm->yv12_fb[cm->lst_fb_idx];
4083 cm->frame_to_show = &cm->yv12_fb[cm->new_fb_idx];
4086 #if CONFIG_MULTITHREAD
4087 if (cpi->b_multi_threaded)
4089 sem_post(&cpi->h_event_start_lpf); /* start loopfilter in separate thread */
4094 loopfilter_frame(cpi, cm);
4097 if (cpi->oxcf.error_resilient_mode == 1)
4099 cm->refresh_entropy_probs = 0;
4102 #if CONFIG_MULTITHREAD
4103 /* wait that filter_level is picked so that we can continue with stream packing */
4104 if (cpi->b_multi_threaded)
4105 sem_wait(&cpi->h_event_end_lpf);
4108 // build the bitstream
4109 vp8_pack_bitstream(cpi, dest, size);
4111 #if CONFIG_MULTITHREAD
4112 /* wait for loopfilter thread done */
4113 if (cpi->b_multi_threaded)
4115 sem_wait(&cpi->h_event_end_lpf);
4119 /* Move storing frame_type out of the above loop since it is also
4120 * needed in motion search besides loopfilter */
4121 cm->last_frame_type = cm->frame_type;
4123 // Update rate control heuristics
4124 cpi->total_byte_count += (*size);
4125 cpi->projected_frame_size = (*size) << 3;
4127 if (!active_worst_qchanged)
4128 vp8_update_rate_correction_factors(cpi, 2);
4130 cpi->last_q[cm->frame_type] = cm->base_qindex;
4132 if (cm->frame_type == KEY_FRAME)
4134 vp8_adjust_key_frame_context(cpi);
4137 // Keep a record of ambient average Q.
4138 if (cm->frame_type != KEY_FRAME)
4139 cpi->avg_frame_qindex = (2 + 3 * cpi->avg_frame_qindex + cm->base_qindex) >> 2;
4141 // Keep a record from which we can calculate the average Q excluding GF updates and key frames
4142 if ((cm->frame_type != KEY_FRAME) && !cm->refresh_golden_frame && !cm->refresh_alt_ref_frame)
4146 // Calculate the average Q for normal inter frames (not key or GFU
4148 if ( cpi->pass == 2 )
4150 cpi->ni_tot_qi += Q;
4151 cpi->ni_av_qi = (cpi->ni_tot_qi / cpi->ni_frames);
4155 // Damp value for first few frames
4156 if (cpi->ni_frames > 150 )
4158 cpi->ni_tot_qi += Q;
4159 cpi->ni_av_qi = (cpi->ni_tot_qi / cpi->ni_frames);
4161 // For one pass, early in the clip ... average the current frame Q
4162 // value with the worstq entered by the user as a dampening measure
4165 cpi->ni_tot_qi += Q;
4166 cpi->ni_av_qi = ((cpi->ni_tot_qi / cpi->ni_frames) + cpi->worst_quality + 1) / 2;
4169 // If the average Q is higher than what was used in the last frame
4170 // (after going through the recode loop to keep the frame size within range)
4171 // then use the last frame value - 1.
4172 // The -1 is designed to stop Q and hence the data rate, from progressively
4173 // falling away during difficult sections, but at the same time reduce the number of
4174 // itterations around the recode loop.
4175 if (Q > cpi->ni_av_qi)
4176 cpi->ni_av_qi = Q - 1;
4182 // If the frame was massively oversize and we are below optimal buffer level drop next frame
4183 if ((cpi->drop_frames_allowed) &&
4184 (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER) &&
4185 (cpi->buffer_level < cpi->oxcf.drop_frames_water_mark * cpi->oxcf.optimal_buffer_level / 100) &&
4186 (cpi->projected_frame_size > (4 * cpi->this_frame_target)))
4188 cpi->drop_frame = TRUE;
4193 // Set the count for maximum consequative dropped frames based upon the ratio of
4194 // this frame size to the target average per frame bandwidth.
4195 // (cpi->av_per_frame_bandwidth > 0) is just a sanity check to prevent / 0.
4196 if (cpi->drop_frames_allowed && (cpi->av_per_frame_bandwidth > 0))
4198 cpi->max_drop_count = cpi->projected_frame_size / cpi->av_per_frame_bandwidth;
4200 if (cpi->max_drop_count > cpi->max_consec_dropped_frames)
4201 cpi->max_drop_count = cpi->max_consec_dropped_frames;
4204 // Update the buffer level variable.
4205 // Non-viewable frames are a special case and are treated as pure overhead.
4206 if ( !cm->show_frame )
4207 cpi->bits_off_target -= cpi->projected_frame_size;
4209 cpi->bits_off_target += cpi->av_per_frame_bandwidth - cpi->projected_frame_size;
4211 // Rolling monitors of whether we are over or underspending used to help regulate min and Max Q in two pass.
4212 cpi->rolling_target_bits = ((cpi->rolling_target_bits * 3) + cpi->this_frame_target + 2) / 4;
4213 cpi->rolling_actual_bits = ((cpi->rolling_actual_bits * 3) + cpi->projected_frame_size + 2) / 4;
4214 cpi->long_rolling_target_bits = ((cpi->long_rolling_target_bits * 31) + cpi->this_frame_target + 16) / 32;
4215 cpi->long_rolling_actual_bits = ((cpi->long_rolling_actual_bits * 31) + cpi->projected_frame_size + 16) / 32;
4217 // Actual bits spent
4218 cpi->total_actual_bits += cpi->projected_frame_size;
4221 cpi->total_target_vs_actual += (cpi->this_frame_target - cpi->projected_frame_size);
4223 cpi->buffer_level = cpi->bits_off_target;
4225 // Update bits left to the kf and gf groups to account for overshoot or undershoot on these frames
4226 if (cm->frame_type == KEY_FRAME)
4228 cpi->twopass.kf_group_bits += cpi->this_frame_target - cpi->projected_frame_size;
4230 if (cpi->twopass.kf_group_bits < 0)
4231 cpi->twopass.kf_group_bits = 0 ;
4233 else if (cm->refresh_golden_frame || cm->refresh_alt_ref_frame)
4235 cpi->twopass.gf_group_bits += cpi->this_frame_target - cpi->projected_frame_size;
4237 if (cpi->twopass.gf_group_bits < 0)
4238 cpi->twopass.gf_group_bits = 0 ;
4241 if (cm->frame_type != KEY_FRAME)
4243 if (cpi->common.refresh_alt_ref_frame)
4245 cpi->last_skip_false_probs[2] = cpi->prob_skip_false;
4246 cpi->last_skip_probs_q[2] = cm->base_qindex;
4248 else if (cpi->common.refresh_golden_frame)
4250 cpi->last_skip_false_probs[1] = cpi->prob_skip_false;
4251 cpi->last_skip_probs_q[1] = cm->base_qindex;
4255 cpi->last_skip_false_probs[0] = cpi->prob_skip_false;
4256 cpi->last_skip_probs_q[0] = cm->base_qindex;
4258 //update the baseline
4259 cpi->base_skip_false_prob[cm->base_qindex] = cpi->prob_skip_false;
4264 #if 0 && CONFIG_INTERNAL_STATS
4266 FILE *f = fopen("tmp.stt", "a");
4268 vp8_clear_system_state(); //__asm emms;
4270 if (cpi->total_coded_error_left != 0.0)
4271 fprintf(f, "%10d %10d %10d %10d %10d %10d %10d %10d %6d %6d"
4272 "%6d %6d %6d %5d %5d %5d %8d %8.2f %10d %10.3f"
4274 cpi->common.current_video_frame, cpi->this_frame_target,
4275 cpi->projected_frame_size,
4276 (cpi->projected_frame_size - cpi->this_frame_target),
4277 (int)cpi->total_target_vs_actual,
4278 (cpi->oxcf.starting_buffer_level-cpi->bits_off_target),
4279 (int)cpi->total_actual_bits, cm->base_qindex,
4280 cpi->active_best_quality, cpi->active_worst_quality,
4281 cpi->ni_av_qi, cpi->cq_target_quality, cpi->zbin_over_quant,
4282 //cpi->avg_frame_qindex, cpi->zbin_over_quant,
4283 cm->refresh_golden_frame, cm->refresh_alt_ref_frame,
4284 cm->frame_type, cpi->gfu_boost,
4285 cpi->twopass.est_max_qcorrection_factor, (int)cpi->bits_left,
4286 cpi->total_coded_error_left,
4287 (double)cpi->bits_left / cpi->total_coded_error_left,
4288 cpi->tot_recode_hits);
4290 fprintf(f, "%10d %10d %10d %10d %10d %10d %10d %10d %6d %6d"
4291 "%6d %6d %6d %5d %5d %5d %8d %8.2f %10d %10.3f"
4293 cpi->common.current_video_frame,
4294 cpi->this_frame_target, cpi->projected_frame_size,
4295 (cpi->projected_frame_size - cpi->this_frame_target),
4296 (int)cpi->total_target_vs_actual,
4297 (cpi->oxcf.starting_buffer_level-cpi->bits_off_target),
4298 (int)cpi->total_actual_bits, cm->base_qindex,
4299 cpi->active_best_quality, cpi->active_worst_quality,
4300 cpi->ni_av_qi, cpi->cq_target_quality, cpi->zbin_over_quant,
4301 //cpi->avg_frame_qindex, cpi->zbin_over_quant,
4302 cm->refresh_golden_frame, cm->refresh_alt_ref_frame,
4303 cm->frame_type, cpi->gfu_boost,
4304 cpi->twopass.est_max_qcorrection_factor, (int)cpi->bits_left,
4305 cpi->total_coded_error_left, cpi->tot_recode_hits);
4310 FILE *fmodes = fopen("Modes.stt", "a");
4313 fprintf(fmodes, "%6d:%1d:%1d:%1d ",
4314 cpi->common.current_video_frame,
4315 cm->frame_type, cm->refresh_golden_frame,
4316 cm->refresh_alt_ref_frame);
4318 for (i = 0; i < MAX_MODES; i++)
4319 fprintf(fmodes, "%5d ", cpi->mode_chosen_counts[i]);
4321 fprintf(fmodes, "\n");
4329 // If this was a kf or Gf note the Q
4330 if ((cm->frame_type == KEY_FRAME) || cm->refresh_golden_frame || cm->refresh_alt_ref_frame)
4331 cm->last_kf_gf_q = cm->base_qindex;
4333 if (cm->refresh_golden_frame == 1)
4334 cm->frame_flags = cm->frame_flags | FRAMEFLAGS_GOLDEN;
4336 cm->frame_flags = cm->frame_flags&~FRAMEFLAGS_GOLDEN;
4338 if (cm->refresh_alt_ref_frame == 1)
4339 cm->frame_flags = cm->frame_flags | FRAMEFLAGS_ALTREF;
4341 cm->frame_flags = cm->frame_flags&~FRAMEFLAGS_ALTREF;
4344 if (cm->refresh_last_frame & cm->refresh_golden_frame) // both refreshed
4345 cpi->gold_is_last = 1;
4346 else if (cm->refresh_last_frame ^ cm->refresh_golden_frame) // 1 refreshed but not the other
4347 cpi->gold_is_last = 0;
4349 if (cm->refresh_last_frame & cm->refresh_alt_ref_frame) // both refreshed
4350 cpi->alt_is_last = 1;
4351 else if (cm->refresh_last_frame ^ cm->refresh_alt_ref_frame) // 1 refreshed but not the other
4352 cpi->alt_is_last = 0;
4354 if (cm->refresh_alt_ref_frame & cm->refresh_golden_frame) // both refreshed
4355 cpi->gold_is_alt = 1;
4356 else if (cm->refresh_alt_ref_frame ^ cm->refresh_golden_frame) // 1 refreshed but not the other
4357 cpi->gold_is_alt = 0;
4359 cpi->ref_frame_flags = VP8_ALT_FLAG | VP8_GOLD_FLAG | VP8_LAST_FLAG;
4361 if (cpi->gold_is_last)
4362 cpi->ref_frame_flags &= ~VP8_GOLD_FLAG;
4364 if (cpi->alt_is_last)
4365 cpi->ref_frame_flags &= ~VP8_ALT_FLAG;
4367 if (cpi->gold_is_alt)
4368 cpi->ref_frame_flags &= ~VP8_ALT_FLAG;
4371 if (cpi->oxcf.error_resilient_mode)
4373 if (cm->frame_type != KEY_FRAME)
4375 // Is this an alternate reference update
4376 if (cm->refresh_alt_ref_frame)
4377 vp8_yv12_copy_frame_ptr(cm->frame_to_show, &cm->yv12_fb[cm->alt_fb_idx]);
4379 if (cm->refresh_golden_frame)
4380 vp8_yv12_copy_frame_ptr(cm->frame_to_show, &cm->yv12_fb[cm->gld_fb_idx]);
4385 if (cpi->oxcf.play_alternate && cm->refresh_alt_ref_frame && (cm->frame_type != KEY_FRAME))
4386 // Update the alternate reference frame and stats as appropriate.
4387 update_alt_ref_frame_and_stats(cpi);
4389 // Update the Golden frame and golden frame and stats as appropriate.
4390 update_golden_frame_and_stats(cpi);
4393 if (cm->frame_type == KEY_FRAME)
4395 // Tell the caller that the frame was coded as a key frame
4396 *frame_flags = cm->frame_flags | FRAMEFLAGS_KEY;
4398 // As this frame is a key frame the next defaults to an inter frame.
4399 cm->frame_type = INTER_FRAME;
4401 cpi->last_frame_percent_intra = 100;
4405 *frame_flags = cm->frame_flags&~FRAMEFLAGS_KEY;
4407 cpi->last_frame_percent_intra = cpi->this_frame_percent_intra;
4410 // Clear the one shot update flags for segmentation map and mode/ref loop filter deltas.
4411 cpi->mb.e_mbd.update_mb_segmentation_map = 0;
4412 cpi->mb.e_mbd.update_mb_segmentation_data = 0;
4413 cpi->mb.e_mbd.mode_ref_lf_delta_update = 0;
4416 // Dont increment frame counters if this was an altref buffer update not a real frame
4419 cm->current_video_frame++;
4420 cpi->frames_since_key++;
4423 // reset to normal state now that we are done.
4431 sprintf(filename, "enc%04d.yuv", (int) cm->current_video_frame);
4432 recon_file = fopen(filename, "wb");
4433 fwrite(cm->yv12_fb[cm->lst_fb_idx].buffer_alloc,
4434 cm->yv12_fb[cm->lst_fb_idx].frame_size, 1, recon_file);
4440 //vp8_write_yuv_frame("encoder_recon.yuv", cm->frame_to_show);
4446 static void check_gf_quality(VP8_COMP *cpi)
4448 VP8_COMMON *cm = &cpi->common;
4449 int gf_active_pct = (100 * cpi->gf_active_count) / (cm->mb_rows * cm->mb_cols);
4450 int gf_ref_usage_pct = (cpi->count_mb_ref_frame_usage[GOLDEN_FRAME] * 100) / (cm->mb_rows * cm->mb_cols);
4451 int last_ref_zz_useage = (cpi->inter_zz_count * 100) / (cm->mb_rows * cm->mb_cols);
4453 // Gf refresh is not currently being signalled
4454 if (cpi->gf_update_recommended == 0)
4456 if (cpi->common.frames_since_golden > 7)
4459 if ((gf_active_pct < 10) || ((gf_active_pct + gf_ref_usage_pct) < 15))
4461 // ...but last frame zero zero usage is reasonbable so a new gf might be appropriate
4462 if (last_ref_zz_useage >= 25)
4464 cpi->gf_bad_count ++;
4466 if (cpi->gf_bad_count >= 8) // Check that the condition is stable
4468 cpi->gf_update_recommended = 1;
4469 cpi->gf_bad_count = 0;
4473 cpi->gf_bad_count = 0; // Restart count as the background is not stable enough
4476 cpi->gf_bad_count = 0; // Gf useage has picked up so reset count
4479 // If the signal is set but has not been read should we cancel it.
4480 else if (last_ref_zz_useage < 15)
4482 cpi->gf_update_recommended = 0;
4483 cpi->gf_bad_count = 0;
4488 FILE *f = fopen("gfneeded.stt", "a");
4489 fprintf(f, "%10d %10d %10d %10d %10ld \n",
4490 cm->current_video_frame,
4491 cpi->common.frames_since_golden,
4492 gf_active_pct, gf_ref_usage_pct,
4493 cpi->gf_update_recommended);
4500 #if !(CONFIG_REALTIME_ONLY)
4501 static void Pass2Encode(VP8_COMP *cpi, unsigned long *size, unsigned char *dest, unsigned int *frame_flags)
4504 if (!cpi->common.refresh_alt_ref_frame)
4505 vp8_second_pass(cpi);
4507 encode_frame_to_data_rate(cpi, size, dest, frame_flags);
4508 cpi->twopass.bits_left -= 8 * *size;
4510 if (!cpi->common.refresh_alt_ref_frame)
4512 double two_pass_min_rate = (double)(cpi->oxcf.target_bandwidth
4513 *cpi->oxcf.two_pass_vbrmin_section / 100);
4514 cpi->twopass.bits_left += (long long)(two_pass_min_rate / cpi->oxcf.frame_rate);
4519 //For ARM NEON, d8-d15 are callee-saved registers, and need to be saved by us.
4521 extern void vp8_push_neon(INT64 *store);
4522 extern void vp8_pop_neon(INT64 *store);
4526 int vp8_receive_raw_frame(VP8_PTR ptr, unsigned int frame_flags, YV12_BUFFER_CONFIG *sd, INT64 time_stamp, INT64 end_time)
4531 VP8_COMP *cpi = (VP8_COMP *) ptr;
4532 VP8_COMMON *cm = &cpi->common;
4533 struct vpx_usec_timer timer;
4537 #if CONFIG_RUNTIME_CPU_DETECT
4538 if (cm->rtcd.flags & HAS_NEON)
4541 vp8_push_neon(store_reg);
4545 vpx_usec_timer_start(&timer);
4546 if(vp8_lookahead_push(cpi->lookahead, sd, time_stamp, end_time,
4549 cm->clr_type = sd->clrtype;
4550 vpx_usec_timer_mark(&timer);
4551 cpi->time_receive_data += vpx_usec_timer_elapsed(&timer);
4554 #if CONFIG_RUNTIME_CPU_DETECT
4555 if (cm->rtcd.flags & HAS_NEON)
4558 vp8_pop_neon(store_reg);
4566 int vp8_get_compressed_data(VP8_PTR ptr, unsigned int *frame_flags, unsigned long *size, unsigned char *dest, INT64 *time_stamp, INT64 *time_end, int flush)
4571 VP8_COMP *cpi = (VP8_COMP *) ptr;
4572 VP8_COMMON *cm = &cpi->common;
4573 struct vpx_usec_timer tsctimer;
4574 struct vpx_usec_timer ticktimer;
4575 struct vpx_usec_timer cmptimer;
4576 YV12_BUFFER_CONFIG *force_src_buffer = NULL;
4582 #if CONFIG_RUNTIME_CPU_DETECT
4583 if (cm->rtcd.flags & HAS_NEON)
4586 vp8_push_neon(store_reg);
4590 vpx_usec_timer_start(&cmptimer);
4594 #if !(CONFIG_REALTIME_ONLY)
4595 // Should we code an alternate reference frame
4596 if (cpi->oxcf.error_resilient_mode == 0 &&
4597 cpi->oxcf.play_alternate &&
4598 cpi->source_alt_ref_pending)
4600 if ((cpi->source = vp8_lookahead_peek(cpi->lookahead,
4601 cpi->frames_till_gf_update_due)))
4603 cpi->alt_ref_source = cpi->source;
4604 if (cpi->oxcf.arnr_max_frames > 0)
4606 vp8_temporal_filter_prepare_c(cpi,
4607 cpi->frames_till_gf_update_due);
4608 force_src_buffer = &cpi->alt_ref_buffer;
4610 cm->frames_till_alt_ref_frame = cpi->frames_till_gf_update_due;
4611 cm->refresh_alt_ref_frame = 1;
4612 cm->refresh_golden_frame = 0;
4613 cm->refresh_last_frame = 0;
4615 cpi->source_alt_ref_pending = FALSE; // Clear Pending altf Ref flag.
4616 cpi->is_src_frame_alt_ref = 0;
4623 if ((cpi->source = vp8_lookahead_pop(cpi->lookahead, flush)))
4627 cpi->is_src_frame_alt_ref = cpi->alt_ref_source
4628 && (cpi->source == cpi->alt_ref_source);
4630 if(cpi->is_src_frame_alt_ref)
4631 cpi->alt_ref_source = NULL;
4637 cpi->un_scaled_source =
4638 cpi->Source = force_src_buffer ? force_src_buffer : &cpi->source->img;
4639 *time_stamp = cpi->source->ts_start;
4640 *time_end = cpi->source->ts_end;
4641 *frame_flags = cpi->source->flags;
4646 #if !(CONFIG_REALTIME_ONLY)
4648 if (flush && cpi->pass == 1 && !cpi->twopass.first_pass_done)
4650 vp8_end_first_pass(cpi); /* get last stats packet */
4651 cpi->twopass.first_pass_done = 1;
4657 #if CONFIG_RUNTIME_CPU_DETECT
4658 if (cm->rtcd.flags & HAS_NEON)
4661 vp8_pop_neon(store_reg);
4667 if (cpi->source->ts_start < cpi->first_time_stamp_ever)
4669 cpi->first_time_stamp_ever = cpi->source->ts_start;
4670 cpi->last_end_time_stamp_seen = cpi->source->ts_start;
4673 // adjust frame rates based on timestamps given
4674 if (!cm->refresh_alt_ref_frame)
4676 long long this_duration;
4679 if (cpi->source->ts_start == cpi->first_time_stamp_ever)
4681 this_duration = cpi->source->ts_end - cpi->source->ts_start;
4686 long long last_duration;
4688 this_duration = cpi->source->ts_end - cpi->last_end_time_stamp_seen;
4689 last_duration = cpi->last_end_time_stamp_seen
4690 - cpi->last_time_stamp_seen;
4691 // do a step update if the duration changes by 10%
4693 step = ((this_duration - last_duration) * 10 / last_duration);
4699 vp8_new_frame_rate(cpi, 10000000.0 / this_duration);
4702 double avg_duration, interval;
4704 /* Average this frame's rate into the last second's average
4705 * frame rate. If we haven't seen 1 second yet, then average
4706 * over the whole interval seen.
4708 interval = cpi->source->ts_end - cpi->first_time_stamp_ever;
4709 if(interval > 10000000.0)
4710 interval = 10000000;
4712 avg_duration = 10000000.0 / cpi->oxcf.frame_rate;
4713 avg_duration *= (interval - avg_duration + this_duration);
4714 avg_duration /= interval;
4716 vp8_new_frame_rate(cpi, 10000000.0 / avg_duration);
4720 cpi->last_time_stamp_seen = cpi->source->ts_start;
4721 cpi->last_end_time_stamp_seen = cpi->source->ts_end;
4724 if (cpi->compressor_speed == 2)
4726 check_gf_quality(cpi);
4727 vpx_usec_timer_start(&tsctimer);
4728 vpx_usec_timer_start(&ticktimer);
4731 // start with a 0 size frame
4734 // Clear down mmx registers
4735 vp8_clear_system_state(); //__asm emms;
4737 cm->frame_type = INTER_FRAME;
4738 cm->frame_flags = *frame_flags;
4742 if (cm->refresh_alt_ref_frame)
4744 //cm->refresh_golden_frame = 1;
4745 cm->refresh_golden_frame = 0;
4746 cm->refresh_last_frame = 0;
4750 cm->refresh_golden_frame = 0;
4751 cm->refresh_last_frame = 1;
4756 #if !(CONFIG_REALTIME_ONLY)
4760 Pass1Encode(cpi, size, dest, frame_flags);
4762 else if (cpi->pass == 2)
4764 Pass2Encode(cpi, size, dest, frame_flags);
4768 encode_frame_to_data_rate(cpi, size, dest, frame_flags);
4770 if (cpi->compressor_speed == 2)
4772 unsigned int duration, duration2;
4773 vpx_usec_timer_mark(&tsctimer);
4774 vpx_usec_timer_mark(&ticktimer);
4776 duration = vpx_usec_timer_elapsed(&ticktimer);
4777 duration2 = (unsigned int)((double)duration / 2);
4779 if (cm->frame_type != KEY_FRAME)
4781 if (cpi->avg_encode_time == 0)
4782 cpi->avg_encode_time = duration;
4784 cpi->avg_encode_time = (7 * cpi->avg_encode_time + duration) >> 3;
4789 //if(*frame_flags!=1)
4792 if (cpi->avg_pick_mode_time == 0)
4793 cpi->avg_pick_mode_time = duration2;
4795 cpi->avg_pick_mode_time = (7 * cpi->avg_pick_mode_time + duration2) >> 3;
4801 if (cm->refresh_entropy_probs == 0)
4803 vpx_memcpy(&cm->fc, &cm->lfc, sizeof(cm->fc));
4806 // if its a dropped frame honor the requests on subsequent frames
4810 // return to normal state
4811 cm->refresh_entropy_probs = 1;
4812 cm->refresh_alt_ref_frame = 0;
4813 cm->refresh_golden_frame = 0;
4814 cm->refresh_last_frame = 1;
4815 cm->frame_type = INTER_FRAME;
4819 vpx_usec_timer_mark(&cmptimer);
4820 cpi->time_compress_data += vpx_usec_timer_elapsed(&cmptimer);
4822 if (cpi->b_calculate_psnr && cpi->pass != 1 && cm->show_frame)
4824 generate_psnr_packet(cpi);
4827 #if CONFIG_INTERNAL_STATS
4831 cpi->bytes += *size;
4838 if (cpi->b_calculate_psnr)
4842 YV12_BUFFER_CONFIG *orig = cpi->Source;
4843 YV12_BUFFER_CONFIG *recon = cpi->common.frame_to_show;
4844 YV12_BUFFER_CONFIG *pp = &cm->post_proc_buffer;
4845 int y_samples = orig->y_height * orig->y_width ;
4846 int uv_samples = orig->uv_height * orig->uv_width ;
4847 int t_samples = y_samples + 2 * uv_samples;
4850 ye = calc_plane_error(orig->y_buffer, orig->y_stride,
4851 recon->y_buffer, recon->y_stride, orig->y_width, orig->y_height,
4852 IF_RTCD(&cpi->rtcd.variance));
4854 ue = calc_plane_error(orig->u_buffer, orig->uv_stride,
4855 recon->u_buffer, recon->uv_stride, orig->uv_width, orig->uv_height,
4856 IF_RTCD(&cpi->rtcd.variance));
4858 ve = calc_plane_error(orig->v_buffer, orig->uv_stride,
4859 recon->v_buffer, recon->uv_stride, orig->uv_width, orig->uv_height,
4860 IF_RTCD(&cpi->rtcd.variance));
4862 sq_error = ye + ue + ve;
4864 frame_psnr = vp8_mse2psnr(t_samples, 255.0, sq_error);
4866 cpi->total_y += vp8_mse2psnr(y_samples, 255.0, ye);
4867 cpi->total_u += vp8_mse2psnr(uv_samples, 255.0, ue);
4868 cpi->total_v += vp8_mse2psnr(uv_samples, 255.0, ve);
4869 cpi->total_sq_error += sq_error;
4870 cpi->total += frame_psnr;
4872 double frame_psnr2, frame_ssim2 = 0;
4875 vp8_deblock(cm->frame_to_show, &cm->post_proc_buffer, cm->filter_level * 10 / 6, 1, 0, IF_RTCD(&cm->rtcd.postproc));
4876 vp8_clear_system_state();
4878 ye = calc_plane_error(orig->y_buffer, orig->y_stride,
4879 pp->y_buffer, pp->y_stride, orig->y_width, orig->y_height,
4880 IF_RTCD(&cpi->rtcd.variance));
4882 ue = calc_plane_error(orig->u_buffer, orig->uv_stride,
4883 pp->u_buffer, pp->uv_stride, orig->uv_width, orig->uv_height,
4884 IF_RTCD(&cpi->rtcd.variance));
4886 ve = calc_plane_error(orig->v_buffer, orig->uv_stride,
4887 pp->v_buffer, pp->uv_stride, orig->uv_width, orig->uv_height,
4888 IF_RTCD(&cpi->rtcd.variance));
4890 sq_error = ye + ue + ve;
4892 frame_psnr2 = vp8_mse2psnr(t_samples, 255.0, sq_error);
4894 cpi->totalp_y += vp8_mse2psnr(y_samples, 255.0, ye);
4895 cpi->totalp_u += vp8_mse2psnr(uv_samples, 255.0, ue);
4896 cpi->totalp_v += vp8_mse2psnr(uv_samples, 255.0, ve);
4897 cpi->total_sq_error2 += sq_error;
4898 cpi->totalp += frame_psnr2;
4900 frame_ssim2 = vp8_calc_ssim(cpi->Source,
4901 &cm->post_proc_buffer, 1, &weight,
4902 IF_RTCD(&cpi->rtcd.variance));
4904 cpi->summed_quality += frame_ssim2 * weight;
4905 cpi->summed_weights += weight;
4910 if (cpi->b_calculate_ssimg)
4912 double y, u, v, frame_all;
4913 frame_all = vp8_calc_ssimg(cpi->Source, cm->frame_to_show,
4914 &y, &u, &v, IF_RTCD(&cpi->rtcd.variance));
4915 cpi->total_ssimg_y += y;
4916 cpi->total_ssimg_u += u;
4917 cpi->total_ssimg_v += v;
4918 cpi->total_ssimg_all += frame_all;
4926 if (cpi->common.frame_type != 0 && cpi->common.base_qindex == cpi->oxcf.worst_allowed_q)
4928 skiptruecount += cpi->skip_true_count;
4929 skipfalsecount += cpi->skip_false_count;
4937 FILE *f = fopen("skip.stt", "a");
4938 fprintf(f, "frame:%4d flags:%4x Q:%4d P:%4d Size:%5d\n", cpi->common.current_video_frame, *frame_flags, cpi->common.base_qindex, cpi->prob_skip_false, *size);
4940 if (cpi->is_src_frame_alt_ref == 1)
4941 fprintf(f, "skipcount: %4d framesize: %d\n", cpi->skip_true_count , *size);
4950 #if CONFIG_RUNTIME_CPU_DETECT
4951 if (cm->rtcd.flags & HAS_NEON)
4954 vp8_pop_neon(store_reg);
4961 int vp8_get_preview_raw_frame(VP8_PTR comp, YV12_BUFFER_CONFIG *dest, vp8_ppflags_t *flags)
4963 VP8_COMP *cpi = (VP8_COMP *) comp;
4965 if (cpi->common.refresh_alt_ref_frame)
4971 ret = vp8_post_proc_frame(&cpi->common, dest, flags);
4974 if (cpi->common.frame_to_show)
4976 *dest = *cpi->common.frame_to_show;
4977 dest->y_width = cpi->common.Width;
4978 dest->y_height = cpi->common.Height;
4979 dest->uv_height = cpi->common.Height / 2;
4987 #endif //!CONFIG_POSTPROC
4988 vp8_clear_system_state();
4993 int vp8_set_roimap(VP8_PTR comp, unsigned char *map, unsigned int rows, unsigned int cols, int delta_q[4], int delta_lf[4], unsigned int threshold[4])
4995 VP8_COMP *cpi = (VP8_COMP *) comp;
4996 signed char feature_data[MB_LVL_MAX][MAX_MB_SEGMENTS];
4998 if (cpi->common.mb_rows != rows || cpi->common.mb_cols != cols)
5003 disable_segmentation((VP8_PTR)cpi);
5007 // Set the segmentation Map
5008 set_segmentation_map((VP8_PTR)cpi, map);
5010 // Activate segmentation.
5011 enable_segmentation((VP8_PTR)cpi);
5013 // Set up the quant segment data
5014 feature_data[MB_LVL_ALT_Q][0] = delta_q[0];
5015 feature_data[MB_LVL_ALT_Q][1] = delta_q[1];
5016 feature_data[MB_LVL_ALT_Q][2] = delta_q[2];
5017 feature_data[MB_LVL_ALT_Q][3] = delta_q[3];
5019 // Set up the loop segment data s
5020 feature_data[MB_LVL_ALT_LF][0] = delta_lf[0];
5021 feature_data[MB_LVL_ALT_LF][1] = delta_lf[1];
5022 feature_data[MB_LVL_ALT_LF][2] = delta_lf[2];
5023 feature_data[MB_LVL_ALT_LF][3] = delta_lf[3];
5025 cpi->segment_encode_breakout[0] = threshold[0];
5026 cpi->segment_encode_breakout[1] = threshold[1];
5027 cpi->segment_encode_breakout[2] = threshold[2];
5028 cpi->segment_encode_breakout[3] = threshold[3];
5030 // Initialise the feature data structure
5031 // SEGMENT_DELTADATA 0, SEGMENT_ABSDATA 1
5032 set_segment_data((VP8_PTR)cpi, &feature_data[0][0], SEGMENT_DELTADATA);
5037 int vp8_set_active_map(VP8_PTR comp, unsigned char *map, unsigned int rows, unsigned int cols)
5039 VP8_COMP *cpi = (VP8_COMP *) comp;
5041 if (rows == cpi->common.mb_rows && cols == cpi->common.mb_cols)
5045 vpx_memcpy(cpi->active_map, map, rows * cols);
5046 cpi->active_map_enabled = 1;
5049 cpi->active_map_enabled = 0;
5055 //cpi->active_map_enabled = 0;
5060 int vp8_set_internal_size(VP8_PTR comp, VPX_SCALING horiz_mode, VPX_SCALING vert_mode)
5062 VP8_COMP *cpi = (VP8_COMP *) comp;
5064 if (horiz_mode <= ONETWO)
5065 cpi->common.horiz_scale = horiz_mode;
5069 if (vert_mode <= ONETWO)
5070 cpi->common.vert_scale = vert_mode;
5079 int vp8_calc_ss_err(YV12_BUFFER_CONFIG *source, YV12_BUFFER_CONFIG *dest, const vp8_variance_rtcd_vtable_t *rtcd)
5084 unsigned char *src = source->y_buffer;
5085 unsigned char *dst = dest->y_buffer;
5088 // Loop through the Y plane raw and reconstruction data summing (square differences)
5089 for (i = 0; i < source->y_height; i += 16)
5091 for (j = 0; j < source->y_width; j += 16)
5094 Total += VARIANCE_INVOKE(rtcd, mse16x16)(src + j, source->y_stride, dst + j, dest->y_stride, &sse);
5097 src += 16 * source->y_stride;
5098 dst += 16 * dest->y_stride;
5105 int vp8_get_quantizer(VP8_PTR c)
5107 VP8_COMP *cpi = (VP8_COMP *) c;
5108 return cpi->common.base_qindex;