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 "vpx_config.h"
13 #include "vp8/common/onyxc_int.h"
15 #include "vp8/common/systemdependent.h"
17 #include "vp8/common/alloccommon.h"
19 #include "firstpass.h"
21 #include "vpx_scale/vpxscale.h"
22 #include "vp8/common/extend.h"
24 #include "vp8/common/quant_common.h"
25 #include "segmentation.h"
26 #include "vpx_scale/yv12extend.h"
28 #include "vp8/common/postproc.h"
30 #include "vpx_mem/vpx_mem.h"
31 #include "vp8/common/swapyv12buffer.h"
32 #include "vp8/common/threading.h"
33 #include "vpx_ports/vpx_timer.h"
35 #include "vpx_ports/arm.h"
37 #if CONFIG_MULTI_RES_ENCODING
38 #include "mr_dissim.h"
45 #if CONFIG_REALTIME_ONLY & CONFIG_ONTHEFLY_BITPACKING
46 extern int vp8_update_coef_context(VP8_COMP *cpi);
47 extern void vp8_update_coef_probs(VP8_COMP *cpi);
50 extern void vp8cx_pick_filter_level_fast(YV12_BUFFER_CONFIG *sd, VP8_COMP *cpi);
51 extern void vp8cx_set_alt_lf_level(VP8_COMP *cpi, int filt_val);
52 extern void vp8cx_pick_filter_level(YV12_BUFFER_CONFIG *sd, VP8_COMP *cpi);
54 extern void vp8_deblock_frame(YV12_BUFFER_CONFIG *source, YV12_BUFFER_CONFIG *post, int filt_lvl, int low_var_thresh, int flag);
55 extern void print_parms(VP8_CONFIG *ocf, char *filenam);
56 extern unsigned int vp8_get_processor_freq();
57 extern void print_tree_update_probs();
58 extern void vp8cx_create_encoder_threads(VP8_COMP *cpi);
59 extern void vp8cx_remove_encoder_threads(VP8_COMP *cpi);
61 extern void vp8_yv12_copy_frame_func_neon(YV12_BUFFER_CONFIG *src_ybc, YV12_BUFFER_CONFIG *dst_ybc);
62 extern void vp8_yv12_copy_src_frame_func_neon(YV12_BUFFER_CONFIG *src_ybc, YV12_BUFFER_CONFIG *dst_ybc);
65 int vp8_estimate_entropy_savings(VP8_COMP *cpi);
67 int vp8_calc_ss_err(YV12_BUFFER_CONFIG *source, YV12_BUFFER_CONFIG *dest);
69 extern void vp8_temporal_filter_prepare_c(VP8_COMP *cpi, int distance);
71 static void set_default_lf_deltas(VP8_COMP *cpi);
73 extern const int vp8_gf_interval_table[101];
75 #if CONFIG_INTERNAL_STATS
78 extern double vp8_calc_ssim
80 YV12_BUFFER_CONFIG *source,
81 YV12_BUFFER_CONFIG *dest,
87 extern double vp8_calc_ssimg
89 YV12_BUFFER_CONFIG *source,
90 YV12_BUFFER_CONFIG *dest,
100 #ifdef OUTPUT_YUV_SRC
111 extern int skip_true_count;
112 extern int skip_false_count;
117 extern int intra_mode_stats[10][10][10];
121 unsigned int frames_at_speed[16] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
122 unsigned int tot_pm = 0;
123 unsigned int cnt_pm = 0;
124 unsigned int tot_ef = 0;
125 unsigned int cnt_ef = 0;
129 extern unsigned __int64 Sectionbits[50];
130 extern int y_modes[5] ;
131 extern int uv_modes[4] ;
132 extern int b_modes[10] ;
134 extern int inter_y_modes[10] ;
135 extern int inter_uv_modes[4] ;
136 extern unsigned int inter_b_modes[15];
139 extern const int vp8_bits_per_mb[2][QINDEX_RANGE];
141 extern const int qrounding_factors[129];
142 extern const int qzbin_factors[129];
143 extern void vp8cx_init_quantizer(VP8_COMP *cpi);
144 extern const int vp8cx_base_skip_false_prob[128];
146 // Tables relating active max Q to active min Q
147 static const unsigned char kf_low_motion_minq[QINDEX_RANGE] =
149 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
150 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
151 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
152 0,0,0,0,1,1,1,1,1,1,1,1,2,2,2,2,
153 3,3,3,3,3,3,4,4,4,5,5,5,5,5,6,6,
154 6,6,7,7,8,8,8,8,9,9,10,10,10,10,11,11,
155 11,11,12,12,13,13,13,13,14,14,15,15,15,15,16,16,
156 16,16,17,17,18,18,18,18,19,20,20,21,21,22,23,23
158 static const unsigned char kf_high_motion_minq[QINDEX_RANGE] =
160 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
161 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
162 1,1,1,1,1,1,1,1,2,2,2,2,3,3,3,3,
163 3,3,3,3,4,4,4,4,5,5,5,5,5,5,6,6,
164 6,6,7,7,8,8,8,8,9,9,10,10,10,10,11,11,
165 11,11,12,12,13,13,13,13,14,14,15,15,15,15,16,16,
166 16,16,17,17,18,18,18,18,19,19,20,20,20,20,21,21,
167 21,21,22,22,23,23,24,25,25,26,26,27,28,28,29,30
169 static const unsigned char gf_low_motion_minq[QINDEX_RANGE] =
171 0,0,0,0,1,1,1,1,1,1,1,1,2,2,2,2,
172 3,3,3,3,4,4,4,4,5,5,5,5,6,6,6,6,
173 7,7,7,7,8,8,8,8,9,9,9,9,10,10,10,10,
174 11,11,12,12,13,13,14,14,15,15,16,16,17,17,18,18,
175 19,19,20,20,21,21,22,22,23,23,24,24,25,25,26,26,
176 27,27,28,28,29,29,30,30,31,31,32,32,33,33,34,34,
177 35,35,36,36,37,37,38,38,39,39,40,40,41,41,42,42,
178 43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58
180 static const unsigned char gf_mid_motion_minq[QINDEX_RANGE] =
182 0,0,0,0,1,1,1,1,1,1,2,2,3,3,3,4,
183 4,4,5,5,5,6,6,6,7,7,7,8,8,8,9,9,
184 9,10,10,10,10,11,11,11,12,12,12,12,13,13,13,14,
185 14,14,15,15,16,16,17,17,18,18,19,19,20,20,21,21,
186 22,22,23,23,24,24,25,25,26,26,27,27,28,28,29,29,
187 30,30,31,31,32,32,33,33,34,34,35,35,36,36,37,37,
188 38,39,39,40,40,41,41,42,42,43,43,44,45,46,47,48,
189 49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64
191 static const unsigned char gf_high_motion_minq[QINDEX_RANGE] =
193 0,0,0,0,1,1,1,1,1,2,2,2,3,3,3,4,
194 4,4,5,5,5,6,6,6,7,7,7,8,8,8,9,9,
195 9,10,10,10,11,11,12,12,13,13,14,14,15,15,16,16,
196 17,17,18,18,19,19,20,20,21,21,22,22,23,23,24,24,
197 25,25,26,26,27,27,28,28,29,29,30,30,31,31,32,32,
198 33,33,34,34,35,35,36,36,37,37,38,38,39,39,40,40,
199 41,41,42,42,43,44,45,46,47,48,49,50,51,52,53,54,
200 55,56,57,58,59,60,62,64,66,68,70,72,74,76,78,80
202 static const unsigned char inter_minq[QINDEX_RANGE] =
204 0,0,1,1,2,3,3,4,4,5,6,6,7,8,8,9,
205 9,10,11,11,12,13,13,14,15,15,16,17,17,18,19,20,
206 20,21,22,22,23,24,24,25,26,27,27,28,29,30,30,31,
207 32,33,33,34,35,36,36,37,38,39,39,40,41,42,42,43,
208 44,45,46,46,47,48,49,50,50,51,52,53,54,55,55,56,
209 57,58,59,60,60,61,62,63,64,65,66,67,67,68,69,70,
210 71,72,73,74,75,75,76,77,78,79,80,81,82,83,84,85,
211 86,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100
214 void vp8_initialize()
216 static int init_done = 0;
220 vp8_scale_machine_specific_config();
221 vp8_initialize_common();
222 vp8_tokenize_initialize();
227 #ifdef PACKET_TESTING
228 extern FILE *vpxlogc;
231 static void save_layer_context(VP8_COMP *cpi)
233 LAYER_CONTEXT *lc = &cpi->layer_context[cpi->current_layer];
235 // Save layer dependent coding state
236 lc->target_bandwidth = cpi->target_bandwidth;
237 //lc->target_bandwidth = cpi->oxcf.target_bandwidth;
238 lc->starting_buffer_level = cpi->oxcf.starting_buffer_level;
239 lc->optimal_buffer_level = cpi->oxcf.optimal_buffer_level;
240 lc->maximum_buffer_size = cpi->oxcf.maximum_buffer_size;
241 lc->starting_buffer_level_in_ms = cpi->oxcf.starting_buffer_level_in_ms;
242 lc->optimal_buffer_level_in_ms = cpi->oxcf.optimal_buffer_level_in_ms;
243 lc->maximum_buffer_size_in_ms = cpi->oxcf.maximum_buffer_size_in_ms;
244 lc->buffer_level = cpi->buffer_level;
245 lc->bits_off_target = cpi->bits_off_target;
246 lc->total_actual_bits = cpi->total_actual_bits;
247 lc->worst_quality = cpi->worst_quality;
248 lc->active_worst_quality = cpi->active_worst_quality;
249 lc->best_quality = cpi->best_quality;
250 lc->active_best_quality = cpi->active_best_quality;
251 lc->ni_av_qi = cpi->ni_av_qi;
252 lc->ni_tot_qi = cpi->ni_tot_qi;
253 lc->ni_frames = cpi->ni_frames;
254 lc->avg_frame_qindex = cpi->avg_frame_qindex;
255 lc->rate_correction_factor = cpi->rate_correction_factor;
256 lc->key_frame_rate_correction_factor = cpi->key_frame_rate_correction_factor;
257 lc->gf_rate_correction_factor = cpi->gf_rate_correction_factor;
258 lc->zbin_over_quant = cpi->zbin_over_quant;
259 lc->inter_frame_target = cpi->inter_frame_target;
260 lc->total_byte_count = cpi->total_byte_count;
261 lc->filter_level = cpi->common.filter_level;
263 lc->last_frame_percent_intra = cpi->last_frame_percent_intra;
265 memcpy (lc->count_mb_ref_frame_usage,
266 cpi->count_mb_ref_frame_usage,
267 sizeof(cpi->count_mb_ref_frame_usage));
270 static void restore_layer_context(VP8_COMP *cpi, const int layer)
272 LAYER_CONTEXT *lc = &cpi->layer_context[layer];
274 // Restore layer dependent coding state
275 cpi->current_layer = layer;
276 cpi->target_bandwidth = lc->target_bandwidth;
277 cpi->oxcf.target_bandwidth = lc->target_bandwidth;
278 cpi->oxcf.starting_buffer_level = lc->starting_buffer_level;
279 cpi->oxcf.optimal_buffer_level = lc->optimal_buffer_level;
280 cpi->oxcf.maximum_buffer_size = lc->maximum_buffer_size;
281 cpi->oxcf.starting_buffer_level_in_ms = lc->starting_buffer_level_in_ms;
282 cpi->oxcf.optimal_buffer_level_in_ms = lc->optimal_buffer_level_in_ms;
283 cpi->oxcf.maximum_buffer_size_in_ms = lc->maximum_buffer_size_in_ms;
284 cpi->buffer_level = lc->buffer_level;
285 cpi->bits_off_target = lc->bits_off_target;
286 cpi->total_actual_bits = lc->total_actual_bits;
287 //cpi->worst_quality = lc->worst_quality;
288 cpi->active_worst_quality = lc->active_worst_quality;
289 //cpi->best_quality = lc->best_quality;
290 cpi->active_best_quality = lc->active_best_quality;
291 cpi->ni_av_qi = lc->ni_av_qi;
292 cpi->ni_tot_qi = lc->ni_tot_qi;
293 cpi->ni_frames = lc->ni_frames;
294 cpi->avg_frame_qindex = lc->avg_frame_qindex;
295 cpi->rate_correction_factor = lc->rate_correction_factor;
296 cpi->key_frame_rate_correction_factor = lc->key_frame_rate_correction_factor;
297 cpi->gf_rate_correction_factor = lc->gf_rate_correction_factor;
298 cpi->zbin_over_quant = lc->zbin_over_quant;
299 cpi->inter_frame_target = lc->inter_frame_target;
300 cpi->total_byte_count = lc->total_byte_count;
301 cpi->common.filter_level = lc->filter_level;
303 cpi->last_frame_percent_intra = lc->last_frame_percent_intra;
305 memcpy (cpi->count_mb_ref_frame_usage,
306 lc->count_mb_ref_frame_usage,
307 sizeof(cpi->count_mb_ref_frame_usage));
310 static void setup_features(VP8_COMP *cpi)
312 // Set up default state for MB feature flags
313 cpi->mb.e_mbd.segmentation_enabled = 0;
314 cpi->mb.e_mbd.update_mb_segmentation_map = 0;
315 cpi->mb.e_mbd.update_mb_segmentation_data = 0;
316 vpx_memset(cpi->mb.e_mbd.mb_segment_tree_probs, 255, sizeof(cpi->mb.e_mbd.mb_segment_tree_probs));
317 vpx_memset(cpi->mb.e_mbd.segment_feature_data, 0, sizeof(cpi->mb.e_mbd.segment_feature_data));
319 cpi->mb.e_mbd.mode_ref_lf_delta_enabled = 0;
320 cpi->mb.e_mbd.mode_ref_lf_delta_update = 0;
321 vpx_memset(cpi->mb.e_mbd.ref_lf_deltas, 0, sizeof(cpi->mb.e_mbd.ref_lf_deltas));
322 vpx_memset(cpi->mb.e_mbd.mode_lf_deltas, 0, sizeof(cpi->mb.e_mbd.mode_lf_deltas));
323 vpx_memset(cpi->mb.e_mbd.last_ref_lf_deltas, 0, sizeof(cpi->mb.e_mbd.ref_lf_deltas));
324 vpx_memset(cpi->mb.e_mbd.last_mode_lf_deltas, 0, sizeof(cpi->mb.e_mbd.mode_lf_deltas));
326 set_default_lf_deltas(cpi);
331 static void dealloc_raw_frame_buffers(VP8_COMP *cpi);
334 static void dealloc_compressor_data(VP8_COMP *cpi)
336 vpx_free(cpi->tplist);
339 // Delete last frame MV storage buffers
343 vpx_free(cpi->lf_ref_frame_sign_bias);
344 cpi->lf_ref_frame_sign_bias = 0;
346 vpx_free(cpi->lf_ref_frame);
347 cpi->lf_ref_frame = 0;
349 // Delete sementation map
350 vpx_free(cpi->segmentation_map);
351 cpi->segmentation_map = 0;
353 vpx_free(cpi->active_map);
356 vp8_de_alloc_frame_buffers(&cpi->common);
358 vp8_yv12_de_alloc_frame_buffer(&cpi->pick_lf_lvl_frame);
359 vp8_yv12_de_alloc_frame_buffer(&cpi->scaled_source);
360 dealloc_raw_frame_buffers(cpi);
365 // Structure used to monitor GF usage
366 vpx_free(cpi->gf_active_flags);
367 cpi->gf_active_flags = 0;
369 // Activity mask based per mb zbin adjustments
370 vpx_free(cpi->mb_activity_map);
371 cpi->mb_activity_map = 0;
372 vpx_free(cpi->mb_norm_activity_map);
373 cpi->mb_norm_activity_map = 0;
375 vpx_free(cpi->mb.pip);
379 static void enable_segmentation(VP8_COMP *cpi)
381 // Set the appropriate feature bit
382 cpi->mb.e_mbd.segmentation_enabled = 1;
383 cpi->mb.e_mbd.update_mb_segmentation_map = 1;
384 cpi->mb.e_mbd.update_mb_segmentation_data = 1;
386 static void disable_segmentation(VP8_COMP *cpi)
388 // Clear the appropriate feature bit
389 cpi->mb.e_mbd.segmentation_enabled = 0;
392 // Valid values for a segment are 0 to 3
393 // Segmentation map is arrange as [Rows][Columns]
394 static void set_segmentation_map(VP8_COMP *cpi, unsigned char *segmentation_map)
396 // Copy in the new segmentation map
397 vpx_memcpy(cpi->segmentation_map, segmentation_map, (cpi->common.mb_rows * cpi->common.mb_cols));
399 // Signal that the map should be updated.
400 cpi->mb.e_mbd.update_mb_segmentation_map = 1;
401 cpi->mb.e_mbd.update_mb_segmentation_data = 1;
404 // The values given for each segment can be either deltas (from the default value chosen for the frame) or absolute values.
406 // Valid range for abs values is (0-127 for MB_LVL_ALT_Q) , (0-63 for SEGMENT_ALT_LF)
407 // Valid range for delta values are (+/-127 for MB_LVL_ALT_Q) , (+/-63 for SEGMENT_ALT_LF)
409 // abs_delta = SEGMENT_DELTADATA (deltas) abs_delta = SEGMENT_ABSDATA (use the absolute values given).
412 static void set_segment_data(VP8_COMP *cpi, signed char *feature_data, unsigned char abs_delta)
414 cpi->mb.e_mbd.mb_segement_abs_delta = abs_delta;
415 vpx_memcpy(cpi->segment_feature_data, feature_data, sizeof(cpi->segment_feature_data));
419 static void segmentation_test_function(VP8_COMP *cpi)
421 unsigned char *seg_map;
422 signed char feature_data[MB_LVL_MAX][MAX_MB_SEGMENTS];
424 // Create a temporary map for segmentation data.
425 CHECK_MEM_ERROR(seg_map, vpx_calloc(cpi->common.mb_rows * cpi->common.mb_cols, 1));
427 // MB loop to set local segmentation map
428 /*for ( i = 0; i < cpi->common.mb_rows; i++ )
430 for ( j = 0; j < cpi->common.mb_cols; j++ )
432 //seg_map[(i*cpi->common.mb_cols) + j] = (j % 2) + ((i%2)* 2);
433 //if ( j < cpi->common.mb_cols/2 )
435 // Segment 1 around the edge else 0
436 if ( (i == 0) || (j == 0) || (i == (cpi->common.mb_rows-1)) || (j == (cpi->common.mb_cols-1)) )
437 seg_map[(i*cpi->common.mb_cols) + j] = 1;
438 //else if ( (i < 2) || (j < 2) || (i > (cpi->common.mb_rows-3)) || (j > (cpi->common.mb_cols-3)) )
439 // seg_map[(i*cpi->common.mb_cols) + j] = 2;
440 //else if ( (i < 5) || (j < 5) || (i > (cpi->common.mb_rows-6)) || (j > (cpi->common.mb_cols-6)) )
441 // seg_map[(i*cpi->common.mb_cols) + j] = 3;
443 seg_map[(i*cpi->common.mb_cols) + j] = 0;
447 // Set the segmentation Map
448 set_segmentation_map(cpi, seg_map);
450 // Activate segmentation.
451 enable_segmentation(cpi);
453 // Set up the quant segment data
454 feature_data[MB_LVL_ALT_Q][0] = 0;
455 feature_data[MB_LVL_ALT_Q][1] = 4;
456 feature_data[MB_LVL_ALT_Q][2] = 0;
457 feature_data[MB_LVL_ALT_Q][3] = 0;
458 // Set up the loop segment data
459 feature_data[MB_LVL_ALT_LF][0] = 0;
460 feature_data[MB_LVL_ALT_LF][1] = 0;
461 feature_data[MB_LVL_ALT_LF][2] = 0;
462 feature_data[MB_LVL_ALT_LF][3] = 0;
464 // Initialise the feature data structure
465 // SEGMENT_DELTADATA 0, SEGMENT_ABSDATA 1
466 set_segment_data(cpi, &feature_data[0][0], SEGMENT_DELTADATA);
468 // Delete sementation map
475 // A simple function to cyclically refresh the background at a lower Q
476 static void cyclic_background_refresh(VP8_COMP *cpi, int Q, int lf_adjustment)
478 unsigned char *seg_map;
479 signed char feature_data[MB_LVL_MAX][MAX_MB_SEGMENTS];
481 int block_count = cpi->cyclic_refresh_mode_max_mbs_perframe;
482 int mbs_in_frame = cpi->common.mb_rows * cpi->common.mb_cols;
484 // Create a temporary map for segmentation data.
485 CHECK_MEM_ERROR(seg_map, vpx_calloc(cpi->common.mb_rows * cpi->common.mb_cols, 1));
487 cpi->cyclic_refresh_q = Q;
489 for (i = Q; i > 0; i--)
491 if (vp8_bits_per_mb[cpi->common.frame_type][i] >= ((vp8_bits_per_mb[cpi->common.frame_type][Q]*(Q + 128)) / 64))
492 //if ( vp8_bits_per_mb[cpi->common.frame_type][i] >= ((vp8_bits_per_mb[cpi->common.frame_type][Q]*((2*Q)+96))/64) )
498 cpi->cyclic_refresh_q = i;
500 // Only update for inter frames
501 if (cpi->common.frame_type != KEY_FRAME)
503 // Cycle through the macro_block rows
504 // MB loop to set local segmentation map
505 for (i = cpi->cyclic_refresh_mode_index; i < mbs_in_frame; i++)
507 // If the MB is as a candidate for clean up then mark it for possible boost/refresh (segment 1)
508 // The segment id may get reset to 0 later if the MB gets coded anything other than last frame 0,0
509 // as only (last frame 0,0) MBs are eligable for refresh : that is to say Mbs likely to be background blocks.
510 if (cpi->cyclic_refresh_map[i] == 0)
518 // Skip blocks that have been refreshed recently anyway.
519 if (cpi->cyclic_refresh_map[i] < 0)
520 //cpi->cyclic_refresh_map[i] = cpi->cyclic_refresh_map[i] / 16;
521 cpi->cyclic_refresh_map[i]++;
532 // If we have gone through the frame reset to the start
533 cpi->cyclic_refresh_mode_index = i;
535 if (cpi->cyclic_refresh_mode_index >= mbs_in_frame)
536 cpi->cyclic_refresh_mode_index = 0;
539 // Set the segmentation Map
540 set_segmentation_map(cpi, seg_map);
542 // Activate segmentation.
543 enable_segmentation(cpi);
545 // Set up the quant segment data
546 feature_data[MB_LVL_ALT_Q][0] = 0;
547 feature_data[MB_LVL_ALT_Q][1] = (cpi->cyclic_refresh_q - Q);
548 feature_data[MB_LVL_ALT_Q][2] = 0;
549 feature_data[MB_LVL_ALT_Q][3] = 0;
551 // Set up the loop segment data
552 feature_data[MB_LVL_ALT_LF][0] = 0;
553 feature_data[MB_LVL_ALT_LF][1] = lf_adjustment;
554 feature_data[MB_LVL_ALT_LF][2] = 0;
555 feature_data[MB_LVL_ALT_LF][3] = 0;
557 // Initialise the feature data structure
558 // SEGMENT_DELTADATA 0, SEGMENT_ABSDATA 1
559 set_segment_data(cpi, &feature_data[0][0], SEGMENT_DELTADATA);
561 // Delete sementation map
568 static void set_default_lf_deltas(VP8_COMP *cpi)
570 cpi->mb.e_mbd.mode_ref_lf_delta_enabled = 1;
571 cpi->mb.e_mbd.mode_ref_lf_delta_update = 1;
573 vpx_memset(cpi->mb.e_mbd.ref_lf_deltas, 0, sizeof(cpi->mb.e_mbd.ref_lf_deltas));
574 vpx_memset(cpi->mb.e_mbd.mode_lf_deltas, 0, sizeof(cpi->mb.e_mbd.mode_lf_deltas));
576 // Test of ref frame deltas
577 cpi->mb.e_mbd.ref_lf_deltas[INTRA_FRAME] = 2;
578 cpi->mb.e_mbd.ref_lf_deltas[LAST_FRAME] = 0;
579 cpi->mb.e_mbd.ref_lf_deltas[GOLDEN_FRAME] = -2;
580 cpi->mb.e_mbd.ref_lf_deltas[ALTREF_FRAME] = -2;
582 cpi->mb.e_mbd.mode_lf_deltas[0] = 4; // BPRED
583 cpi->mb.e_mbd.mode_lf_deltas[1] = -2; // Zero
584 cpi->mb.e_mbd.mode_lf_deltas[2] = 2; // New mv
585 cpi->mb.e_mbd.mode_lf_deltas[3] = 4; // Split mv
588 /* Convenience macros for mapping speed and mode into a continuous
591 #define GOOD(x) (x+1)
594 static int speed_map(int speed, int *map)
601 } while(speed >= *map++);
605 static int thresh_mult_map_znn[] = {
606 /* map common to zero, nearest, and near */
607 0, GOOD(2), 1500, GOOD(3), 2000, RT(0), 1000, RT(2), 2000, INT_MAX
610 static int thresh_mult_map_vhpred[] = {
611 1000, GOOD(2), 1500, GOOD(3), 2000, RT(0), 1000, RT(1), 2000,
612 RT(7), INT_MAX, INT_MAX
615 static int thresh_mult_map_bpred[] = {
616 2000, GOOD(0), 2500, GOOD(2), 5000, GOOD(3), 7500, RT(0), 2500, RT(1), 5000,
617 RT(6), INT_MAX, INT_MAX
620 static int thresh_mult_map_tm[] = {
621 1000, GOOD(2), 1500, GOOD(3), 2000, RT(0), 0, RT(1), 1000, RT(2), 2000,
622 RT(7), INT_MAX, INT_MAX
625 static int thresh_mult_map_new1[] = {
626 1000, GOOD(2), 2000, RT(0), 2000, INT_MAX
629 static int thresh_mult_map_new2[] = {
630 1000, GOOD(2), 2000, GOOD(3), 2500, GOOD(5), 4000, RT(0), 2000, RT(2), 2500,
634 static int thresh_mult_map_split1[] = {
635 2500, GOOD(0), 1700, GOOD(2), 10000, GOOD(3), 25000, GOOD(4), INT_MAX,
636 RT(0), 5000, RT(1), 10000, RT(2), 25000, RT(3), INT_MAX, INT_MAX
639 static int thresh_mult_map_split2[] = {
640 5000, GOOD(0), 4500, GOOD(2), 20000, GOOD(3), 50000, GOOD(4), INT_MAX,
641 RT(0), 10000, RT(1), 20000, RT(2), 50000, RT(3), INT_MAX, INT_MAX
644 static int mode_check_freq_map_zn2[] = {
645 /* {zero,nearest}{2,3} */
646 0, RT(10), 1<<1, RT(11), 1<<2, RT(12), 1<<3, INT_MAX
649 static int mode_check_freq_map_vhbpred[] = {
650 0, GOOD(5), 2, RT(0), 0, RT(3), 2, RT(5), 4, INT_MAX
653 static int mode_check_freq_map_near2[] = {
654 0, GOOD(5), 2, RT(0), 0, RT(3), 2, RT(10), 1<<2, RT(11), 1<<3, RT(12), 1<<4,
658 static int mode_check_freq_map_new1[] = {
659 0, RT(10), 1<<1, RT(11), 1<<2, RT(12), 1<<3, INT_MAX
662 static int mode_check_freq_map_new2[] = {
663 0, GOOD(5), 4, RT(0), 0, RT(3), 4, RT(10), 1<<3, RT(11), 1<<4, RT(12), 1<<5,
667 static int mode_check_freq_map_split1[] = {
668 0, GOOD(2), 2, GOOD(3), 7, RT(1), 2, RT(2), 7, INT_MAX
671 static int mode_check_freq_map_split2[] = {
672 0, GOOD(1), 2, GOOD(2), 4, GOOD(3), 15, RT(1), 4, RT(2), 15, INT_MAX
675 void vp8_set_speed_features(VP8_COMP *cpi)
677 SPEED_FEATURES *sf = &cpi->sf;
678 int Mode = cpi->compressor_speed;
679 int Speed = cpi->Speed;
681 VP8_COMMON *cm = &cpi->common;
682 int last_improved_quant = sf->improved_quant;
685 // Initialise default mode frequency sampling variables
686 for (i = 0; i < MAX_MODES; i ++)
688 cpi->mode_check_freq[i] = 0;
689 cpi->mode_test_hit_counts[i] = 0;
690 cpi->mode_chosen_counts[i] = 0;
693 cpi->mbs_tested_so_far = 0;
695 // best quality defaults
697 sf->search_method = NSTEP;
698 sf->improved_quant = 1;
699 sf->improved_dct = 1;
702 sf->quarter_pixel_search = 1;
703 sf->half_pixel_search = 1;
704 sf->iterative_sub_pixel = 1;
705 sf->optimize_coefficients = 1;
706 sf->use_fastquant_for_pick = 0;
707 sf->no_skip_block4x4_search = 1;
710 sf->max_step_search_steps = MAX_MVSEARCH_STEPS;
711 sf->improved_mv_pred = 1;
713 // default thresholds to 0
714 for (i = 0; i < MAX_MODES; i++)
715 sf->thresh_mult[i] = 0;
717 /* Count enabled references */
719 if (cpi->ref_frame_flags & VP8_LAST_FLAG)
721 if (cpi->ref_frame_flags & VP8_GOLD_FLAG)
723 if (cpi->ref_frame_flags & VP8_ALT_FLAG)
726 /* Convert speed to continuous range, with clamping */
738 sf->thresh_mult[THR_ZERO1] =
739 sf->thresh_mult[THR_NEAREST1] =
740 sf->thresh_mult[THR_NEAR1] =
741 sf->thresh_mult[THR_DC] = 0; /* always */
743 sf->thresh_mult[THR_ZERO2] =
744 sf->thresh_mult[THR_ZERO3] =
745 sf->thresh_mult[THR_NEAREST2] =
746 sf->thresh_mult[THR_NEAREST3] =
747 sf->thresh_mult[THR_NEAR2] =
748 sf->thresh_mult[THR_NEAR3] = speed_map(Speed, thresh_mult_map_znn);
750 sf->thresh_mult[THR_V_PRED] =
751 sf->thresh_mult[THR_H_PRED] = speed_map(Speed, thresh_mult_map_vhpred);
752 sf->thresh_mult[THR_B_PRED] = speed_map(Speed, thresh_mult_map_bpred);
753 sf->thresh_mult[THR_TM] = speed_map(Speed, thresh_mult_map_tm);
754 sf->thresh_mult[THR_NEW1] = speed_map(Speed, thresh_mult_map_new1);
755 sf->thresh_mult[THR_NEW2] =
756 sf->thresh_mult[THR_NEW3] = speed_map(Speed, thresh_mult_map_new2);
757 sf->thresh_mult[THR_SPLIT1] = speed_map(Speed, thresh_mult_map_split1);
758 sf->thresh_mult[THR_SPLIT2] =
759 sf->thresh_mult[THR_SPLIT3] = speed_map(Speed, thresh_mult_map_split2);
761 cpi->mode_check_freq[THR_ZERO1] =
762 cpi->mode_check_freq[THR_NEAREST1] =
763 cpi->mode_check_freq[THR_NEAR1] =
764 cpi->mode_check_freq[THR_TM] =
765 cpi->mode_check_freq[THR_DC] = 0; /* always */
767 cpi->mode_check_freq[THR_ZERO2] =
768 cpi->mode_check_freq[THR_ZERO3] =
769 cpi->mode_check_freq[THR_NEAREST2] =
770 cpi->mode_check_freq[THR_NEAREST3] = speed_map(Speed,
771 mode_check_freq_map_zn2);
773 cpi->mode_check_freq[THR_NEAR2] =
774 cpi->mode_check_freq[THR_NEAR3] = speed_map(Speed,
775 mode_check_freq_map_near2);
777 cpi->mode_check_freq[THR_V_PRED] =
778 cpi->mode_check_freq[THR_H_PRED] =
779 cpi->mode_check_freq[THR_B_PRED] = speed_map(Speed,
780 mode_check_freq_map_vhbpred);
781 cpi->mode_check_freq[THR_NEW1] = speed_map(Speed,
782 mode_check_freq_map_new1);
783 cpi->mode_check_freq[THR_NEW2] =
784 cpi->mode_check_freq[THR_NEW3] = speed_map(Speed,
785 mode_check_freq_map_new2);
786 cpi->mode_check_freq[THR_SPLIT1] = speed_map(Speed,
787 mode_check_freq_map_split1);
788 cpi->mode_check_freq[THR_SPLIT2] =
789 cpi->mode_check_freq[THR_SPLIT3] = speed_map(Speed,
790 mode_check_freq_map_split2);
794 #if !(CONFIG_REALTIME_ONLY)
795 case 0: // best quality mode
797 sf->max_step_search_steps = MAX_MVSEARCH_STEPS;
803 /* Disable coefficient optimization above speed 0 */
804 sf->optimize_coefficients = 0;
805 sf->use_fastquant_for_pick = 1;
806 sf->no_skip_block4x4_search = 0;
813 sf->improved_quant = 0;
814 sf->improved_dct = 0;
816 // Only do recode loop on key frames, golden frames and
825 sf->recode_loop = 0; // recode loop off
826 sf->RD = 0; // Turn rd off
832 sf->auto_filter = 0; // Faster selection of loop filter
838 sf->optimize_coefficients = 0;
841 sf->iterative_sub_pixel = 1;
842 sf->search_method = NSTEP;
846 sf->improved_quant = 0;
847 sf->improved_dct = 0;
849 sf->use_fastquant_for_pick = 1;
850 sf->no_skip_block4x4_search = 0;
855 sf->auto_filter = 0; // Faster selection of loop filter
865 sf->auto_filter = 0; // Faster selection of loop filter
866 sf->search_method = HEX;
867 sf->iterative_sub_pixel = 0;
872 unsigned int sum = 0;
873 unsigned int total_mbs = cm->MBs;
875 unsigned int total_skip;
879 if (cpi->oxcf.encode_breakout > 2000)
880 min = cpi->oxcf.encode_breakout;
884 for (i = 0; i < min; i++)
886 sum += cpi->error_bins[i];
892 // i starts from 2 to make sure thresh started from 2048
893 for (; i < 1024; i++)
895 sum += cpi->error_bins[i];
897 if (10 * sum >= (unsigned int)(cpi->Speed - 6)*(total_mbs - total_skip))
909 sf->thresh_mult[THR_NEW1 ] = thresh;
910 sf->thresh_mult[THR_NEAREST1 ] = thresh >> 1;
911 sf->thresh_mult[THR_NEAR1 ] = thresh >> 1;
916 sf->thresh_mult[THR_NEW2] = thresh << 1;
917 sf->thresh_mult[THR_NEAREST2 ] = thresh;
918 sf->thresh_mult[THR_NEAR2 ] = thresh;
923 sf->thresh_mult[THR_NEW3] = thresh << 1;
924 sf->thresh_mult[THR_NEAREST3 ] = thresh;
925 sf->thresh_mult[THR_NEAR3 ] = thresh;
928 sf->improved_mv_pred = 0;
932 sf->quarter_pixel_search = 0;
936 cm->filter_type = NORMAL_LOOPFILTER;
939 cm->filter_type = SIMPLE_LOOPFILTER;
943 cm->filter_type = SIMPLE_LOOPFILTER;
946 // This has a big hit on quality. Last resort
948 sf->half_pixel_search = 0;
950 vpx_memset(cpi->error_bins, 0, sizeof(cpi->error_bins));
954 // Slow quant, dct and trellis not worthwhile for first pass
955 // so make sure they are always turned off.
956 if ( cpi->pass == 1 )
958 sf->improved_quant = 0;
959 sf->optimize_coefficients = 0;
960 sf->improved_dct = 0;
963 if (cpi->sf.search_method == NSTEP)
965 vp8_init3smotion_compensation(&cpi->mb, cm->yv12_fb[cm->lst_fb_idx].y_stride);
967 else if (cpi->sf.search_method == DIAMOND)
969 vp8_init_dsmotion_compensation(&cpi->mb, cm->yv12_fb[cm->lst_fb_idx].y_stride);
972 if (cpi->sf.improved_dct)
974 cpi->mb.short_fdct8x4 = vp8_short_fdct8x4;
975 cpi->mb.short_fdct4x4 = vp8_short_fdct4x4;
979 /* No fast FDCT defined for any platform at this time. */
980 cpi->mb.short_fdct8x4 = vp8_short_fdct8x4;
981 cpi->mb.short_fdct4x4 = vp8_short_fdct4x4;
984 cpi->mb.short_walsh4x4 = vp8_short_walsh4x4;
986 if (cpi->sf.improved_quant)
988 cpi->mb.quantize_b = vp8_regular_quantize_b;
989 cpi->mb.quantize_b_pair = vp8_regular_quantize_b_pair;
993 cpi->mb.quantize_b = vp8_fast_quantize_b;
994 cpi->mb.quantize_b_pair = vp8_fast_quantize_b_pair;
996 if (cpi->sf.improved_quant != last_improved_quant)
997 vp8cx_init_quantizer(cpi);
999 if (cpi->sf.iterative_sub_pixel == 1)
1001 cpi->find_fractional_mv_step = vp8_find_best_sub_pixel_step_iteratively;
1003 else if (cpi->sf.quarter_pixel_search)
1005 cpi->find_fractional_mv_step = vp8_find_best_sub_pixel_step;
1007 else if (cpi->sf.half_pixel_search)
1009 cpi->find_fractional_mv_step = vp8_find_best_half_pixel_step;
1013 cpi->find_fractional_mv_step = vp8_skip_fractional_mv_step;
1016 if (cpi->sf.optimize_coefficients == 1 && cpi->pass!=1)
1017 cpi->mb.optimize = 1;
1019 cpi->mb.optimize = 0;
1021 if (cpi->common.full_pixel)
1022 cpi->find_fractional_mv_step = vp8_skip_fractional_mv_step;
1025 frames_at_speed[cpi->Speed]++;
1031 static void alloc_raw_frame_buffers(VP8_COMP *cpi)
1033 #if VP8_TEMPORAL_ALT_REF
1034 int width = (cpi->oxcf.Width + 15) & ~15;
1035 int height = (cpi->oxcf.Height + 15) & ~15;
1038 cpi->lookahead = vp8_lookahead_init(cpi->oxcf.Width, cpi->oxcf.Height,
1039 cpi->oxcf.lag_in_frames);
1041 vpx_internal_error(&cpi->common.error, VPX_CODEC_MEM_ERROR,
1042 "Failed to allocate lag buffers");
1044 #if VP8_TEMPORAL_ALT_REF
1046 if (vp8_yv12_alloc_frame_buffer(&cpi->alt_ref_buffer,
1047 width, height, VP8BORDERINPIXELS))
1048 vpx_internal_error(&cpi->common.error, VPX_CODEC_MEM_ERROR,
1049 "Failed to allocate altref buffer");
1055 static void dealloc_raw_frame_buffers(VP8_COMP *cpi)
1057 #if VP8_TEMPORAL_ALT_REF
1058 vp8_yv12_de_alloc_frame_buffer(&cpi->alt_ref_buffer);
1060 vp8_lookahead_destroy(cpi->lookahead);
1064 static int vp8_alloc_partition_data(VP8_COMP *cpi)
1066 vpx_free(cpi->mb.pip);
1068 cpi->mb.pip = vpx_calloc((cpi->common.mb_cols + 1) *
1069 (cpi->common.mb_rows + 1),
1070 sizeof(PARTITION_INFO));
1074 cpi->mb.pi = cpi->mb.pip + cpi->common.mode_info_stride + 1;
1079 void vp8_alloc_compressor_data(VP8_COMP *cpi)
1081 VP8_COMMON *cm = & cpi->common;
1083 int width = cm->Width;
1084 int height = cm->Height;
1086 if (vp8_alloc_frame_buffers(cm, width, height))
1087 vpx_internal_error(&cpi->common.error, VPX_CODEC_MEM_ERROR,
1088 "Failed to allocate frame buffers");
1090 if (vp8_alloc_partition_data(cpi))
1091 vpx_internal_error(&cpi->common.error, VPX_CODEC_MEM_ERROR,
1092 "Failed to allocate partition data");
1095 if ((width & 0xf) != 0)
1096 width += 16 - (width & 0xf);
1098 if ((height & 0xf) != 0)
1099 height += 16 - (height & 0xf);
1102 if (vp8_yv12_alloc_frame_buffer(&cpi->pick_lf_lvl_frame,
1103 width, height, VP8BORDERINPIXELS))
1104 vpx_internal_error(&cpi->common.error, VPX_CODEC_MEM_ERROR,
1105 "Failed to allocate last frame buffer");
1107 if (vp8_yv12_alloc_frame_buffer(&cpi->scaled_source,
1108 width, height, VP8BORDERINPIXELS))
1109 vpx_internal_error(&cpi->common.error, VPX_CODEC_MEM_ERROR,
1110 "Failed to allocate scaled source buffer");
1115 #if CONFIG_REALTIME_ONLY & CONFIG_ONTHEFLY_BITPACKING
1116 unsigned int tokens = 8 * 24 * 16; /* one MB for each thread */
1118 unsigned int tokens = cm->mb_rows * cm->mb_cols * 24 * 16;
1120 CHECK_MEM_ERROR(cpi->tok, vpx_calloc(tokens, sizeof(*cpi->tok)));
1123 // Data used for real time vc mode to see if gf needs refreshing
1124 cpi->inter_zz_count = 0;
1125 cpi->gf_bad_count = 0;
1126 cpi->gf_update_recommended = 0;
1129 // Structures used to minitor GF usage
1130 vpx_free(cpi->gf_active_flags);
1131 CHECK_MEM_ERROR(cpi->gf_active_flags,
1132 vpx_calloc(1, cm->mb_rows * cm->mb_cols));
1133 cpi->gf_active_count = cm->mb_rows * cm->mb_cols;
1135 vpx_free(cpi->mb_activity_map);
1136 CHECK_MEM_ERROR(cpi->mb_activity_map,
1137 vpx_calloc(sizeof(unsigned int),
1138 cm->mb_rows * cm->mb_cols));
1140 vpx_free(cpi->mb_norm_activity_map);
1141 CHECK_MEM_ERROR(cpi->mb_norm_activity_map,
1142 vpx_calloc(sizeof(unsigned int),
1143 cm->mb_rows * cm->mb_cols));
1145 #if CONFIG_MULTITHREAD
1147 cpi->mt_sync_range = 1;
1148 else if (width <= 1280)
1149 cpi->mt_sync_range = 4;
1150 else if (width <= 2560)
1151 cpi->mt_sync_range = 8;
1153 cpi->mt_sync_range = 16;
1156 vpx_free(cpi->tplist);
1158 CHECK_MEM_ERROR(cpi->tplist, vpx_malloc(sizeof(TOKENLIST) * cpi->common.mb_rows));
1163 static const int q_trans[] =
1165 0, 1, 2, 3, 4, 5, 7, 8,
1166 9, 10, 12, 13, 15, 17, 18, 19,
1167 20, 21, 23, 24, 25, 26, 27, 28,
1168 29, 30, 31, 33, 35, 37, 39, 41,
1169 43, 45, 47, 49, 51, 53, 55, 57,
1170 59, 61, 64, 67, 70, 73, 76, 79,
1171 82, 85, 88, 91, 94, 97, 100, 103,
1172 106, 109, 112, 115, 118, 121, 124, 127,
1175 int vp8_reverse_trans(int x)
1179 for (i = 0; i < 64; i++)
1180 if (q_trans[i] >= x)
1185 void vp8_new_frame_rate(VP8_COMP *cpi, double framerate)
1190 cpi->frame_rate = framerate;
1191 cpi->output_frame_rate = framerate;
1192 cpi->per_frame_bandwidth = (int)(cpi->oxcf.target_bandwidth /
1193 cpi->output_frame_rate);
1194 cpi->av_per_frame_bandwidth = cpi->per_frame_bandwidth;
1195 cpi->min_frame_bandwidth = (int)(cpi->av_per_frame_bandwidth *
1196 cpi->oxcf.two_pass_vbrmin_section / 100);
1198 // Set Maximum gf/arf interval
1199 cpi->max_gf_interval = ((int)(cpi->output_frame_rate / 2.0) + 2);
1201 if(cpi->max_gf_interval < 12)
1202 cpi->max_gf_interval = 12;
1204 // Extended interval for genuinely static scenes
1205 cpi->twopass.static_scene_max_gf_interval = cpi->key_frame_frequency >> 1;
1207 // Special conditions when altr ref frame enabled in lagged compress mode
1208 if (cpi->oxcf.play_alternate && cpi->oxcf.lag_in_frames)
1210 if (cpi->max_gf_interval > cpi->oxcf.lag_in_frames - 1)
1211 cpi->max_gf_interval = cpi->oxcf.lag_in_frames - 1;
1213 if (cpi->twopass.static_scene_max_gf_interval > cpi->oxcf.lag_in_frames - 1)
1214 cpi->twopass.static_scene_max_gf_interval = cpi->oxcf.lag_in_frames - 1;
1217 if ( cpi->max_gf_interval > cpi->twopass.static_scene_max_gf_interval )
1218 cpi->max_gf_interval = cpi->twopass.static_scene_max_gf_interval;
1223 rescale(int val, int num, int denom)
1225 int64_t llnum = num;
1226 int64_t llden = denom;
1227 int64_t llval = val;
1229 return llval * llnum / llden;
1233 static void init_config(VP8_COMP *cpi, VP8_CONFIG *oxcf)
1235 VP8_COMMON *cm = &cpi->common;
1240 cpi->auto_adjust_gold_quantizer = 1;
1243 cm->version = oxcf->Version;
1244 vp8_setup_version(cm);
1246 /* frame rate is not available on the first frame, as it's derived from
1247 * the observed timestamps. The actual value used here doesn't matter
1248 * too much, as it will adapt quickly. If the reciprocal of the timebase
1249 * seems like a reasonable framerate, then use that as a guess, otherwise
1252 cpi->frame_rate = (double)(oxcf->timebase.den) /
1253 (double)(oxcf->timebase.num);
1255 if (cpi->frame_rate > 180)
1256 cpi->frame_rate = 30;
1258 cpi->ref_frame_rate = cpi->frame_rate;
1260 // change includes all joint functionality
1261 vp8_change_config(cpi, oxcf);
1263 // Initialize active best and worst q and average q values.
1264 cpi->active_worst_quality = cpi->oxcf.worst_allowed_q;
1265 cpi->active_best_quality = cpi->oxcf.best_allowed_q;
1266 cpi->avg_frame_qindex = cpi->oxcf.worst_allowed_q;
1268 // Initialise the starting buffer levels
1269 cpi->buffer_level = cpi->oxcf.starting_buffer_level;
1270 cpi->bits_off_target = cpi->oxcf.starting_buffer_level;
1272 cpi->rolling_target_bits = cpi->av_per_frame_bandwidth;
1273 cpi->rolling_actual_bits = cpi->av_per_frame_bandwidth;
1274 cpi->long_rolling_target_bits = cpi->av_per_frame_bandwidth;
1275 cpi->long_rolling_actual_bits = cpi->av_per_frame_bandwidth;
1277 cpi->total_actual_bits = 0;
1278 cpi->total_target_vs_actual = 0;
1280 // Temporal scalabilty
1281 if (cpi->oxcf.number_of_layers > 1)
1284 double prev_layer_frame_rate=0;
1286 for (i=0; i<cpi->oxcf.number_of_layers; i++)
1288 LAYER_CONTEXT *lc = &cpi->layer_context[i];
1290 // Layer configuration
1292 cpi->output_frame_rate / cpi->oxcf.rate_decimator[i];
1293 lc->target_bandwidth = cpi->oxcf.target_bitrate[i] * 1000;
1295 lc->starting_buffer_level_in_ms = oxcf->starting_buffer_level;
1296 lc->optimal_buffer_level_in_ms = oxcf->optimal_buffer_level;
1297 lc->maximum_buffer_size_in_ms = oxcf->maximum_buffer_size;
1299 lc->starting_buffer_level =
1300 rescale(oxcf->starting_buffer_level,
1301 lc->target_bandwidth, 1000);
1303 if (oxcf->optimal_buffer_level == 0)
1304 lc->optimal_buffer_level = lc->target_bandwidth / 8;
1306 lc->optimal_buffer_level =
1307 rescale(oxcf->optimal_buffer_level,
1308 lc->target_bandwidth, 1000);
1310 if (oxcf->maximum_buffer_size == 0)
1311 lc->maximum_buffer_size = lc->target_bandwidth / 8;
1313 lc->maximum_buffer_size =
1314 rescale(oxcf->maximum_buffer_size,
1315 lc->target_bandwidth, 1000);
1317 // Work out the average size of a frame within this layer
1319 lc->avg_frame_size_for_layer = (cpi->oxcf.target_bitrate[i] -
1320 cpi->oxcf.target_bitrate[i-1]) * 1000 /
1321 (lc->frame_rate - prev_layer_frame_rate);
1323 lc->active_worst_quality = cpi->oxcf.worst_allowed_q;
1324 lc->active_best_quality = cpi->oxcf.best_allowed_q;
1325 lc->avg_frame_qindex = cpi->oxcf.worst_allowed_q;
1327 lc->buffer_level = lc->starting_buffer_level;
1328 lc->bits_off_target = lc->starting_buffer_level;
1330 lc->total_actual_bits = 0;
1334 lc->rate_correction_factor = 1.0;
1335 lc->key_frame_rate_correction_factor = 1.0;
1336 lc->gf_rate_correction_factor = 1.0;
1337 lc->inter_frame_target = 0.0;
1339 prev_layer_frame_rate = lc->frame_rate;
1343 #if VP8_TEMPORAL_ALT_REF
1347 cpi->fixed_divide[0] = 0;
1349 for (i = 1; i < 512; i++)
1350 cpi->fixed_divide[i] = 0x80000 / i;
1355 void update_layer_contexts (VP8_COMP *cpi)
1357 VP8_CONFIG *oxcf = &cpi->oxcf;
1359 /* Update snapshots of the layer contexts to reflect new parameters */
1360 if (oxcf->number_of_layers > 1)
1363 double prev_layer_frame_rate=0;
1365 for (i=0; i<oxcf->number_of_layers; i++)
1367 LAYER_CONTEXT *lc = &cpi->layer_context[i];
1370 cpi->ref_frame_rate / oxcf->rate_decimator[i];
1371 lc->target_bandwidth = oxcf->target_bitrate[i] * 1000;
1373 lc->starting_buffer_level = rescale(
1374 oxcf->starting_buffer_level_in_ms,
1375 lc->target_bandwidth, 1000);
1377 if (oxcf->optimal_buffer_level == 0)
1378 lc->optimal_buffer_level = lc->target_bandwidth / 8;
1380 lc->optimal_buffer_level = rescale(
1381 oxcf->optimal_buffer_level_in_ms,
1382 lc->target_bandwidth, 1000);
1384 if (oxcf->maximum_buffer_size == 0)
1385 lc->maximum_buffer_size = lc->target_bandwidth / 8;
1387 lc->maximum_buffer_size = rescale(
1388 oxcf->maximum_buffer_size_in_ms,
1389 lc->target_bandwidth, 1000);
1391 // Work out the average size of a frame within this layer
1393 lc->avg_frame_size_for_layer = (oxcf->target_bitrate[i] -
1394 oxcf->target_bitrate[i-1]) * 1000 /
1395 (lc->frame_rate - prev_layer_frame_rate);
1397 lc->active_worst_quality = oxcf->worst_allowed_q;
1398 lc->active_best_quality = oxcf->best_allowed_q;
1399 lc->avg_frame_qindex = oxcf->worst_allowed_q;
1401 prev_layer_frame_rate = lc->frame_rate;
1406 void vp8_change_config(VP8_COMP *cpi, VP8_CONFIG *oxcf)
1408 VP8_COMMON *cm = &cpi->common;
1417 #if CONFIG_MULTITHREAD
1418 /* wait for the last picture loopfilter thread done */
1419 if (cpi->b_lpf_running)
1421 sem_wait(&cpi->h_event_end_lpf);
1422 cpi->b_lpf_running = 0;
1426 if (cm->version != oxcf->Version)
1428 cm->version = oxcf->Version;
1429 vp8_setup_version(cm);
1432 last_w = cpi->oxcf.Width;
1433 last_h = cpi->oxcf.Height;
1437 switch (cpi->oxcf.Mode)
1442 cpi->compressor_speed = 2;
1444 if (cpi->oxcf.cpu_used < -16)
1446 cpi->oxcf.cpu_used = -16;
1449 if (cpi->oxcf.cpu_used > 16)
1450 cpi->oxcf.cpu_used = 16;
1454 case MODE_GOODQUALITY:
1456 cpi->compressor_speed = 1;
1458 if (cpi->oxcf.cpu_used < -5)
1460 cpi->oxcf.cpu_used = -5;
1463 if (cpi->oxcf.cpu_used > 5)
1464 cpi->oxcf.cpu_used = 5;
1468 case MODE_BESTQUALITY:
1470 cpi->compressor_speed = 0;
1473 case MODE_FIRSTPASS:
1475 cpi->compressor_speed = 1;
1477 case MODE_SECONDPASS:
1479 cpi->compressor_speed = 1;
1481 if (cpi->oxcf.cpu_used < -5)
1483 cpi->oxcf.cpu_used = -5;
1486 if (cpi->oxcf.cpu_used > 5)
1487 cpi->oxcf.cpu_used = 5;
1490 case MODE_SECONDPASS_BEST:
1492 cpi->compressor_speed = 0;
1497 cpi->auto_worst_q = 1;
1499 cpi->oxcf.worst_allowed_q = q_trans[oxcf->worst_allowed_q];
1500 cpi->oxcf.best_allowed_q = q_trans[oxcf->best_allowed_q];
1501 cpi->oxcf.cq_level = q_trans[cpi->oxcf.cq_level];
1503 if (oxcf->fixed_q >= 0)
1505 if (oxcf->worst_allowed_q < 0)
1506 cpi->oxcf.fixed_q = q_trans[0];
1508 cpi->oxcf.fixed_q = q_trans[oxcf->worst_allowed_q];
1510 if (oxcf->alt_q < 0)
1511 cpi->oxcf.alt_q = q_trans[0];
1513 cpi->oxcf.alt_q = q_trans[oxcf->alt_q];
1515 if (oxcf->key_q < 0)
1516 cpi->oxcf.key_q = q_trans[0];
1518 cpi->oxcf.key_q = q_trans[oxcf->key_q];
1520 if (oxcf->gold_q < 0)
1521 cpi->oxcf.gold_q = q_trans[0];
1523 cpi->oxcf.gold_q = q_trans[oxcf->gold_q];
1527 cpi->baseline_gf_interval =
1528 cpi->oxcf.alt_freq ? cpi->oxcf.alt_freq : DEFAULT_GF_INTERVAL;
1530 cpi->ref_frame_flags = VP8_ALT_FLAG | VP8_GOLD_FLAG | VP8_LAST_FLAG;
1532 //cpi->use_golden_frame_only = 0;
1533 //cpi->use_last_frame_only = 0;
1534 cm->refresh_golden_frame = 0;
1535 cm->refresh_last_frame = 1;
1536 cm->refresh_entropy_probs = 1;
1538 #if (CONFIG_REALTIME_ONLY & CONFIG_ONTHEFLY_BITPACKING)
1539 cpi->oxcf.token_partitions = 3;
1542 if (cpi->oxcf.token_partitions >= 0 && cpi->oxcf.token_partitions <= 3)
1543 cm->multi_token_partition =
1544 (TOKEN_PARTITION) cpi->oxcf.token_partitions;
1546 setup_features(cpi);
1551 for (i = 0; i < MAX_MB_SEGMENTS; i++)
1552 cpi->segment_encode_breakout[i] = cpi->oxcf.encode_breakout;
1555 // At the moment the first order values may not be > MAXQ
1556 if (cpi->oxcf.fixed_q > MAXQ)
1557 cpi->oxcf.fixed_q = MAXQ;
1559 // local file playback mode == really big buffer
1560 if (cpi->oxcf.end_usage == USAGE_LOCAL_FILE_PLAYBACK)
1562 cpi->oxcf.starting_buffer_level = 60000;
1563 cpi->oxcf.optimal_buffer_level = 60000;
1564 cpi->oxcf.maximum_buffer_size = 240000;
1565 cpi->oxcf.starting_buffer_level_in_ms = 60000;
1566 cpi->oxcf.optimal_buffer_level_in_ms = 60000;
1567 cpi->oxcf.maximum_buffer_size_in_ms = 240000;
1570 // Convert target bandwidth from Kbit/s to Bit/s
1571 cpi->oxcf.target_bandwidth *= 1000;
1573 cpi->oxcf.starting_buffer_level =
1574 rescale(cpi->oxcf.starting_buffer_level,
1575 cpi->oxcf.target_bandwidth, 1000);
1577 // Set or reset optimal and maximum buffer levels.
1578 if (cpi->oxcf.optimal_buffer_level == 0)
1579 cpi->oxcf.optimal_buffer_level = cpi->oxcf.target_bandwidth / 8;
1581 cpi->oxcf.optimal_buffer_level =
1582 rescale(cpi->oxcf.optimal_buffer_level,
1583 cpi->oxcf.target_bandwidth, 1000);
1585 if (cpi->oxcf.maximum_buffer_size == 0)
1586 cpi->oxcf.maximum_buffer_size = cpi->oxcf.target_bandwidth / 8;
1588 cpi->oxcf.maximum_buffer_size =
1589 rescale(cpi->oxcf.maximum_buffer_size,
1590 cpi->oxcf.target_bandwidth, 1000);
1592 // Set up frame rate and related parameters rate control values.
1593 vp8_new_frame_rate(cpi, cpi->frame_rate);
1595 // Set absolute upper and lower quality limits
1596 cpi->worst_quality = cpi->oxcf.worst_allowed_q;
1597 cpi->best_quality = cpi->oxcf.best_allowed_q;
1599 // active values should only be modified if out of new range
1600 if (cpi->active_worst_quality > cpi->oxcf.worst_allowed_q)
1602 cpi->active_worst_quality = cpi->oxcf.worst_allowed_q;
1605 else if (cpi->active_worst_quality < cpi->oxcf.best_allowed_q)
1607 cpi->active_worst_quality = cpi->oxcf.best_allowed_q;
1609 if (cpi->active_best_quality < cpi->oxcf.best_allowed_q)
1611 cpi->active_best_quality = cpi->oxcf.best_allowed_q;
1614 else if (cpi->active_best_quality > cpi->oxcf.worst_allowed_q)
1616 cpi->active_best_quality = cpi->oxcf.worst_allowed_q;
1619 cpi->buffered_mode = cpi->oxcf.optimal_buffer_level > 0;
1621 cpi->cq_target_quality = cpi->oxcf.cq_level;
1623 // Only allow dropped frames in buffered mode
1624 cpi->drop_frames_allowed = cpi->oxcf.allow_df && cpi->buffered_mode;
1626 if (!cm->use_bilinear_mc_filter)
1627 cm->mcomp_filter_type = SIXTAP;
1629 cm->mcomp_filter_type = BILINEAR;
1631 cpi->target_bandwidth = cpi->oxcf.target_bandwidth;
1634 cm->Width = cpi->oxcf.Width;
1635 cm->Height = cpi->oxcf.Height;
1637 /* TODO(jkoleszar): if an internal spatial resampling is active,
1638 * and we downsize the input image, maybe we should clear the
1639 * internal scale immediately rather than waiting for it to
1643 // VP8 sharpness level mapping 0-7 (vs 0-10 in general VPx dialogs)
1644 if (cpi->oxcf.Sharpness > 7)
1645 cpi->oxcf.Sharpness = 7;
1647 cm->sharpness_level = cpi->oxcf.Sharpness;
1649 if (cm->horiz_scale != NORMAL || cm->vert_scale != NORMAL)
1651 int UNINITIALIZED_IS_SAFE(hr), UNINITIALIZED_IS_SAFE(hs);
1652 int UNINITIALIZED_IS_SAFE(vr), UNINITIALIZED_IS_SAFE(vs);
1654 Scale2Ratio(cm->horiz_scale, &hr, &hs);
1655 Scale2Ratio(cm->vert_scale, &vr, &vs);
1657 // always go to the next whole number
1658 cm->Width = (hs - 1 + cpi->oxcf.Width * hr) / hs;
1659 cm->Height = (vs - 1 + cpi->oxcf.Height * vr) / vs;
1662 if (last_w != cpi->oxcf.Width || last_h != cpi->oxcf.Height)
1663 cpi->force_next_frame_intra = 1;
1665 if (((cm->Width + 15) & 0xfffffff0) !=
1666 cm->yv12_fb[cm->lst_fb_idx].y_width ||
1667 ((cm->Height + 15) & 0xfffffff0) !=
1668 cm->yv12_fb[cm->lst_fb_idx].y_height ||
1669 cm->yv12_fb[cm->lst_fb_idx].y_width == 0)
1671 alloc_raw_frame_buffers(cpi);
1672 vp8_alloc_compressor_data(cpi);
1675 if (cpi->oxcf.fixed_q >= 0)
1677 cpi->last_q[0] = cpi->oxcf.fixed_q;
1678 cpi->last_q[1] = cpi->oxcf.fixed_q;
1681 cpi->Speed = cpi->oxcf.cpu_used;
1683 // force to allowlag to 0 if lag_in_frames is 0;
1684 if (cpi->oxcf.lag_in_frames == 0)
1686 cpi->oxcf.allow_lag = 0;
1688 // Limit on lag buffers as these are not currently dynamically allocated
1689 else if (cpi->oxcf.lag_in_frames > MAX_LAG_BUFFERS)
1690 cpi->oxcf.lag_in_frames = MAX_LAG_BUFFERS;
1693 cpi->alt_ref_source = NULL;
1694 cpi->is_src_frame_alt_ref = 0;
1696 #if CONFIG_TEMPORAL_DENOISING
1697 if (cpi->oxcf.noise_sensitivity)
1699 if (!cpi->denoiser.yv12_mc_running_avg.buffer_alloc)
1701 int width = (cpi->oxcf.Width + 15) & ~15;
1702 int height = (cpi->oxcf.Height + 15) & ~15;
1703 vp8_denoiser_allocate(&cpi->denoiser, width, height);
1709 // Experimental RD Code
1710 cpi->frame_distortion = 0;
1711 cpi->last_frame_distortion = 0;
1716 #define M_LOG2_E 0.693147180559945309417
1717 #define log2f(x) (log (x) / (float) M_LOG2_E)
1718 static void cal_mvsadcosts(int *mvsadcost[2])
1722 mvsadcost [0] [0] = 300;
1723 mvsadcost [1] [0] = 300;
1727 double z = 256 * (2 * (log2f(8 * i) + .6));
1728 mvsadcost [0][i] = (int) z;
1729 mvsadcost [1][i] = (int) z;
1730 mvsadcost [0][-i] = (int) z;
1731 mvsadcost [1][-i] = (int) z;
1733 while (++i <= mvfp_max);
1736 struct VP8_COMP* vp8_create_compressor(VP8_CONFIG *oxcf)
1743 cpi = vpx_memalign(32, sizeof(VP8_COMP));
1744 // Check that the CPI instance is valid
1750 vpx_memset(cpi, 0, sizeof(VP8_COMP));
1752 if (setjmp(cm->error.jmp))
1754 cpi->common.error.setjmp = 0;
1755 vp8_remove_compressor(&cpi);
1759 cpi->common.error.setjmp = 1;
1761 CHECK_MEM_ERROR(cpi->mb.ss, vpx_calloc(sizeof(search_site), (MAX_MVSEARCH_STEPS * 8) + 1));
1763 vp8_create_common(&cpi->common);
1765 init_config(cpi, oxcf);
1767 memcpy(cpi->base_skip_false_prob, vp8cx_base_skip_false_prob, sizeof(vp8cx_base_skip_false_prob));
1768 cpi->common.current_video_frame = 0;
1769 cpi->kf_overspend_bits = 0;
1770 cpi->kf_bitrate_adjustment = 0;
1771 cpi->frames_till_gf_update_due = 0;
1772 cpi->gf_overspend_bits = 0;
1773 cpi->non_gf_bitrate_adjustment = 0;
1774 cpi->prob_last_coded = 128;
1775 cpi->prob_gf_coded = 128;
1776 cpi->prob_intra_coded = 63;
1778 // Prime the recent reference frame usage counters.
1779 // Hereafter they will be maintained as a sort of moving average
1780 cpi->recent_ref_frame_usage[INTRA_FRAME] = 1;
1781 cpi->recent_ref_frame_usage[LAST_FRAME] = 1;
1782 cpi->recent_ref_frame_usage[GOLDEN_FRAME] = 1;
1783 cpi->recent_ref_frame_usage[ALTREF_FRAME] = 1;
1785 // Set reference frame sign bias for ALTREF frame to 1 (for now)
1786 cpi->common.ref_frame_sign_bias[ALTREF_FRAME] = 1;
1788 cpi->twopass.gf_decay_rate = 0;
1789 cpi->baseline_gf_interval = DEFAULT_GF_INTERVAL;
1791 cpi->gold_is_last = 0 ;
1792 cpi->alt_is_last = 0 ;
1793 cpi->gold_is_alt = 0 ;
1795 // allocate memory for storing last frame's MVs for MV prediction.
1796 CHECK_MEM_ERROR(cpi->lfmv, vpx_calloc((cpi->common.mb_rows+2) * (cpi->common.mb_cols+2), sizeof(int_mv)));
1797 CHECK_MEM_ERROR(cpi->lf_ref_frame_sign_bias, vpx_calloc((cpi->common.mb_rows+2) * (cpi->common.mb_cols+2), sizeof(int)));
1798 CHECK_MEM_ERROR(cpi->lf_ref_frame, vpx_calloc((cpi->common.mb_rows+2) * (cpi->common.mb_cols+2), sizeof(int)));
1800 // Create the encoder segmentation map and set all entries to 0
1801 CHECK_MEM_ERROR(cpi->segmentation_map, vpx_calloc(cpi->common.mb_rows * cpi->common.mb_cols, 1));
1802 CHECK_MEM_ERROR(cpi->active_map, vpx_calloc(cpi->common.mb_rows * cpi->common.mb_cols, 1));
1803 vpx_memset(cpi->active_map , 1, (cpi->common.mb_rows * cpi->common.mb_cols));
1804 cpi->active_map_enabled = 0;
1807 // Experimental code for lagged and one pass
1808 // Initialise one_pass GF frames stats
1809 // Update stats used for GF selection
1812 cpi->one_pass_frame_index = 0;
1814 for (i = 0; i < MAX_LAG_BUFFERS; i++)
1816 cpi->one_pass_frame_stats[i].frames_so_far = 0;
1817 cpi->one_pass_frame_stats[i].frame_intra_error = 0.0;
1818 cpi->one_pass_frame_stats[i].frame_coded_error = 0.0;
1819 cpi->one_pass_frame_stats[i].frame_pcnt_inter = 0.0;
1820 cpi->one_pass_frame_stats[i].frame_pcnt_motion = 0.0;
1821 cpi->one_pass_frame_stats[i].frame_mvr = 0.0;
1822 cpi->one_pass_frame_stats[i].frame_mvr_abs = 0.0;
1823 cpi->one_pass_frame_stats[i].frame_mvc = 0.0;
1824 cpi->one_pass_frame_stats[i].frame_mvc_abs = 0.0;
1829 // Should we use the cyclic refresh method.
1830 // Currently this is tied to error resilliant mode
1831 cpi->cyclic_refresh_mode_enabled = cpi->oxcf.error_resilient_mode;
1832 cpi->cyclic_refresh_mode_max_mbs_perframe = (cpi->common.mb_rows * cpi->common.mb_cols) / 40;
1833 cpi->cyclic_refresh_mode_index = 0;
1834 cpi->cyclic_refresh_q = 32;
1836 if (cpi->cyclic_refresh_mode_enabled)
1838 CHECK_MEM_ERROR(cpi->cyclic_refresh_map, vpx_calloc((cpi->common.mb_rows * cpi->common.mb_cols), 1));
1841 cpi->cyclic_refresh_map = (signed char *) NULL;
1843 // Test function for segmentation
1844 //segmentation_test_function( cpi);
1846 #ifdef ENTROPY_STATS
1847 init_context_counters();
1850 /*Initialize the feed-forward activity masking.*/
1851 cpi->activity_avg = 90<<12;
1853 cpi->frames_since_key = 8; // Give a sensible default for the first frame.
1854 cpi->key_frame_frequency = cpi->oxcf.key_freq;
1855 cpi->this_key_frame_forced = 0;
1856 cpi->next_key_frame_forced = 0;
1858 cpi->source_alt_ref_pending = 0;
1859 cpi->source_alt_ref_active = 0;
1860 cpi->common.refresh_alt_ref_frame = 0;
1862 cpi->b_calculate_psnr = CONFIG_INTERNAL_STATS;
1863 #if CONFIG_INTERNAL_STATS
1864 cpi->b_calculate_ssimg = 0;
1869 if (cpi->b_calculate_psnr)
1871 cpi->total_sq_error = 0.0;
1872 cpi->total_sq_error2 = 0.0;
1877 cpi->totalp_y = 0.0;
1878 cpi->totalp_u = 0.0;
1879 cpi->totalp_v = 0.0;
1881 cpi->tot_recode_hits = 0;
1882 cpi->summed_quality = 0;
1883 cpi->summed_weights = 0;
1886 if (cpi->b_calculate_ssimg)
1888 cpi->total_ssimg_y = 0;
1889 cpi->total_ssimg_u = 0;
1890 cpi->total_ssimg_v = 0;
1891 cpi->total_ssimg_all = 0;
1897 #define LLONG_MAX 9223372036854775807LL
1899 cpi->first_time_stamp_ever = LLONG_MAX;
1901 cpi->frames_till_gf_update_due = 0;
1902 cpi->key_frame_count = 1;
1904 cpi->ni_av_qi = cpi->oxcf.worst_allowed_q;
1907 cpi->total_byte_count = 0;
1909 cpi->drop_frame = 0;
1910 cpi->drop_count = 0;
1911 cpi->max_drop_count = 0;
1912 cpi->max_consec_dropped_frames = 4;
1914 cpi->rate_correction_factor = 1.0;
1915 cpi->key_frame_rate_correction_factor = 1.0;
1916 cpi->gf_rate_correction_factor = 1.0;
1917 cpi->twopass.est_max_qcorrection_factor = 1.0;
1919 cpi->mb.mvcost[0] = &cpi->mb.mvcosts[0][mv_max+1];
1920 cpi->mb.mvcost[1] = &cpi->mb.mvcosts[1][mv_max+1];
1921 cpi->mb.mvsadcost[0] = &cpi->mb.mvsadcosts[0][mvfp_max+1];
1922 cpi->mb.mvsadcost[1] = &cpi->mb.mvsadcosts[1][mvfp_max+1];
1924 cal_mvsadcosts(cpi->mb.mvsadcost);
1926 for (i = 0; i < KEY_FRAME_CONTEXT; i++)
1928 cpi->prior_key_frame_distance[i] = (int)cpi->output_frame_rate;
1931 #ifdef OUTPUT_YUV_SRC
1932 yuv_file = fopen("bd.yuv", "ab");
1936 framepsnr = fopen("framepsnr.stt", "a");
1937 kf_list = fopen("kf_list.stt", "w");
1940 cpi->output_pkt_list = oxcf->output_pkt_list;
1942 #if !(CONFIG_REALTIME_ONLY)
1946 vp8_init_first_pass(cpi);
1948 else if (cpi->pass == 2)
1950 size_t packet_sz = sizeof(FIRSTPASS_STATS);
1951 int packets = oxcf->two_pass_stats_in.sz / packet_sz;
1953 cpi->twopass.stats_in_start = oxcf->two_pass_stats_in.buf;
1954 cpi->twopass.stats_in = cpi->twopass.stats_in_start;
1955 cpi->twopass.stats_in_end = (void*)((char *)cpi->twopass.stats_in
1956 + (packets - 1) * packet_sz);
1957 vp8_init_second_pass(cpi);
1962 if (cpi->compressor_speed == 2)
1964 cpi->cpu_freq = 0; //vp8_get_processor_freq();
1965 cpi->avg_encode_time = 0;
1966 cpi->avg_pick_mode_time = 0;
1969 vp8_set_speed_features(cpi);
1971 // Set starting values of RD threshold multipliers (128 = *1)
1972 for (i = 0; i < MAX_MODES; i++)
1974 cpi->rd_thresh_mult[i] = 128;
1977 #ifdef ENTROPY_STATS
1978 init_mv_ref_counts();
1981 #if CONFIG_MULTITHREAD
1982 vp8cx_create_encoder_threads(cpi);
1985 cpi->fn_ptr[BLOCK_16X16].sdf = vp8_sad16x16;
1986 cpi->fn_ptr[BLOCK_16X16].vf = vp8_variance16x16;
1987 cpi->fn_ptr[BLOCK_16X16].svf = vp8_sub_pixel_variance16x16;
1988 cpi->fn_ptr[BLOCK_16X16].svf_halfpix_h = vp8_variance_halfpixvar16x16_h;
1989 cpi->fn_ptr[BLOCK_16X16].svf_halfpix_v = vp8_variance_halfpixvar16x16_v;
1990 cpi->fn_ptr[BLOCK_16X16].svf_halfpix_hv = vp8_variance_halfpixvar16x16_hv;
1991 cpi->fn_ptr[BLOCK_16X16].sdx3f = vp8_sad16x16x3;
1992 cpi->fn_ptr[BLOCK_16X16].sdx8f = vp8_sad16x16x8;
1993 cpi->fn_ptr[BLOCK_16X16].sdx4df = vp8_sad16x16x4d;
1995 cpi->fn_ptr[BLOCK_16X8].sdf = vp8_sad16x8;
1996 cpi->fn_ptr[BLOCK_16X8].vf = vp8_variance16x8;
1997 cpi->fn_ptr[BLOCK_16X8].svf = vp8_sub_pixel_variance16x8;
1998 cpi->fn_ptr[BLOCK_16X8].svf_halfpix_h = NULL;
1999 cpi->fn_ptr[BLOCK_16X8].svf_halfpix_v = NULL;
2000 cpi->fn_ptr[BLOCK_16X8].svf_halfpix_hv = NULL;
2001 cpi->fn_ptr[BLOCK_16X8].sdx3f = vp8_sad16x8x3;
2002 cpi->fn_ptr[BLOCK_16X8].sdx8f = vp8_sad16x8x8;
2003 cpi->fn_ptr[BLOCK_16X8].sdx4df = vp8_sad16x8x4d;
2005 cpi->fn_ptr[BLOCK_8X16].sdf = vp8_sad8x16;
2006 cpi->fn_ptr[BLOCK_8X16].vf = vp8_variance8x16;
2007 cpi->fn_ptr[BLOCK_8X16].svf = vp8_sub_pixel_variance8x16;
2008 cpi->fn_ptr[BLOCK_8X16].svf_halfpix_h = NULL;
2009 cpi->fn_ptr[BLOCK_8X16].svf_halfpix_v = NULL;
2010 cpi->fn_ptr[BLOCK_8X16].svf_halfpix_hv = NULL;
2011 cpi->fn_ptr[BLOCK_8X16].sdx3f = vp8_sad8x16x3;
2012 cpi->fn_ptr[BLOCK_8X16].sdx8f = vp8_sad8x16x8;
2013 cpi->fn_ptr[BLOCK_8X16].sdx4df = vp8_sad8x16x4d;
2015 cpi->fn_ptr[BLOCK_8X8].sdf = vp8_sad8x8;
2016 cpi->fn_ptr[BLOCK_8X8].vf = vp8_variance8x8;
2017 cpi->fn_ptr[BLOCK_8X8].svf = vp8_sub_pixel_variance8x8;
2018 cpi->fn_ptr[BLOCK_8X8].svf_halfpix_h = NULL;
2019 cpi->fn_ptr[BLOCK_8X8].svf_halfpix_v = NULL;
2020 cpi->fn_ptr[BLOCK_8X8].svf_halfpix_hv = NULL;
2021 cpi->fn_ptr[BLOCK_8X8].sdx3f = vp8_sad8x8x3;
2022 cpi->fn_ptr[BLOCK_8X8].sdx8f = vp8_sad8x8x8;
2023 cpi->fn_ptr[BLOCK_8X8].sdx4df = vp8_sad8x8x4d;
2025 cpi->fn_ptr[BLOCK_4X4].sdf = vp8_sad4x4;
2026 cpi->fn_ptr[BLOCK_4X4].vf = vp8_variance4x4;
2027 cpi->fn_ptr[BLOCK_4X4].svf = vp8_sub_pixel_variance4x4;
2028 cpi->fn_ptr[BLOCK_4X4].svf_halfpix_h = NULL;
2029 cpi->fn_ptr[BLOCK_4X4].svf_halfpix_v = NULL;
2030 cpi->fn_ptr[BLOCK_4X4].svf_halfpix_hv = NULL;
2031 cpi->fn_ptr[BLOCK_4X4].sdx3f = vp8_sad4x4x3;
2032 cpi->fn_ptr[BLOCK_4X4].sdx8f = vp8_sad4x4x8;
2033 cpi->fn_ptr[BLOCK_4X4].sdx4df = vp8_sad4x4x4d;
2035 #if ARCH_X86 || ARCH_X86_64
2036 cpi->fn_ptr[BLOCK_16X16].copymem = vp8_copy32xn;
2037 cpi->fn_ptr[BLOCK_16X8].copymem = vp8_copy32xn;
2038 cpi->fn_ptr[BLOCK_8X16].copymem = vp8_copy32xn;
2039 cpi->fn_ptr[BLOCK_8X8].copymem = vp8_copy32xn;
2040 cpi->fn_ptr[BLOCK_4X4].copymem = vp8_copy32xn;
2043 cpi->full_search_sad = vp8_full_search_sad;
2044 cpi->diamond_search_sad = vp8_diamond_search_sad;
2045 cpi->refining_search_sad = vp8_refining_search_sad;
2047 // make sure frame 1 is okay
2048 cpi->error_bins[0] = cpi->common.MBs;
2050 //vp8cx_init_quantizer() is first called here. Add check in vp8cx_frame_init_quantizer() so that vp8cx_init_quantizer is only called later
2051 //when needed. This will avoid unnecessary calls of vp8cx_init_quantizer() for every frame.
2052 vp8cx_init_quantizer(cpi);
2054 vp8_loop_filter_init(cm);
2056 cpi->common.error.setjmp = 0;
2058 #if CONFIG_MULTI_RES_ENCODING
2059 /* Calculate # of MBs in a row in lower-resolution level image. */
2060 if (cpi->oxcf.mr_encoder_id > 0)
2061 vp8_cal_low_res_mb_cols(cpi);
2069 void vp8_remove_compressor(VP8_COMP **ptr)
2071 VP8_COMP *cpi = *ptr;
2076 if (cpi && (cpi->common.current_video_frame > 0))
2078 #if !(CONFIG_REALTIME_ONLY)
2082 vp8_end_second_pass(cpi);
2087 #ifdef ENTROPY_STATS
2088 print_context_counters();
2089 print_tree_update_probs();
2090 print_mode_context();
2093 #if CONFIG_INTERNAL_STATS
2097 FILE *f = fopen("opsnr.stt", "a");
2098 double time_encoded = (cpi->last_end_time_stamp_seen
2099 - cpi->first_time_stamp_ever) / 10000000.000;
2100 double total_encode_time = (cpi->time_receive_data +
2101 cpi->time_compress_data) / 1000.000;
2102 double dr = (double)cpi->bytes * 8.0 / 1000.0 / time_encoded;
2104 if (cpi->b_calculate_psnr)
2106 YV12_BUFFER_CONFIG *lst_yv12 =
2107 &cpi->common.yv12_fb[cpi->common.lst_fb_idx];
2109 if (cpi->oxcf.number_of_layers > 1)
2113 fprintf(f, "Layer\tBitrate\tAVGPsnr\tGLBPsnr\tAVPsnrP\t"
2114 "GLPsnrP\tVPXSSIM\t\n");
2115 for (i=0; i<cpi->oxcf.number_of_layers; i++)
2117 double dr = (double)cpi->bytes_in_layer[i] *
2118 8.0 / 1000.0 / time_encoded;
2119 double samples = 3.0 / 2 * cpi->frames_in_layer[i] *
2120 lst_yv12->y_width * lst_yv12->y_height;
2121 double total_psnr = vp8_mse2psnr(samples, 255.0,
2122 cpi->total_error2[i]);
2123 double total_psnr2 = vp8_mse2psnr(samples, 255.0,
2124 cpi->total_error2_p[i]);
2125 double total_ssim = 100 * pow(cpi->sum_ssim[i] /
2126 cpi->sum_weights[i], 8.0);
2128 fprintf(f, "%5d\t%7.3f\t%7.3f\t%7.3f\t%7.3f\t"
2131 cpi->sum_psnr[i] / cpi->frames_in_layer[i],
2133 cpi->sum_psnr_p[i] / cpi->frames_in_layer[i],
2134 total_psnr2, total_ssim);
2139 double samples = 3.0 / 2 * cpi->count *
2140 lst_yv12->y_width * lst_yv12->y_height;
2141 double total_psnr = vp8_mse2psnr(samples, 255.0,
2142 cpi->total_sq_error);
2143 double total_psnr2 = vp8_mse2psnr(samples, 255.0,
2144 cpi->total_sq_error2);
2145 double total_ssim = 100 * pow(cpi->summed_quality /
2146 cpi->summed_weights, 8.0);
2148 fprintf(f, "Bitrate\tAVGPsnr\tGLBPsnr\tAVPsnrP\t"
2149 "GLPsnrP\tVPXSSIM\t Time(us)\n");
2150 fprintf(f, "%7.3f\t%7.3f\t%7.3f\t%7.3f\t%7.3f\t"
2152 dr, cpi->total / cpi->count, total_psnr,
2153 cpi->totalp / cpi->count, total_psnr2,
2154 total_ssim, total_encode_time);
2158 if (cpi->b_calculate_ssimg)
2160 if (cpi->oxcf.number_of_layers > 1)
2164 fprintf(f, "Layer\tBitRate\tSSIM_Y\tSSIM_U\tSSIM_V\tSSIM_A\t"
2166 for (i=0; i<cpi->oxcf.number_of_layers; i++)
2168 double dr = (double)cpi->bytes_in_layer[i] *
2169 8.0 / 1000.0 / time_encoded;
2170 fprintf(f, "%5d\t%7.3f\t%6.4f\t"
2171 "%6.4f\t%6.4f\t%6.4f\t%8.0f\n",
2173 cpi->total_ssimg_y_in_layer[i] /
2174 cpi->frames_in_layer[i],
2175 cpi->total_ssimg_u_in_layer[i] /
2176 cpi->frames_in_layer[i],
2177 cpi->total_ssimg_v_in_layer[i] /
2178 cpi->frames_in_layer[i],
2179 cpi->total_ssimg_all_in_layer[i] /
2180 cpi->frames_in_layer[i],
2186 fprintf(f, "BitRate\tSSIM_Y\tSSIM_U\tSSIM_V\tSSIM_A\t"
2188 fprintf(f, "%7.3f\t%6.4f\t%6.4f\t%6.4f\t%6.4f\t%8.0f\n", dr,
2189 cpi->total_ssimg_y / cpi->count,
2190 cpi->total_ssimg_u / cpi->count,
2191 cpi->total_ssimg_v / cpi->count,
2192 cpi->total_ssimg_all / cpi->count, total_encode_time);
2198 f = fopen("qskip.stt", "a");
2199 fprintf(f, "minq:%d -maxq:%d skiptrue:skipfalse = %d:%d\n", cpi->oxcf.best_allowed_q, cpi->oxcf.worst_allowed_q, skiptruecount, skipfalsecount);
2210 if (cpi->compressor_speed == 2)
2213 FILE *f = fopen("cxspeed.stt", "a");
2214 cnt_pm /= cpi->common.MBs;
2216 for (i = 0; i < 16; i++)
2217 fprintf(f, "%5d", frames_at_speed[i]);
2220 //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);
2229 extern int count_mb_seg[4];
2230 FILE *f = fopen("modes.stt", "a");
2231 double dr = (double)cpi->frame_rate * (double)bytes * (double)8 / (double)count / (double)1000 ;
2232 fprintf(f, "intra_mode in Intra Frames:\n");
2233 fprintf(f, "Y: %8d, %8d, %8d, %8d, %8d\n", y_modes[0], y_modes[1], y_modes[2], y_modes[3], y_modes[4]);
2234 fprintf(f, "UV:%8d, %8d, %8d, %8d\n", uv_modes[0], uv_modes[1], uv_modes[2], uv_modes[3]);
2239 for (i = 0; i < 10; i++)
2240 fprintf(f, "%8d, ", b_modes[i]);
2246 fprintf(f, "Modes in Inter Frames:\n");
2247 fprintf(f, "Y: %8d, %8d, %8d, %8d, %8d, %8d, %8d, %8d, %8d, %8d\n",
2248 inter_y_modes[0], inter_y_modes[1], inter_y_modes[2], inter_y_modes[3], inter_y_modes[4],
2249 inter_y_modes[5], inter_y_modes[6], inter_y_modes[7], inter_y_modes[8], inter_y_modes[9]);
2250 fprintf(f, "UV:%8d, %8d, %8d, %8d\n", inter_uv_modes[0], inter_uv_modes[1], inter_uv_modes[2], inter_uv_modes[3]);
2255 for (i = 0; i < 15; i++)
2256 fprintf(f, "%8d, ", inter_b_modes[i]);
2261 fprintf(f, "P:%8d, %8d, %8d, %8d\n", count_mb_seg[0], count_mb_seg[1], count_mb_seg[2], count_mb_seg[3]);
2262 fprintf(f, "PB:%8d, %8d, %8d, %8d\n", inter_b_modes[LEFT4X4], inter_b_modes[ABOVE4X4], inter_b_modes[ZERO4X4], inter_b_modes[NEW4X4]);
2270 #ifdef ENTROPY_STATS
2273 FILE *fmode = fopen("modecontext.c", "w");
2275 fprintf(fmode, "\n#include \"entropymode.h\"\n\n");
2276 fprintf(fmode, "const unsigned int vp8_kf_default_bmode_counts ");
2277 fprintf(fmode, "[VP8_BINTRAMODES] [VP8_BINTRAMODES] [VP8_BINTRAMODES] =\n{\n");
2279 for (i = 0; i < 10; i++)
2282 fprintf(fmode, " { //Above Mode : %d\n", i);
2284 for (j = 0; j < 10; j++)
2287 fprintf(fmode, " {");
2289 for (k = 0; k < 10; k++)
2291 if (!intra_mode_stats[i][j][k])
2292 fprintf(fmode, " %5d, ", 1);
2294 fprintf(fmode, " %5d, ", intra_mode_stats[i][j][k]);
2297 fprintf(fmode, "}, // left_mode %d\n", j);
2301 fprintf(fmode, " },\n");
2305 fprintf(fmode, "};\n");
2311 #if defined(SECTIONBITS_OUTPUT)
2316 FILE *f = fopen("tokenbits.stt", "a");
2318 for (i = 0; i < 28; i++)
2319 fprintf(f, "%8d", (int)(Sectionbits[i] / 256));
2329 printf("\n_pick_loop_filter_level:%d\n", cpi->time_pick_lpf / 1000);
2330 printf("\n_frames recive_data encod_mb_row compress_frame Total\n");
2331 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);
2337 #if CONFIG_MULTITHREAD
2338 vp8cx_remove_encoder_threads(cpi);
2341 #if CONFIG_TEMPORAL_DENOISING
2342 vp8_denoiser_free(&cpi->denoiser);
2344 dealloc_compressor_data(cpi);
2345 vpx_free(cpi->mb.ss);
2347 vpx_free(cpi->cyclic_refresh_map);
2349 vp8_remove_common(&cpi->common);
2353 #ifdef OUTPUT_YUV_SRC
2373 static uint64_t calc_plane_error(unsigned char *orig, int orig_stride,
2374 unsigned char *recon, int recon_stride,
2375 unsigned int cols, unsigned int rows)
2377 unsigned int row, col;
2378 uint64_t total_sse = 0;
2381 for (row = 0; row + 16 <= rows; row += 16)
2383 for (col = 0; col + 16 <= cols; col += 16)
2387 vp8_mse16x16(orig + col, orig_stride,
2388 recon + col, recon_stride,
2393 /* Handle odd-sized width */
2396 unsigned int border_row, border_col;
2397 unsigned char *border_orig = orig;
2398 unsigned char *border_recon = recon;
2400 for (border_row = 0; border_row < 16; border_row++)
2402 for (border_col = col; border_col < cols; border_col++)
2404 diff = border_orig[border_col] - border_recon[border_col];
2405 total_sse += diff * diff;
2408 border_orig += orig_stride;
2409 border_recon += recon_stride;
2413 orig += orig_stride * 16;
2414 recon += recon_stride * 16;
2417 /* Handle odd-sized height */
2418 for (; row < rows; row++)
2420 for (col = 0; col < cols; col++)
2422 diff = orig[col] - recon[col];
2423 total_sse += diff * diff;
2426 orig += orig_stride;
2427 recon += recon_stride;
2430 vp8_clear_system_state();
2435 static void generate_psnr_packet(VP8_COMP *cpi)
2437 YV12_BUFFER_CONFIG *orig = cpi->Source;
2438 YV12_BUFFER_CONFIG *recon = cpi->common.frame_to_show;
2439 struct vpx_codec_cx_pkt pkt;
2442 unsigned int width = cpi->common.Width;
2443 unsigned int height = cpi->common.Height;
2445 pkt.kind = VPX_CODEC_PSNR_PKT;
2446 sse = calc_plane_error(orig->y_buffer, orig->y_stride,
2447 recon->y_buffer, recon->y_stride,
2449 pkt.data.psnr.sse[0] = sse;
2450 pkt.data.psnr.sse[1] = sse;
2451 pkt.data.psnr.samples[0] = width * height;
2452 pkt.data.psnr.samples[1] = width * height;
2454 width = (width + 1) / 2;
2455 height = (height + 1) / 2;
2457 sse = calc_plane_error(orig->u_buffer, orig->uv_stride,
2458 recon->u_buffer, recon->uv_stride,
2460 pkt.data.psnr.sse[0] += sse;
2461 pkt.data.psnr.sse[2] = sse;
2462 pkt.data.psnr.samples[0] += width * height;
2463 pkt.data.psnr.samples[2] = width * height;
2465 sse = calc_plane_error(orig->v_buffer, orig->uv_stride,
2466 recon->v_buffer, recon->uv_stride,
2468 pkt.data.psnr.sse[0] += sse;
2469 pkt.data.psnr.sse[3] = sse;
2470 pkt.data.psnr.samples[0] += width * height;
2471 pkt.data.psnr.samples[3] = width * height;
2473 for (i = 0; i < 4; i++)
2474 pkt.data.psnr.psnr[i] = vp8_mse2psnr(pkt.data.psnr.samples[i], 255.0,
2475 pkt.data.psnr.sse[i]);
2477 vpx_codec_pkt_list_add(cpi->output_pkt_list, &pkt);
2481 int vp8_use_as_reference(VP8_COMP *cpi, int ref_frame_flags)
2483 if (ref_frame_flags > 7)
2486 cpi->ref_frame_flags = ref_frame_flags;
2489 int vp8_update_reference(VP8_COMP *cpi, int ref_frame_flags)
2491 if (ref_frame_flags > 7)
2494 cpi->common.refresh_golden_frame = 0;
2495 cpi->common.refresh_alt_ref_frame = 0;
2496 cpi->common.refresh_last_frame = 0;
2498 if (ref_frame_flags & VP8_LAST_FLAG)
2499 cpi->common.refresh_last_frame = 1;
2501 if (ref_frame_flags & VP8_GOLD_FLAG)
2502 cpi->common.refresh_golden_frame = 1;
2504 if (ref_frame_flags & VP8_ALT_FLAG)
2505 cpi->common.refresh_alt_ref_frame = 1;
2510 int vp8_get_reference(VP8_COMP *cpi, VP8_REFFRAME ref_frame_flag, YV12_BUFFER_CONFIG *sd)
2512 VP8_COMMON *cm = &cpi->common;
2515 if (ref_frame_flag == VP8_LAST_FLAG)
2516 ref_fb_idx = cm->lst_fb_idx;
2517 else if (ref_frame_flag == VP8_GOLD_FLAG)
2518 ref_fb_idx = cm->gld_fb_idx;
2519 else if (ref_frame_flag == VP8_ALT_FLAG)
2520 ref_fb_idx = cm->alt_fb_idx;
2524 vp8_yv12_copy_frame_ptr(&cm->yv12_fb[ref_fb_idx], sd);
2528 int vp8_set_reference(VP8_COMP *cpi, VP8_REFFRAME ref_frame_flag, YV12_BUFFER_CONFIG *sd)
2530 VP8_COMMON *cm = &cpi->common;
2534 if (ref_frame_flag == VP8_LAST_FLAG)
2535 ref_fb_idx = cm->lst_fb_idx;
2536 else if (ref_frame_flag == VP8_GOLD_FLAG)
2537 ref_fb_idx = cm->gld_fb_idx;
2538 else if (ref_frame_flag == VP8_ALT_FLAG)
2539 ref_fb_idx = cm->alt_fb_idx;
2543 vp8_yv12_copy_frame_ptr(sd, &cm->yv12_fb[ref_fb_idx]);
2547 int vp8_update_entropy(VP8_COMP *cpi, int update)
2549 VP8_COMMON *cm = &cpi->common;
2550 cm->refresh_entropy_probs = update;
2557 void vp8_write_yuv_frame(const char *name, YV12_BUFFER_CONFIG *s)
2559 FILE *yuv_file = fopen(name, "ab");
2560 unsigned char *src = s->y_buffer;
2561 int h = s->y_height;
2565 fwrite(src, s->y_width, 1, yuv_file);
2575 fwrite(src, s->uv_width, 1, yuv_file);
2576 src += s->uv_stride;
2585 fwrite(src, s->uv_width, 1, yuv_file);
2586 src += s->uv_stride;
2595 static void scale_and_extend_source(YV12_BUFFER_CONFIG *sd, VP8_COMP *cpi)
2597 VP8_COMMON *cm = &cpi->common;
2599 // are we resizing the image
2600 if (cm->horiz_scale != 0 || cm->vert_scale != 0)
2602 #if CONFIG_SPATIAL_RESAMPLING
2603 int UNINITIALIZED_IS_SAFE(hr), UNINITIALIZED_IS_SAFE(hs);
2604 int UNINITIALIZED_IS_SAFE(vr), UNINITIALIZED_IS_SAFE(vs);
2607 if (cm->vert_scale == 3)
2612 Scale2Ratio(cm->horiz_scale, &hr, &hs);
2613 Scale2Ratio(cm->vert_scale, &vr, &vs);
2615 vp8_scale_frame(sd, &cpi->scaled_source, cm->temp_scale_frame.y_buffer,
2616 tmp_height, hs, hr, vs, vr, 0);
2618 vp8_yv12_extend_frame_borders(&cpi->scaled_source);
2619 cpi->Source = &cpi->scaled_source;
2627 static void resize_key_frame(VP8_COMP *cpi)
2629 #if CONFIG_SPATIAL_RESAMPLING
2630 VP8_COMMON *cm = &cpi->common;
2632 // Do we need to apply resampling for one pass cbr.
2633 // In one pass this is more limited than in two pass cbr
2634 // The test and any change is only made one per key frame sequence
2635 if (cpi->oxcf.allow_spatial_resampling && (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER))
2637 int UNINITIALIZED_IS_SAFE(hr), UNINITIALIZED_IS_SAFE(hs);
2638 int UNINITIALIZED_IS_SAFE(vr), UNINITIALIZED_IS_SAFE(vs);
2639 int new_width, new_height;
2641 // If we are below the resample DOWN watermark then scale down a notch.
2642 if (cpi->buffer_level < (cpi->oxcf.resample_down_water_mark * cpi->oxcf.optimal_buffer_level / 100))
2644 cm->horiz_scale = (cm->horiz_scale < ONETWO) ? cm->horiz_scale + 1 : ONETWO;
2645 cm->vert_scale = (cm->vert_scale < ONETWO) ? cm->vert_scale + 1 : ONETWO;
2647 // Should we now start scaling back up
2648 else if (cpi->buffer_level > (cpi->oxcf.resample_up_water_mark * cpi->oxcf.optimal_buffer_level / 100))
2650 cm->horiz_scale = (cm->horiz_scale > NORMAL) ? cm->horiz_scale - 1 : NORMAL;
2651 cm->vert_scale = (cm->vert_scale > NORMAL) ? cm->vert_scale - 1 : NORMAL;
2654 // Get the new hieght and width
2655 Scale2Ratio(cm->horiz_scale, &hr, &hs);
2656 Scale2Ratio(cm->vert_scale, &vr, &vs);
2657 new_width = ((hs - 1) + (cpi->oxcf.Width * hr)) / hs;
2658 new_height = ((vs - 1) + (cpi->oxcf.Height * vr)) / vs;
2660 // If the image size has changed we need to reallocate the buffers
2661 // and resample the source image
2662 if ((cm->Width != new_width) || (cm->Height != new_height))
2664 cm->Width = new_width;
2665 cm->Height = new_height;
2666 vp8_alloc_compressor_data(cpi);
2667 scale_and_extend_source(cpi->un_scaled_source, cpi);
2675 static void update_alt_ref_frame_stats(VP8_COMP *cpi)
2677 VP8_COMMON *cm = &cpi->common;
2679 // Select an interval before next GF or altref
2680 if (!cpi->auto_gold)
2681 cpi->frames_till_gf_update_due = cpi->goldfreq;
2683 if ((cpi->pass != 2) && cpi->frames_till_gf_update_due)
2685 cpi->current_gf_interval = cpi->frames_till_gf_update_due;
2687 // Set the bits per frame that we should try and recover in subsequent inter frames
2688 // to account for the extra GF spend... note that his does not apply for GF updates
2689 // that occur coincident with a key frame as the extra cost of key frames is dealt
2692 cpi->gf_overspend_bits += cpi->projected_frame_size;
2693 cpi->non_gf_bitrate_adjustment = cpi->gf_overspend_bits / cpi->frames_till_gf_update_due;
2696 // Update data structure that monitors level of reference to last GF
2697 vpx_memset(cpi->gf_active_flags, 1, (cm->mb_rows * cm->mb_cols));
2698 cpi->gf_active_count = cm->mb_rows * cm->mb_cols;
2700 // this frame refreshes means next frames don't unless specified by user
2701 cpi->common.frames_since_golden = 0;
2703 // Clear the alternate reference update pending flag.
2704 cpi->source_alt_ref_pending = 0;
2706 // Set the alternate refernce frame active flag
2707 cpi->source_alt_ref_active = 1;
2711 static void update_golden_frame_stats(VP8_COMP *cpi)
2713 VP8_COMMON *cm = &cpi->common;
2715 // Update the Golden frame usage counts.
2716 if (cm->refresh_golden_frame)
2718 // Select an interval before next GF
2719 if (!cpi->auto_gold)
2720 cpi->frames_till_gf_update_due = cpi->goldfreq;
2722 if ((cpi->pass != 2) && (cpi->frames_till_gf_update_due > 0))
2724 cpi->current_gf_interval = cpi->frames_till_gf_update_due;
2726 // Set the bits per frame that we should try and recover in subsequent inter frames
2727 // to account for the extra GF spend... note that his does not apply for GF updates
2728 // that occur coincident with a key frame as the extra cost of key frames is dealt
2730 if ((cm->frame_type != KEY_FRAME) && !cpi->source_alt_ref_active)
2732 // Calcluate GF bits to be recovered
2733 // Projected size - av frame bits available for inter frames for clip as a whole
2734 cpi->gf_overspend_bits += (cpi->projected_frame_size - cpi->inter_frame_target);
2737 cpi->non_gf_bitrate_adjustment = cpi->gf_overspend_bits / cpi->frames_till_gf_update_due;
2741 // Update data structure that monitors level of reference to last GF
2742 vpx_memset(cpi->gf_active_flags, 1, (cm->mb_rows * cm->mb_cols));
2743 cpi->gf_active_count = cm->mb_rows * cm->mb_cols;
2745 // this frame refreshes means next frames don't unless specified by user
2746 cm->refresh_golden_frame = 0;
2747 cpi->common.frames_since_golden = 0;
2749 //if ( cm->frame_type == KEY_FRAME )
2751 cpi->recent_ref_frame_usage[INTRA_FRAME] = 1;
2752 cpi->recent_ref_frame_usage[LAST_FRAME] = 1;
2753 cpi->recent_ref_frame_usage[GOLDEN_FRAME] = 1;
2754 cpi->recent_ref_frame_usage[ALTREF_FRAME] = 1;
2758 // // Carry a potrtion of count over to begining of next gf sequence
2759 // cpi->recent_ref_frame_usage[INTRA_FRAME] >>= 5;
2760 // cpi->recent_ref_frame_usage[LAST_FRAME] >>= 5;
2761 // cpi->recent_ref_frame_usage[GOLDEN_FRAME] >>= 5;
2762 // cpi->recent_ref_frame_usage[ALTREF_FRAME] >>= 5;
2765 // ******** Fixed Q test code only ************
2766 // If we are going to use the ALT reference for the next group of frames set a flag to say so.
2767 if (cpi->oxcf.fixed_q >= 0 &&
2768 cpi->oxcf.play_alternate && !cpi->common.refresh_alt_ref_frame)
2770 cpi->source_alt_ref_pending = 1;
2771 cpi->frames_till_gf_update_due = cpi->baseline_gf_interval;
2774 if (!cpi->source_alt_ref_pending)
2775 cpi->source_alt_ref_active = 0;
2777 // Decrement count down till next gf
2778 if (cpi->frames_till_gf_update_due > 0)
2779 cpi->frames_till_gf_update_due--;
2782 else if (!cpi->common.refresh_alt_ref_frame)
2784 // Decrement count down till next gf
2785 if (cpi->frames_till_gf_update_due > 0)
2786 cpi->frames_till_gf_update_due--;
2788 if (cpi->common.frames_till_alt_ref_frame)
2789 cpi->common.frames_till_alt_ref_frame --;
2791 cpi->common.frames_since_golden ++;
2793 if (cpi->common.frames_since_golden > 1)
2795 cpi->recent_ref_frame_usage[INTRA_FRAME] += cpi->count_mb_ref_frame_usage[INTRA_FRAME];
2796 cpi->recent_ref_frame_usage[LAST_FRAME] += cpi->count_mb_ref_frame_usage[LAST_FRAME];
2797 cpi->recent_ref_frame_usage[GOLDEN_FRAME] += cpi->count_mb_ref_frame_usage[GOLDEN_FRAME];
2798 cpi->recent_ref_frame_usage[ALTREF_FRAME] += cpi->count_mb_ref_frame_usage[ALTREF_FRAME];
2803 // This function updates the reference frame probability estimates that
2804 // will be used during mode selection
2805 static void update_rd_ref_frame_probs(VP8_COMP *cpi)
2807 VP8_COMMON *cm = &cpi->common;
2809 const int *const rfct = cpi->count_mb_ref_frame_usage;
2810 const int rf_intra = rfct[INTRA_FRAME];
2811 const int rf_inter = rfct[LAST_FRAME] + rfct[GOLDEN_FRAME] + rfct[ALTREF_FRAME];
2813 if (cm->frame_type == KEY_FRAME)
2815 cpi->prob_intra_coded = 255;
2816 cpi->prob_last_coded = 128;
2817 cpi->prob_gf_coded = 128;
2819 else if (!(rf_intra + rf_inter))
2821 cpi->prob_intra_coded = 63;
2822 cpi->prob_last_coded = 128;
2823 cpi->prob_gf_coded = 128;
2826 // update reference frame costs since we can do better than what we got last frame.
2827 if (cpi->oxcf.number_of_layers == 1)
2829 if (cpi->common.refresh_alt_ref_frame)
2831 cpi->prob_intra_coded += 40;
2832 cpi->prob_last_coded = 200;
2833 cpi->prob_gf_coded = 1;
2835 else if (cpi->common.frames_since_golden == 0)
2837 cpi->prob_last_coded = 214;
2839 else if (cpi->common.frames_since_golden == 1)
2841 cpi->prob_last_coded = 192;
2842 cpi->prob_gf_coded = 220;
2844 else if (cpi->source_alt_ref_active)
2846 cpi->prob_gf_coded -= 20;
2848 if (cpi->prob_gf_coded < 10)
2849 cpi->prob_gf_coded = 10;
2851 if (!cpi->source_alt_ref_active)
2852 cpi->prob_gf_coded = 255;
2857 // 1 = key, 0 = inter
2858 static int decide_key_frame(VP8_COMP *cpi)
2860 VP8_COMMON *cm = &cpi->common;
2862 int code_key_frame = 0;
2866 if (cpi->Speed > 11)
2869 // Clear down mmx registers
2870 vp8_clear_system_state(); //__asm emms;
2872 if ((cpi->compressor_speed == 2) && (cpi->Speed >= 5) && (cpi->sf.RD == 0))
2874 double change = 1.0 * abs((int)(cpi->intra_error - cpi->last_intra_error)) / (1 + cpi->last_intra_error);
2875 double change2 = 1.0 * abs((int)(cpi->prediction_error - cpi->last_prediction_error)) / (1 + cpi->last_prediction_error);
2876 double minerror = cm->MBs * 256;
2880 if (10 * cpi->intra_error / (1 + cpi->prediction_error) < 15
2881 && cpi->prediction_error > minerror
2882 && (change > .25 || change2 > .25))
2884 FILE *f = fopen("intra_inter.stt", "a");
2886 if (cpi->prediction_error <= 0)
2887 cpi->prediction_error = 1;
2889 fprintf(f, "%d %d %d %d %14.4f\n",
2890 cm->current_video_frame,
2891 (int) cpi->prediction_error,
2892 (int) cpi->intra_error,
2893 (int)((10 * cpi->intra_error) / cpi->prediction_error),
2901 cpi->last_intra_error = cpi->intra_error;
2902 cpi->last_prediction_error = cpi->prediction_error;
2904 if (10 * cpi->intra_error / (1 + cpi->prediction_error) < 15
2905 && cpi->prediction_error > minerror
2906 && (change > .25 || change2 > .25))
2908 /*(change > 1.4 || change < .75)&& cpi->this_frame_percent_intra > cpi->last_frame_percent_intra + 3*/
2916 // If the following are true we might as well code a key frame
2917 if (((cpi->this_frame_percent_intra == 100) &&
2918 (cpi->this_frame_percent_intra > (cpi->last_frame_percent_intra + 2))) ||
2919 ((cpi->this_frame_percent_intra > 95) &&
2920 (cpi->this_frame_percent_intra >= (cpi->last_frame_percent_intra + 5))))
2924 // in addition if the following are true and this is not a golden frame then code a key frame
2925 // Note that on golden frames there often seems to be a pop in intra useage anyway hence this
2926 // restriction is designed to prevent spurious key frames. The Intra pop needs to be investigated.
2927 else if (((cpi->this_frame_percent_intra > 60) &&
2928 (cpi->this_frame_percent_intra > (cpi->last_frame_percent_intra * 2))) ||
2929 ((cpi->this_frame_percent_intra > 75) &&
2930 (cpi->this_frame_percent_intra > (cpi->last_frame_percent_intra * 3 / 2))) ||
2931 ((cpi->this_frame_percent_intra > 90) &&
2932 (cpi->this_frame_percent_intra > (cpi->last_frame_percent_intra + 10))))
2934 if (!cm->refresh_golden_frame)
2938 return code_key_frame;
2942 #if !(CONFIG_REALTIME_ONLY)
2943 static void Pass1Encode(VP8_COMP *cpi, unsigned long *size, unsigned char *dest, unsigned int *frame_flags)
2948 vp8_set_quantizer(cpi, 26);
2950 vp8_first_pass(cpi);
2955 void write_cx_frame_to_file(YV12_BUFFER_CONFIG *frame, int this_frame)
2963 sprintf(filename, "cx\\y%04d.raw", this_frame);
2964 yframe = fopen(filename, "wb");
2966 for (i = 0; i < frame->y_height; i++)
2967 fwrite(frame->y_buffer + i * frame->y_stride, frame->y_width, 1, yframe);
2970 sprintf(filename, "cx\\u%04d.raw", this_frame);
2971 yframe = fopen(filename, "wb");
2973 for (i = 0; i < frame->uv_height; i++)
2974 fwrite(frame->u_buffer + i * frame->uv_stride, frame->uv_width, 1, yframe);
2977 sprintf(filename, "cx\\v%04d.raw", this_frame);
2978 yframe = fopen(filename, "wb");
2980 for (i = 0; i < frame->uv_height; i++)
2981 fwrite(frame->v_buffer + i * frame->uv_stride, frame->uv_width, 1, yframe);
2986 // return of 0 means drop frame
2988 // Function to test for conditions that indeicate we should loop
2989 // back and recode a frame.
2990 static int recode_loop_test( VP8_COMP *cpi,
2991 int high_limit, int low_limit,
2992 int q, int maxq, int minq )
2994 int force_recode = 0;
2995 VP8_COMMON *cm = &cpi->common;
2997 // Is frame recode allowed at all
2998 // Yes if either recode mode 1 is selected or mode two is selcted
2999 // and the frame is a key frame. golden frame or alt_ref_frame
3000 if ( (cpi->sf.recode_loop == 1) ||
3001 ( (cpi->sf.recode_loop == 2) &&
3002 ( (cm->frame_type == KEY_FRAME) ||
3003 cm->refresh_golden_frame ||
3004 cm->refresh_alt_ref_frame ) ) )
3006 // General over and under shoot tests
3007 if ( ((cpi->projected_frame_size > high_limit) && (q < maxq)) ||
3008 ((cpi->projected_frame_size < low_limit) && (q > minq)) )
3012 // Special Constrained quality tests
3013 else if (cpi->oxcf.end_usage == USAGE_CONSTRAINED_QUALITY)
3015 // Undershoot and below auto cq level
3016 if ( (q > cpi->cq_target_quality) &&
3017 (cpi->projected_frame_size <
3018 ((cpi->this_frame_target * 7) >> 3)))
3022 // Severe undershoot and between auto and user cq level
3023 else if ( (q > cpi->oxcf.cq_level) &&
3024 (cpi->projected_frame_size < cpi->min_frame_bandwidth) &&
3025 (cpi->active_best_quality > cpi->oxcf.cq_level))
3028 cpi->active_best_quality = cpi->oxcf.cq_level;
3033 return force_recode;
3036 void update_reference_frames(VP8_COMMON *cm)
3038 YV12_BUFFER_CONFIG *yv12_fb = cm->yv12_fb;
3040 // At this point the new frame has been encoded.
3041 // If any buffer copy / swapping is signaled it should be done here.
3043 if (cm->frame_type == KEY_FRAME)
3045 yv12_fb[cm->new_fb_idx].flags |= VP8_GOLD_FLAG | VP8_ALT_FLAG ;
3047 yv12_fb[cm->gld_fb_idx].flags &= ~VP8_GOLD_FLAG;
3048 yv12_fb[cm->alt_fb_idx].flags &= ~VP8_ALT_FLAG;
3050 cm->alt_fb_idx = cm->gld_fb_idx = cm->new_fb_idx;
3052 else /* For non key frames */
3054 if (cm->refresh_alt_ref_frame)
3056 assert(!cm->copy_buffer_to_arf);
3058 cm->yv12_fb[cm->new_fb_idx].flags |= VP8_ALT_FLAG;
3059 cm->yv12_fb[cm->alt_fb_idx].flags &= ~VP8_ALT_FLAG;
3060 cm->alt_fb_idx = cm->new_fb_idx;
3062 else if (cm->copy_buffer_to_arf)
3064 assert(!(cm->copy_buffer_to_arf & ~0x3));
3066 if (cm->copy_buffer_to_arf == 1)
3068 if(cm->alt_fb_idx != cm->lst_fb_idx)
3070 yv12_fb[cm->lst_fb_idx].flags |= VP8_ALT_FLAG;
3071 yv12_fb[cm->alt_fb_idx].flags &= ~VP8_ALT_FLAG;
3072 cm->alt_fb_idx = cm->lst_fb_idx;
3075 else /* if (cm->copy_buffer_to_arf == 2) */
3077 if(cm->alt_fb_idx != cm->gld_fb_idx)
3079 yv12_fb[cm->gld_fb_idx].flags |= VP8_ALT_FLAG;
3080 yv12_fb[cm->alt_fb_idx].flags &= ~VP8_ALT_FLAG;
3081 cm->alt_fb_idx = cm->gld_fb_idx;
3086 if (cm->refresh_golden_frame)
3088 assert(!cm->copy_buffer_to_gf);
3090 cm->yv12_fb[cm->new_fb_idx].flags |= VP8_GOLD_FLAG;
3091 cm->yv12_fb[cm->gld_fb_idx].flags &= ~VP8_GOLD_FLAG;
3092 cm->gld_fb_idx = cm->new_fb_idx;
3094 else if (cm->copy_buffer_to_gf)
3096 assert(!(cm->copy_buffer_to_arf & ~0x3));
3098 if (cm->copy_buffer_to_gf == 1)
3100 if(cm->gld_fb_idx != cm->lst_fb_idx)
3102 yv12_fb[cm->lst_fb_idx].flags |= VP8_GOLD_FLAG;
3103 yv12_fb[cm->gld_fb_idx].flags &= ~VP8_GOLD_FLAG;
3104 cm->gld_fb_idx = cm->lst_fb_idx;
3107 else /* if (cm->copy_buffer_to_gf == 2) */
3109 if(cm->alt_fb_idx != cm->gld_fb_idx)
3111 yv12_fb[cm->alt_fb_idx].flags |= VP8_GOLD_FLAG;
3112 yv12_fb[cm->gld_fb_idx].flags &= ~VP8_GOLD_FLAG;
3113 cm->gld_fb_idx = cm->alt_fb_idx;
3119 if (cm->refresh_last_frame)
3121 cm->yv12_fb[cm->new_fb_idx].flags |= VP8_LAST_FLAG;
3122 cm->yv12_fb[cm->lst_fb_idx].flags &= ~VP8_LAST_FLAG;
3123 cm->lst_fb_idx = cm->new_fb_idx;
3127 void vp8_loopfilter_frame(VP8_COMP *cpi, VP8_COMMON *cm)
3131 cm->filter_level = 0;
3135 struct vpx_usec_timer timer;
3137 vp8_clear_system_state();
3139 vpx_usec_timer_start(&timer);
3140 if (cpi->sf.auto_filter == 0)
3141 vp8cx_pick_filter_level_fast(cpi->Source, cpi);
3144 vp8cx_pick_filter_level(cpi->Source, cpi);
3146 vpx_usec_timer_mark(&timer);
3147 cpi->time_pick_lpf += vpx_usec_timer_elapsed(&timer);
3150 #if CONFIG_MULTITHREAD
3151 if (cpi->b_multi_threaded)
3152 sem_post(&cpi->h_event_end_lpf); /* signal that we have set filter_level */
3155 if (cm->filter_level > 0)
3157 vp8cx_set_alt_lf_level(cpi, cm->filter_level);
3158 vp8_loop_filter_frame(cm, &cpi->mb.e_mbd);
3161 vp8_yv12_extend_frame_borders_ptr(cm->frame_to_show);
3162 #if CONFIG_TEMPORAL_DENOISING
3163 if (cpi->oxcf.noise_sensitivity)
3165 vp8_yv12_extend_frame_borders(&cpi->denoiser.yv12_running_avg);
3170 static void encode_frame_to_data_rate
3173 unsigned long *size,
3174 unsigned char *dest,
3175 unsigned char* dest_end,
3176 unsigned int *frame_flags
3180 int frame_over_shoot_limit;
3181 int frame_under_shoot_limit;
3186 VP8_COMMON *cm = &cpi->common;
3187 int active_worst_qchanged = 0;
3189 #if !(CONFIG_REALTIME_ONLY)
3193 int zbin_oq_low = 0;
3196 int overshoot_seen = 0;
3197 int undershoot_seen = 0;
3200 int drop_mark = cpi->oxcf.drop_frames_water_mark * cpi->oxcf.optimal_buffer_level / 100;
3201 int drop_mark75 = drop_mark * 2 / 3;
3202 int drop_mark50 = drop_mark / 4;
3203 int drop_mark25 = drop_mark / 8;
3206 // Clear down mmx registers to allow floating point in what follows
3207 vp8_clear_system_state();
3209 #if CONFIG_MULTITHREAD
3210 /* wait for the last picture loopfilter thread done */
3211 if (cpi->b_lpf_running)
3213 sem_wait(&cpi->h_event_end_lpf);
3214 cpi->b_lpf_running = 0;
3218 // Test code for segmentation of gf/arf (0,0)
3219 //segmentation_test_function( cpi);
3221 if(cpi->force_next_frame_intra)
3223 cm->frame_type = KEY_FRAME; /* delayed intra frame */
3224 cpi->force_next_frame_intra = 0;
3227 // For an alt ref frame in 2 pass we skip the call to the second pass function that sets the target bandwidth
3228 #if !(CONFIG_REALTIME_ONLY)
3232 if (cpi->common.refresh_alt_ref_frame)
3234 cpi->per_frame_bandwidth = cpi->twopass.gf_bits; // Per frame bit target for the alt ref frame
3235 cpi->target_bandwidth = cpi->twopass.gf_bits * cpi->output_frame_rate; // per second target bitrate
3240 cpi->per_frame_bandwidth = (int)(cpi->target_bandwidth / cpi->output_frame_rate);
3242 // Default turn off buffer to buffer copying
3243 cm->copy_buffer_to_gf = 0;
3244 cm->copy_buffer_to_arf = 0;
3246 // Clear zbin over-quant value and mode boost values.
3247 cpi->zbin_over_quant = 0;
3248 cpi->zbin_mode_boost = 0;
3250 // Enable or disable mode based tweaking of the zbin
3251 // For 2 Pass Only used where GF/ARF prediction quality
3252 // is above a threshold
3253 cpi->zbin_mode_boost_enabled = 1;
3256 if ( cpi->gfu_boost <= 400 )
3258 cpi->zbin_mode_boost_enabled = 0;
3262 // Current default encoder behaviour for the altref sign bias
3263 if (cpi->source_alt_ref_active)
3264 cpi->common.ref_frame_sign_bias[ALTREF_FRAME] = 1;
3266 cpi->common.ref_frame_sign_bias[ALTREF_FRAME] = 0;
3268 // Check to see if a key frame is signalled
3269 // For two pass with auto key frame enabled cm->frame_type may already be set, but not for one pass.
3270 if ((cm->current_video_frame == 0) ||
3271 (cm->frame_flags & FRAMEFLAGS_KEY) ||
3272 (cpi->oxcf.auto_key && (cpi->frames_since_key % cpi->key_frame_frequency == 0)))
3274 // Key frame from VFW/auto-keyframe/first frame
3275 cm->frame_type = KEY_FRAME;
3278 // Set default state for segment and mode based loop filter update flags
3279 cpi->mb.e_mbd.update_mb_segmentation_map = 0;
3280 cpi->mb.e_mbd.update_mb_segmentation_data = 0;
3281 cpi->mb.e_mbd.mode_ref_lf_delta_update = 0;
3283 // Set various flags etc to special state if it is a key frame
3284 if (cm->frame_type == KEY_FRAME)
3288 // Reset the loop filter deltas and segmentation map
3289 setup_features(cpi);
3291 // If segmentation is enabled force a map update for key frames
3292 if (cpi->mb.e_mbd.segmentation_enabled)
3294 cpi->mb.e_mbd.update_mb_segmentation_map = 1;
3295 cpi->mb.e_mbd.update_mb_segmentation_data = 1;
3298 // The alternate reference frame cannot be active for a key frame
3299 cpi->source_alt_ref_active = 0;
3301 // Reset the RD threshold multipliers to default of * 1 (128)
3302 for (i = 0; i < MAX_MODES; i++)
3304 cpi->rd_thresh_mult[i] = 128;
3308 // Test code for segmentation
3309 //if ( (cm->frame_type == KEY_FRAME) || ((cm->current_video_frame % 2) == 0))
3310 //if ( (cm->current_video_frame % 2) == 0 )
3311 // enable_segmentation(cpi);
3313 // disable_segmentation(cpi);
3316 // Experimental code for lagged compress and one pass
3317 // Initialise one_pass GF frames stats
3318 // Update stats used for GF selection
3319 //if ( cpi->pass == 0 )
3321 cpi->one_pass_frame_index = cm->current_video_frame % MAX_LAG_BUFFERS;
3323 cpi->one_pass_frame_stats[cpi->one_pass_frame_index ].frames_so_far = 0;
3324 cpi->one_pass_frame_stats[cpi->one_pass_frame_index ].frame_intra_error = 0.0;
3325 cpi->one_pass_frame_stats[cpi->one_pass_frame_index ].frame_coded_error = 0.0;
3326 cpi->one_pass_frame_stats[cpi->one_pass_frame_index ].frame_pcnt_inter = 0.0;
3327 cpi->one_pass_frame_stats[cpi->one_pass_frame_index ].frame_pcnt_motion = 0.0;
3328 cpi->one_pass_frame_stats[cpi->one_pass_frame_index ].frame_mvr = 0.0;
3329 cpi->one_pass_frame_stats[cpi->one_pass_frame_index ].frame_mvr_abs = 0.0;
3330 cpi->one_pass_frame_stats[cpi->one_pass_frame_index ].frame_mvc = 0.0;
3331 cpi->one_pass_frame_stats[cpi->one_pass_frame_index ].frame_mvc_abs = 0.0;
3335 update_rd_ref_frame_probs(cpi);
3337 if (cpi->drop_frames_allowed)
3339 // The reset to decimation 0 is only done here for one pass.
3340 // Once it is set two pass leaves decimation on till the next kf.
3341 if ((cpi->buffer_level > drop_mark) && (cpi->decimation_factor > 0))
3342 cpi->decimation_factor --;
3344 if (cpi->buffer_level > drop_mark75 && cpi->decimation_factor > 0)
3345 cpi->decimation_factor = 1;
3347 else if (cpi->buffer_level < drop_mark25 && (cpi->decimation_factor == 2 || cpi->decimation_factor == 3))
3349 cpi->decimation_factor = 3;
3351 else if (cpi->buffer_level < drop_mark50 && (cpi->decimation_factor == 1 || cpi->decimation_factor == 2))
3353 cpi->decimation_factor = 2;
3355 else if (cpi->buffer_level < drop_mark75 && (cpi->decimation_factor == 0 || cpi->decimation_factor == 1))
3357 cpi->decimation_factor = 1;
3359 //vpx_log("Encoder: Decimation Factor: %d \n",cpi->decimation_factor);
3362 // The following decimates the frame rate according to a regular pattern (i.e. to 1/2 or 2/3 frame rate)
3363 // This can be used to help prevent buffer under-run in CBR mode. Alternatively it might be desirable in
3364 // some situations to drop frame rate but throw more bits at each frame.
3366 // Note that dropping a key frame can be problematic if spatial resampling is also active
3367 if (cpi->decimation_factor > 0)
3369 switch (cpi->decimation_factor)
3372 cpi->per_frame_bandwidth = cpi->per_frame_bandwidth * 3 / 2;
3375 cpi->per_frame_bandwidth = cpi->per_frame_bandwidth * 5 / 4;
3378 cpi->per_frame_bandwidth = cpi->per_frame_bandwidth * 5 / 4;
3382 // Note that we should not throw out a key frame (especially when spatial resampling is enabled).
3383 if ((cm->frame_type == KEY_FRAME)) // && cpi->oxcf.allow_spatial_resampling )
3385 cpi->decimation_count = cpi->decimation_factor;
3387 else if (cpi->decimation_count > 0)
3389 cpi->decimation_count --;
3391 cpi->bits_off_target += cpi->av_per_frame_bandwidth;
3392 if (cpi->bits_off_target > cpi->oxcf.maximum_buffer_size)
3393 cpi->bits_off_target = cpi->oxcf.maximum_buffer_size;
3395 cm->current_video_frame++;
3396 cpi->frames_since_key++;
3398 #if CONFIG_INTERNAL_STATS
3402 cpi->buffer_level = cpi->bits_off_target;
3404 if (cpi->oxcf.number_of_layers > 1)
3408 // Propagate bits saved by dropping the frame to higher layers
3409 for (i=cpi->current_layer+1; i<cpi->oxcf.number_of_layers; i++)
3411 LAYER_CONTEXT *lc = &cpi->layer_context[i];
3412 lc->bits_off_target += cpi->av_per_frame_bandwidth;
3413 if (lc->bits_off_target > lc->maximum_buffer_size)
3414 lc->bits_off_target = lc->maximum_buffer_size;
3415 lc->buffer_level = lc->bits_off_target;
3422 cpi->decimation_count = cpi->decimation_factor;
3425 // Decide how big to make the frame
3426 if (!vp8_pick_frame_size(cpi))
3428 cm->current_video_frame++;
3429 cpi->frames_since_key++;
3433 // Reduce active_worst_allowed_q for CBR if our buffer is getting too full.
3434 // This has a knock on effect on active best quality as well.
3435 // For CBR if the buffer reaches its maximum level then we can no longer
3436 // save up bits for later frames so we might as well use them up
3437 // on the current frame.
3438 if ((cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER) &&
3439 (cpi->buffer_level >= cpi->oxcf.optimal_buffer_level) && cpi->buffered_mode)
3441 int Adjustment = cpi->active_worst_quality / 4; // Max adjustment is 1/4
3447 if (cpi->buffer_level < cpi->oxcf.maximum_buffer_size)
3449 buff_lvl_step = (cpi->oxcf.maximum_buffer_size - cpi->oxcf.optimal_buffer_level) / Adjustment;
3452 Adjustment = (cpi->buffer_level - cpi->oxcf.optimal_buffer_level) / buff_lvl_step;
3457 cpi->active_worst_quality -= Adjustment;
3459 if(cpi->active_worst_quality < cpi->active_best_quality)
3460 cpi->active_worst_quality = cpi->active_best_quality;
3464 // Set an active best quality and if necessary active worst quality
3465 // There is some odd behavior for one pass here that needs attention.
3466 if ( (cpi->pass == 2) || (cpi->ni_frames > 150))
3468 vp8_clear_system_state();
3470 Q = cpi->active_worst_quality;
3472 if ( cm->frame_type == KEY_FRAME )
3474 if ( cpi->pass == 2 )
3476 if (cpi->gfu_boost > 600)
3477 cpi->active_best_quality = kf_low_motion_minq[Q];
3479 cpi->active_best_quality = kf_high_motion_minq[Q];
3481 // Special case for key frames forced because we have reached
3482 // the maximum key frame interval. Here force the Q to a range
3483 // based on the ambient Q to reduce the risk of popping
3484 if ( cpi->this_key_frame_forced )
3486 if ( cpi->active_best_quality > cpi->avg_frame_qindex * 7/8)
3487 cpi->active_best_quality = cpi->avg_frame_qindex * 7/8;
3488 else if ( cpi->active_best_quality < cpi->avg_frame_qindex >> 2 )
3489 cpi->active_best_quality = cpi->avg_frame_qindex >> 2;
3492 // One pass more conservative
3494 cpi->active_best_quality = kf_high_motion_minq[Q];
3497 else if (cpi->oxcf.number_of_layers==1 &&
3498 (cm->refresh_golden_frame || cpi->common.refresh_alt_ref_frame))
3500 // Use the lower of cpi->active_worst_quality and recent
3501 // average Q as basis for GF/ARF Q limit unless last frame was
3503 if ( (cpi->frames_since_key > 1) &&
3504 (cpi->avg_frame_qindex < cpi->active_worst_quality) )
3506 Q = cpi->avg_frame_qindex;
3509 // For constrained quality dont allow Q less than the cq level
3510 if ( (cpi->oxcf.end_usage == USAGE_CONSTRAINED_QUALITY) &&
3511 (Q < cpi->cq_target_quality) )
3513 Q = cpi->cq_target_quality;
3516 if ( cpi->pass == 2 )
3518 if ( cpi->gfu_boost > 1000 )
3519 cpi->active_best_quality = gf_low_motion_minq[Q];
3520 else if ( cpi->gfu_boost < 400 )
3521 cpi->active_best_quality = gf_high_motion_minq[Q];
3523 cpi->active_best_quality = gf_mid_motion_minq[Q];
3525 // Constrained quality use slightly lower active best.
3526 if ( cpi->oxcf.end_usage == USAGE_CONSTRAINED_QUALITY )
3528 cpi->active_best_quality =
3529 cpi->active_best_quality * 15/16;
3532 // One pass more conservative
3534 cpi->active_best_quality = gf_high_motion_minq[Q];
3538 cpi->active_best_quality = inter_minq[Q];
3540 // For the constant/constrained quality mode we dont want
3541 // q to fall below the cq level.
3542 if ((cpi->oxcf.end_usage == USAGE_CONSTRAINED_QUALITY) &&
3543 (cpi->active_best_quality < cpi->cq_target_quality) )
3545 // If we are strongly undershooting the target rate in the last
3546 // frames then use the user passed in cq value not the auto
3548 if ( cpi->rolling_actual_bits < cpi->min_frame_bandwidth )
3549 cpi->active_best_quality = cpi->oxcf.cq_level;
3551 cpi->active_best_quality = cpi->cq_target_quality;
3555 // If CBR and the buffer is as full then it is reasonable to allow
3556 // higher quality on the frames to prevent bits just going to waste.
3557 if (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER)
3559 // Note that the use of >= here elliminates the risk of a devide
3560 // by 0 error in the else if clause
3561 if (cpi->buffer_level >= cpi->oxcf.maximum_buffer_size)
3562 cpi->active_best_quality = cpi->best_quality;
3564 else if (cpi->buffer_level > cpi->oxcf.optimal_buffer_level)
3566 int Fraction = ((cpi->buffer_level - cpi->oxcf.optimal_buffer_level) * 128) / (cpi->oxcf.maximum_buffer_size - cpi->oxcf.optimal_buffer_level);
3567 int min_qadjustment = ((cpi->active_best_quality - cpi->best_quality) * Fraction) / 128;
3569 cpi->active_best_quality -= min_qadjustment;
3573 // Make sure constrained quality mode limits are adhered to for the first
3574 // few frames of one pass encodes
3575 else if (cpi->oxcf.end_usage == USAGE_CONSTRAINED_QUALITY)
3577 if ( (cm->frame_type == KEY_FRAME) ||
3578 cm->refresh_golden_frame || cpi->common.refresh_alt_ref_frame )
3580 cpi->active_best_quality = cpi->best_quality;
3582 else if (cpi->active_best_quality < cpi->cq_target_quality)
3584 cpi->active_best_quality = cpi->cq_target_quality;
3588 // Clip the active best and worst quality values to limits
3589 if (cpi->active_worst_quality > cpi->worst_quality)
3590 cpi->active_worst_quality = cpi->worst_quality;
3592 if (cpi->active_best_quality < cpi->best_quality)
3593 cpi->active_best_quality = cpi->best_quality;
3595 if ( cpi->active_worst_quality < cpi->active_best_quality )
3596 cpi->active_worst_quality = cpi->active_best_quality;
3598 // Determine initial Q to try
3599 Q = vp8_regulate_q(cpi, cpi->this_frame_target);
3601 #if !(CONFIG_REALTIME_ONLY)
3603 // Set highest allowed value for Zbin over quant
3604 if (cm->frame_type == KEY_FRAME)
3605 zbin_oq_high = 0; //ZBIN_OQ_MAX/16
3606 else if ((cpi->oxcf.number_of_layers == 1) && ((cm->refresh_alt_ref_frame ||
3607 (cm->refresh_golden_frame && !cpi->source_alt_ref_active))))
3612 zbin_oq_high = ZBIN_OQ_MAX;
3615 // Setup background Q adjustment for error resilient mode.
3616 // For multi-layer encodes only enable this for the base layer.
3617 if (cpi->cyclic_refresh_mode_enabled && (cpi->current_layer==0))
3618 cyclic_background_refresh(cpi, Q, 0);
3620 vp8_compute_frame_size_bounds(cpi, &frame_under_shoot_limit, &frame_over_shoot_limit);
3622 #if !(CONFIG_REALTIME_ONLY)
3623 // Limit Q range for the adaptive loop.
3624 bottom_index = cpi->active_best_quality;
3625 top_index = cpi->active_worst_quality;
3626 q_low = cpi->active_best_quality;
3627 q_high = cpi->active_worst_quality;
3630 vp8_save_coding_context(cpi);
3634 scale_and_extend_source(cpi->un_scaled_source, cpi);
3636 #if !(CONFIG_REALTIME_ONLY) && CONFIG_POSTPROC && !(CONFIG_TEMPORAL_DENOISING)
3638 if (cpi->oxcf.noise_sensitivity > 0)
3643 switch (cpi->oxcf.noise_sensitivity)
3666 if (cm->frame_type == KEY_FRAME)
3668 vp8_de_noise(cpi->Source, cpi->Source, l , 1, 0);
3672 vp8_de_noise(cpi->Source, cpi->Source, l , 1, 0);
3674 src = cpi->Source->y_buffer;
3676 if (cpi->Source->y_stride < 0)
3678 src += cpi->Source->y_stride * (cpi->Source->y_height - 1);
3685 #ifdef OUTPUT_YUV_SRC
3686 vp8_write_yuv_frame(cpi->Source);
3691 vp8_clear_system_state(); //__asm emms;
3694 if(cpi->is_src_frame_alt_ref)
3698 vp8_set_quantizer(cpi, Q);
3700 // setup skip prob for costing in mode/mv decision
3701 if (cpi->common.mb_no_coeff_skip)
3703 cpi->prob_skip_false = cpi->base_skip_false_prob[Q];
3705 if (cm->frame_type != KEY_FRAME)
3707 if (cpi->common.refresh_alt_ref_frame)
3709 if (cpi->last_skip_false_probs[2] != 0)
3710 cpi->prob_skip_false = cpi->last_skip_false_probs[2];
3713 if(cpi->last_skip_false_probs[2]!=0 && abs(Q- cpi->last_skip_probs_q[2])<=16 )
3714 cpi->prob_skip_false = cpi->last_skip_false_probs[2];
3715 else if (cpi->last_skip_false_probs[2]!=0)
3716 cpi->prob_skip_false = (cpi->last_skip_false_probs[2] + cpi->prob_skip_false ) / 2;
3719 else if (cpi->common.refresh_golden_frame)
3721 if (cpi->last_skip_false_probs[1] != 0)
3722 cpi->prob_skip_false = cpi->last_skip_false_probs[1];
3725 if(cpi->last_skip_false_probs[1]!=0 && abs(Q- cpi->last_skip_probs_q[1])<=16 )
3726 cpi->prob_skip_false = cpi->last_skip_false_probs[1];
3727 else if (cpi->last_skip_false_probs[1]!=0)
3728 cpi->prob_skip_false = (cpi->last_skip_false_probs[1] + cpi->prob_skip_false ) / 2;
3733 if (cpi->last_skip_false_probs[0] != 0)
3734 cpi->prob_skip_false = cpi->last_skip_false_probs[0];
3737 if(cpi->last_skip_false_probs[0]!=0 && abs(Q- cpi->last_skip_probs_q[0])<=16 )
3738 cpi->prob_skip_false = cpi->last_skip_false_probs[0];
3739 else if(cpi->last_skip_false_probs[0]!=0)
3740 cpi->prob_skip_false = (cpi->last_skip_false_probs[0] + cpi->prob_skip_false ) / 2;
3744 //as this is for cost estimate, let's make sure it does not go extreme eitehr way
3745 if (cpi->prob_skip_false < 5)
3746 cpi->prob_skip_false = 5;
3748 if (cpi->prob_skip_false > 250)
3749 cpi->prob_skip_false = 250;
3751 if (cpi->oxcf.number_of_layers == 1 && cpi->is_src_frame_alt_ref)
3752 cpi->prob_skip_false = 1;
3759 FILE *f = fopen("skip.stt", "a");
3760 fprintf(f, "%d, %d, %4d ", cpi->common.refresh_golden_frame, cpi->common.refresh_alt_ref_frame, cpi->prob_skip_false);
3768 if (cm->frame_type == KEY_FRAME)
3770 resize_key_frame(cpi);
3771 vp8_setup_key_frame(cpi);
3776 #if CONFIG_REALTIME_ONLY & CONFIG_ONTHEFLY_BITPACKING
3778 if(cpi->oxcf.error_resilient_mode)
3779 cm->refresh_entropy_probs = 0;
3781 if (cpi->oxcf.error_resilient_mode & VPX_ERROR_RESILIENT_PARTITIONS)
3783 if (cm->frame_type == KEY_FRAME)
3784 cm->refresh_entropy_probs = 1;
3787 if (cm->refresh_entropy_probs == 0)
3789 // save a copy for later refresh
3790 vpx_memcpy(&cm->lfc, &cm->fc, sizeof(cm->fc));
3793 vp8_update_coef_context(cpi);
3795 vp8_update_coef_probs(cpi);
3797 // transform / motion compensation build reconstruction frame
3798 // +pack coef partitions
3799 vp8_encode_frame(cpi);
3801 /* cpi->projected_frame_size is not needed for RT mode */
3804 // transform / motion compensation build reconstruction frame
3805 vp8_encode_frame(cpi);
3807 cpi->projected_frame_size -= vp8_estimate_entropy_savings(cpi);
3808 cpi->projected_frame_size = (cpi->projected_frame_size > 0) ? cpi->projected_frame_size : 0;
3810 vp8_clear_system_state(); //__asm emms;
3812 // Test to see if the stats generated for this frame indicate that we should have coded a key frame
3813 // (assuming that we didn't)!
3814 if (cpi->pass != 2 && cpi->oxcf.auto_key && cm->frame_type != KEY_FRAME)
3816 int key_frame_decision = decide_key_frame(cpi);
3818 if (cpi->compressor_speed == 2)
3820 /* we don't do re-encoding in realtime mode
3821 * if key frame is decided then we force it on next frame */
3822 cpi->force_next_frame_intra = key_frame_decision;
3824 #if !(CONFIG_REALTIME_ONLY)
3825 else if (key_frame_decision)
3827 // Reset all our sizing numbers and recode
3828 cm->frame_type = KEY_FRAME;
3830 vp8_pick_frame_size(cpi);
3832 // Clear the Alt reference frame active flag when we have a key frame
3833 cpi->source_alt_ref_active = 0;
3835 // Reset the loop filter deltas and segmentation map
3836 setup_features(cpi);
3838 // If segmentation is enabled force a map update for key frames
3839 if (cpi->mb.e_mbd.segmentation_enabled)
3841 cpi->mb.e_mbd.update_mb_segmentation_map = 1;
3842 cpi->mb.e_mbd.update_mb_segmentation_data = 1;
3845 vp8_restore_coding_context(cpi);
3847 Q = vp8_regulate_q(cpi, cpi->this_frame_target);
3849 vp8_compute_frame_size_bounds(cpi, &frame_under_shoot_limit, &frame_over_shoot_limit);
3851 // Limit Q range for the adaptive loop.
3852 bottom_index = cpi->active_best_quality;
3853 top_index = cpi->active_worst_quality;
3854 q_low = cpi->active_best_quality;
3855 q_high = cpi->active_worst_quality;
3865 vp8_clear_system_state();
3867 if (frame_over_shoot_limit == 0)
3868 frame_over_shoot_limit = 1;
3870 // Are we are overshooting and up against the limit of active max Q.
3871 if (((cpi->pass != 2) || (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER)) &&
3872 (Q == cpi->active_worst_quality) &&
3873 (cpi->active_worst_quality < cpi->worst_quality) &&
3874 (cpi->projected_frame_size > frame_over_shoot_limit))
3876 int over_size_percent = ((cpi->projected_frame_size - frame_over_shoot_limit) * 100) / frame_over_shoot_limit;
3878 // If so is there any scope for relaxing it
3879 while ((cpi->active_worst_quality < cpi->worst_quality) && (over_size_percent > 0))
3881 cpi->active_worst_quality++;
3883 over_size_percent = (int)(over_size_percent * 0.96); // Assume 1 qstep = about 4% on frame size.
3885 #if !(CONFIG_REALTIME_ONLY)
3886 top_index = cpi->active_worst_quality;
3888 // If we have updated the active max Q do not call vp8_update_rate_correction_factors() this loop.
3889 active_worst_qchanged = 1;
3892 active_worst_qchanged = 0;
3894 #if !(CONFIG_REALTIME_ONLY)
3895 // Special case handling for forced key frames
3896 if ( (cm->frame_type == KEY_FRAME) && cpi->this_key_frame_forced )
3899 int kf_err = vp8_calc_ss_err(cpi->Source,
3900 &cm->yv12_fb[cm->new_fb_idx]);
3902 // The key frame is not good enough
3903 if ( kf_err > ((cpi->ambient_err * 7) >> 3) )
3906 q_high = (Q > q_low) ? (Q - 1) : q_low;
3909 Q = (q_high + q_low) >> 1;
3911 // The key frame is much better than the previous frame
3912 else if ( kf_err < (cpi->ambient_err >> 1) )
3915 q_low = (Q < q_high) ? (Q + 1) : q_high;
3918 Q = (q_high + q_low + 1) >> 1;
3921 // Clamp Q to upper and lower limits:
3930 // Is the projected frame size out of range and are we allowed to attempt to recode.
3931 else if ( recode_loop_test( cpi,
3932 frame_over_shoot_limit, frame_under_shoot_limit,
3933 Q, top_index, bottom_index ) )
3938 // Frame size out of permitted range:
3939 // Update correction factor & compute new Q to try...
3941 // Frame is too large
3942 if (cpi->projected_frame_size > cpi->this_frame_target)
3944 //if ( cpi->zbin_over_quant == 0 )
3945 q_low = (Q < q_high) ? (Q + 1) : q_high; // Raise Qlow as to at least the current value
3947 if (cpi->zbin_over_quant > 0) // If we are using over quant do the same for zbin_oq_low
3948 zbin_oq_low = (cpi->zbin_over_quant < zbin_oq_high) ? (cpi->zbin_over_quant + 1) : zbin_oq_high;
3950 //if ( undershoot_seen || (Q == MAXQ) )
3951 if (undershoot_seen)
3953 // Update rate_correction_factor unless cpi->active_worst_quality has changed.
3954 if (!active_worst_qchanged)
3955 vp8_update_rate_correction_factors(cpi, 1);
3957 Q = (q_high + q_low + 1) / 2;
3959 // Adjust cpi->zbin_over_quant (only allowed when Q is max)
3961 cpi->zbin_over_quant = 0;
3964 zbin_oq_low = (cpi->zbin_over_quant < zbin_oq_high) ? (cpi->zbin_over_quant + 1) : zbin_oq_high;
3965 cpi->zbin_over_quant = (zbin_oq_high + zbin_oq_low) / 2;
3970 // Update rate_correction_factor unless cpi->active_worst_quality has changed.
3971 if (!active_worst_qchanged)
3972 vp8_update_rate_correction_factors(cpi, 0);
3974 Q = vp8_regulate_q(cpi, cpi->this_frame_target);
3976 while (((Q < q_low) || (cpi->zbin_over_quant < zbin_oq_low)) && (Retries < 10))
3978 vp8_update_rate_correction_factors(cpi, 0);
3979 Q = vp8_regulate_q(cpi, cpi->this_frame_target);
3986 // Frame is too small
3989 if (cpi->zbin_over_quant == 0)
3990 q_high = (Q > q_low) ? (Q - 1) : q_low; // Lower q_high if not using over quant
3991 else // else lower zbin_oq_high
3992 zbin_oq_high = (cpi->zbin_over_quant > zbin_oq_low) ? (cpi->zbin_over_quant - 1) : zbin_oq_low;
3996 // Update rate_correction_factor unless cpi->active_worst_quality has changed.
3997 if (!active_worst_qchanged)
3998 vp8_update_rate_correction_factors(cpi, 1);
4000 Q = (q_high + q_low) / 2;
4002 // Adjust cpi->zbin_over_quant (only allowed when Q is max)
4004 cpi->zbin_over_quant = 0;
4006 cpi->zbin_over_quant = (zbin_oq_high + zbin_oq_low) / 2;
4010 // Update rate_correction_factor unless cpi->active_worst_quality has changed.
4011 if (!active_worst_qchanged)
4012 vp8_update_rate_correction_factors(cpi, 0);
4014 Q = vp8_regulate_q(cpi, cpi->this_frame_target);
4016 // Special case reset for qlow for constrained quality.
4017 // This should only trigger where there is very substantial
4018 // undershoot on a frame and the auto cq level is above
4019 // the user passsed in value.
4020 if ( (cpi->oxcf.end_usage == USAGE_CONSTRAINED_QUALITY) &&
4026 while (((Q > q_high) || (cpi->zbin_over_quant > zbin_oq_high)) && (Retries < 10))
4028 vp8_update_rate_correction_factors(cpi, 0);
4029 Q = vp8_regulate_q(cpi, cpi->this_frame_target);
4034 undershoot_seen = 1;
4037 // Clamp Q to upper and lower limits:
4043 // Clamp cpi->zbin_over_quant
4044 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;
4052 if (cpi->is_src_frame_alt_ref)
4057 vp8_restore_coding_context(cpi);
4059 #if CONFIG_INTERNAL_STATS
4060 cpi->tot_recode_hits++;
4067 // Experimental code for lagged and one pass
4068 // Update stats used for one pass GF selection
4072 double frame_intra_error;
4073 double frame_coded_error;
4074 double frame_pcnt_inter;
4075 double frame_pcnt_motion;
4077 double frame_mvr_abs;
4079 double frame_mvc_abs;
4082 cpi->one_pass_frame_stats[cpi->one_pass_frame_index].frame_coded_error = (double)cpi->prediction_error;
4083 cpi->one_pass_frame_stats[cpi->one_pass_frame_index].frame_intra_error = (double)cpi->intra_error;
4084 cpi->one_pass_frame_stats[cpi->one_pass_frame_index].frame_pcnt_inter = (double)(100 - cpi->this_frame_percent_intra) / 100.0;
4088 // Special case code to reduce pulsing when key frames are forced at a
4089 // fixed interval. Note the reconstruction error if it is the frame before
4090 // the force key frame
4091 if ( cpi->next_key_frame_forced && (cpi->twopass.frames_to_key == 0) )
4093 cpi->ambient_err = vp8_calc_ss_err(cpi->Source,
4094 &cm->yv12_fb[cm->new_fb_idx]);
4097 /* This frame's MVs are saved and will be used in next frame's MV predictor.
4098 * Last frame has one more line(add to bottom) and one more column(add to
4099 * right) than cm->mip. The edge elements are initialized to 0.
4101 #if CONFIG_MULTI_RES_ENCODING
4102 if(!cpi->oxcf.mr_encoder_id && cm->show_frame)
4104 if(cm->show_frame) /* do not save for altref frame */
4109 /* Point to beginning of allocated MODE_INFO arrays. */
4110 MODE_INFO *tmp = cm->mip;
4112 if(cm->frame_type != KEY_FRAME)
4114 for (mb_row = 0; mb_row < cm->mb_rows+1; mb_row ++)
4116 for (mb_col = 0; mb_col < cm->mb_cols+1; mb_col ++)
4118 if(tmp->mbmi.ref_frame != INTRA_FRAME)
4119 cpi->lfmv[mb_col + mb_row*(cm->mode_info_stride+1)].as_int = tmp->mbmi.mv.as_int;
4121 cpi->lf_ref_frame_sign_bias[mb_col + mb_row*(cm->mode_info_stride+1)] = cm->ref_frame_sign_bias[tmp->mbmi.ref_frame];
4122 cpi->lf_ref_frame[mb_col + mb_row*(cm->mode_info_stride+1)] = tmp->mbmi.ref_frame;
4129 #if CONFIG_MULTI_RES_ENCODING
4130 vp8_cal_dissimilarity(cpi);
4133 // Update the GF useage maps.
4134 // This is done after completing the compression of a frame when all
4135 // modes etc. are finalized but before loop filter
4136 if (cpi->oxcf.number_of_layers == 1)
4137 vp8_update_gf_useage_maps(cpi, cm, &cpi->mb);
4139 if (cm->frame_type == KEY_FRAME)
4140 cm->refresh_last_frame = 1;
4144 FILE *f = fopen("gfactive.stt", "a");
4145 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);
4150 // For inter frames the current default behavior is that when
4151 // cm->refresh_golden_frame is set we copy the old GF over to the ARF buffer
4152 // This is purely an encoder decision at present.
4153 if (!cpi->oxcf.error_resilient_mode && cm->refresh_golden_frame)
4154 cm->copy_buffer_to_arf = 2;
4156 cm->copy_buffer_to_arf = 0;
4158 cm->frame_to_show = &cm->yv12_fb[cm->new_fb_idx];
4160 #if CONFIG_MULTITHREAD
4161 if (cpi->b_multi_threaded)
4163 sem_post(&cpi->h_event_start_lpf); /* start loopfilter in separate thread */
4164 cpi->b_lpf_running = 1;
4169 vp8_loopfilter_frame(cpi, cm);
4172 update_reference_frames(cm);
4174 #if !(CONFIG_REALTIME_ONLY & CONFIG_ONTHEFLY_BITPACKING)
4175 if (cpi->oxcf.error_resilient_mode)
4177 cm->refresh_entropy_probs = 0;
4181 #if CONFIG_MULTITHREAD
4182 /* wait that filter_level is picked so that we can continue with stream packing */
4183 if (cpi->b_multi_threaded)
4184 sem_wait(&cpi->h_event_end_lpf);
4187 // build the bitstream
4188 vp8_pack_bitstream(cpi, dest, dest_end, size);
4190 #if CONFIG_MULTITHREAD
4191 /* if PSNR packets are generated we have to wait for the lpf */
4192 if (cpi->b_lpf_running && cpi->b_calculate_psnr)
4194 sem_wait(&cpi->h_event_end_lpf);
4195 cpi->b_lpf_running = 0;
4199 /* Move storing frame_type out of the above loop since it is also
4200 * needed in motion search besides loopfilter */
4201 cm->last_frame_type = cm->frame_type;
4203 // Update rate control heuristics
4204 cpi->total_byte_count += (*size);
4205 cpi->projected_frame_size = (*size) << 3;
4207 if (cpi->oxcf.number_of_layers > 1)
4210 for (i=cpi->current_layer+1; i<cpi->oxcf.number_of_layers; i++)
4211 cpi->layer_context[i].total_byte_count += (*size);
4214 if (!active_worst_qchanged)
4215 vp8_update_rate_correction_factors(cpi, 2);
4217 cpi->last_q[cm->frame_type] = cm->base_qindex;
4219 if (cm->frame_type == KEY_FRAME)
4221 vp8_adjust_key_frame_context(cpi);
4224 // Keep a record of ambient average Q.
4225 if (cm->frame_type != KEY_FRAME)
4226 cpi->avg_frame_qindex = (2 + 3 * cpi->avg_frame_qindex + cm->base_qindex) >> 2;
4228 // Keep a record from which we can calculate the average Q excluding GF updates and key frames
4229 if ((cm->frame_type != KEY_FRAME) && ((cpi->oxcf.number_of_layers > 1) ||
4230 (!cm->refresh_golden_frame && !cm->refresh_alt_ref_frame)))
4234 // Calculate the average Q for normal inter frames (not key or GFU
4236 if ( cpi->pass == 2 )
4238 cpi->ni_tot_qi += Q;
4239 cpi->ni_av_qi = (cpi->ni_tot_qi / cpi->ni_frames);
4243 // Damp value for first few frames
4244 if (cpi->ni_frames > 150 )
4246 cpi->ni_tot_qi += Q;
4247 cpi->ni_av_qi = (cpi->ni_tot_qi / cpi->ni_frames);
4249 // For one pass, early in the clip ... average the current frame Q
4250 // value with the worstq entered by the user as a dampening measure
4253 cpi->ni_tot_qi += Q;
4254 cpi->ni_av_qi = ((cpi->ni_tot_qi / cpi->ni_frames) + cpi->worst_quality + 1) / 2;
4257 // If the average Q is higher than what was used in the last frame
4258 // (after going through the recode loop to keep the frame size within range)
4259 // then use the last frame value - 1.
4260 // The -1 is designed to stop Q and hence the data rate, from progressively
4261 // falling away during difficult sections, but at the same time reduce the number of
4262 // itterations around the recode loop.
4263 if (Q > cpi->ni_av_qi)
4264 cpi->ni_av_qi = Q - 1;
4270 // If the frame was massively oversize and we are below optimal buffer level drop next frame
4271 if ((cpi->drop_frames_allowed) &&
4272 (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER) &&
4273 (cpi->buffer_level < cpi->oxcf.drop_frames_water_mark * cpi->oxcf.optimal_buffer_level / 100) &&
4274 (cpi->projected_frame_size > (4 * cpi->this_frame_target)))
4276 cpi->drop_frame = 1;
4281 // Set the count for maximum consecutive dropped frames based upon the ratio of
4282 // this frame size to the target average per frame bandwidth.
4283 // (cpi->av_per_frame_bandwidth > 0) is just a sanity check to prevent / 0.
4284 if (cpi->drop_frames_allowed && (cpi->av_per_frame_bandwidth > 0))
4286 cpi->max_drop_count = cpi->projected_frame_size / cpi->av_per_frame_bandwidth;
4288 if (cpi->max_drop_count > cpi->max_consec_dropped_frames)
4289 cpi->max_drop_count = cpi->max_consec_dropped_frames;
4292 // Update the buffer level variable.
4293 // Non-viewable frames are a special case and are treated as pure overhead.
4294 if ( !cm->show_frame )
4295 cpi->bits_off_target -= cpi->projected_frame_size;
4297 cpi->bits_off_target += cpi->av_per_frame_bandwidth - cpi->projected_frame_size;
4299 // Clip the buffer level to the maximum specified buffer size
4300 if (cpi->bits_off_target > cpi->oxcf.maximum_buffer_size)
4301 cpi->bits_off_target = cpi->oxcf.maximum_buffer_size;
4303 // Rolling monitors of whether we are over or underspending used to help regulate min and Max Q in two pass.
4304 cpi->rolling_target_bits = ((cpi->rolling_target_bits * 3) + cpi->this_frame_target + 2) / 4;
4305 cpi->rolling_actual_bits = ((cpi->rolling_actual_bits * 3) + cpi->projected_frame_size + 2) / 4;
4306 cpi->long_rolling_target_bits = ((cpi->long_rolling_target_bits * 31) + cpi->this_frame_target + 16) / 32;
4307 cpi->long_rolling_actual_bits = ((cpi->long_rolling_actual_bits * 31) + cpi->projected_frame_size + 16) / 32;
4309 // Actual bits spent
4310 cpi->total_actual_bits += cpi->projected_frame_size;
4313 cpi->total_target_vs_actual += (cpi->this_frame_target - cpi->projected_frame_size);
4315 cpi->buffer_level = cpi->bits_off_target;
4317 // Propagate values to higher temporal layers
4318 if (cpi->oxcf.number_of_layers > 1)
4322 for (i=cpi->current_layer+1; i<cpi->oxcf.number_of_layers; i++)
4324 LAYER_CONTEXT *lc = &cpi->layer_context[i];
4325 int bits_off_for_this_layer = lc->target_bandwidth / lc->frame_rate
4326 - cpi->projected_frame_size;
4328 lc->bits_off_target += bits_off_for_this_layer;
4330 // Clip buffer level to maximum buffer size for the layer
4331 if (lc->bits_off_target > lc->maximum_buffer_size)
4332 lc->bits_off_target = lc->maximum_buffer_size;
4334 lc->total_actual_bits += cpi->projected_frame_size;
4335 lc->total_target_vs_actual += bits_off_for_this_layer;
4336 lc->buffer_level = lc->bits_off_target;
4340 // Update bits left to the kf and gf groups to account for overshoot or undershoot on these frames
4341 if (cm->frame_type == KEY_FRAME)
4343 cpi->twopass.kf_group_bits += cpi->this_frame_target - cpi->projected_frame_size;
4345 if (cpi->twopass.kf_group_bits < 0)
4346 cpi->twopass.kf_group_bits = 0 ;
4348 else if (cm->refresh_golden_frame || cm->refresh_alt_ref_frame)
4350 cpi->twopass.gf_group_bits += cpi->this_frame_target - cpi->projected_frame_size;
4352 if (cpi->twopass.gf_group_bits < 0)
4353 cpi->twopass.gf_group_bits = 0 ;
4356 if (cm->frame_type != KEY_FRAME)
4358 if (cpi->common.refresh_alt_ref_frame)
4360 cpi->last_skip_false_probs[2] = cpi->prob_skip_false;
4361 cpi->last_skip_probs_q[2] = cm->base_qindex;
4363 else if (cpi->common.refresh_golden_frame)
4365 cpi->last_skip_false_probs[1] = cpi->prob_skip_false;
4366 cpi->last_skip_probs_q[1] = cm->base_qindex;
4370 cpi->last_skip_false_probs[0] = cpi->prob_skip_false;
4371 cpi->last_skip_probs_q[0] = cm->base_qindex;
4373 //update the baseline
4374 cpi->base_skip_false_prob[cm->base_qindex] = cpi->prob_skip_false;
4379 #if 0 && CONFIG_INTERNAL_STATS
4381 FILE *f = fopen("tmp.stt", "a");
4383 vp8_clear_system_state(); //__asm emms;
4385 if (cpi->twopass.total_left_stats.coded_error != 0.0)
4386 fprintf(f, "%10d %10d %10d %10d %10d %10d %10d %10d %10d %6d %6d"
4387 "%6d %6d %6d %5d %5d %5d %8d %8.2f %10d %10.3f"
4389 cpi->common.current_video_frame, cpi->this_frame_target,
4390 cpi->projected_frame_size,
4391 (cpi->projected_frame_size - cpi->this_frame_target),
4392 (int)cpi->total_target_vs_actual,
4394 (cpi->oxcf.starting_buffer_level-cpi->bits_off_target),
4395 (int)cpi->total_actual_bits, cm->base_qindex,
4396 cpi->active_best_quality, cpi->active_worst_quality,
4397 cpi->ni_av_qi, cpi->cq_target_quality,
4398 cpi->zbin_over_quant,
4399 //cpi->avg_frame_qindex, cpi->zbin_over_quant,
4400 cm->refresh_golden_frame, cm->refresh_alt_ref_frame,
4401 cm->frame_type, cpi->gfu_boost,
4402 cpi->twopass.est_max_qcorrection_factor,
4403 (int)cpi->twopass.bits_left,
4404 cpi->twopass.total_left_stats.coded_error,
4405 (double)cpi->twopass.bits_left /
4406 cpi->twopass.total_left_stats.coded_error,
4407 cpi->tot_recode_hits);
4409 fprintf(f, "%10d %10d %10d %10d %10d %10d %10d %10d %10d %6d %6d"
4410 "%6d %6d %6d %5d %5d %5d %8d %8.2f %10d %10.3f"
4412 cpi->common.current_video_frame,
4413 cpi->this_frame_target, cpi->projected_frame_size,
4414 (cpi->projected_frame_size - cpi->this_frame_target),
4415 (int)cpi->total_target_vs_actual,
4417 (cpi->oxcf.starting_buffer_level-cpi->bits_off_target),
4418 (int)cpi->total_actual_bits, cm->base_qindex,
4419 cpi->active_best_quality, cpi->active_worst_quality,
4420 cpi->ni_av_qi, cpi->cq_target_quality,
4421 cpi->zbin_over_quant,
4422 //cpi->avg_frame_qindex, cpi->zbin_over_quant,
4423 cm->refresh_golden_frame, cm->refresh_alt_ref_frame,
4424 cm->frame_type, cpi->gfu_boost,
4425 cpi->twopass.est_max_qcorrection_factor,
4426 (int)cpi->twopass.bits_left,
4427 cpi->twopass.total_left_stats.coded_error,
4428 cpi->tot_recode_hits);
4433 FILE *fmodes = fopen("Modes.stt", "a");
4436 fprintf(fmodes, "%6d:%1d:%1d:%1d ",
4437 cpi->common.current_video_frame,
4438 cm->frame_type, cm->refresh_golden_frame,
4439 cm->refresh_alt_ref_frame);
4441 for (i = 0; i < MAX_MODES; i++)
4442 fprintf(fmodes, "%5d ", cpi->mode_chosen_counts[i]);
4444 fprintf(fmodes, "\n");
4452 // If this was a kf or Gf note the Q
4453 if ((cm->frame_type == KEY_FRAME) || cm->refresh_golden_frame || cm->refresh_alt_ref_frame)
4454 cm->last_kf_gf_q = cm->base_qindex;
4456 if (cm->refresh_golden_frame == 1)
4457 cm->frame_flags = cm->frame_flags | FRAMEFLAGS_GOLDEN;
4459 cm->frame_flags = cm->frame_flags&~FRAMEFLAGS_GOLDEN;
4461 if (cm->refresh_alt_ref_frame == 1)
4462 cm->frame_flags = cm->frame_flags | FRAMEFLAGS_ALTREF;
4464 cm->frame_flags = cm->frame_flags&~FRAMEFLAGS_ALTREF;
4467 if (cm->refresh_last_frame & cm->refresh_golden_frame) // both refreshed
4468 cpi->gold_is_last = 1;
4469 else if (cm->refresh_last_frame ^ cm->refresh_golden_frame) // 1 refreshed but not the other
4470 cpi->gold_is_last = 0;
4472 if (cm->refresh_last_frame & cm->refresh_alt_ref_frame) // both refreshed
4473 cpi->alt_is_last = 1;
4474 else if (cm->refresh_last_frame ^ cm->refresh_alt_ref_frame) // 1 refreshed but not the other
4475 cpi->alt_is_last = 0;
4477 if (cm->refresh_alt_ref_frame & cm->refresh_golden_frame) // both refreshed
4478 cpi->gold_is_alt = 1;
4479 else if (cm->refresh_alt_ref_frame ^ cm->refresh_golden_frame) // 1 refreshed but not the other
4480 cpi->gold_is_alt = 0;
4482 cpi->ref_frame_flags = VP8_ALT_FLAG | VP8_GOLD_FLAG | VP8_LAST_FLAG;
4484 if (cpi->gold_is_last)
4485 cpi->ref_frame_flags &= ~VP8_GOLD_FLAG;
4487 if (cpi->alt_is_last)
4488 cpi->ref_frame_flags &= ~VP8_ALT_FLAG;
4490 if (cpi->gold_is_alt)
4491 cpi->ref_frame_flags &= ~VP8_ALT_FLAG;
4494 if (!cpi->oxcf.error_resilient_mode)
4496 if (cpi->oxcf.play_alternate && cm->refresh_alt_ref_frame && (cm->frame_type != KEY_FRAME))
4497 // Update the alternate reference frame stats as appropriate.
4498 update_alt_ref_frame_stats(cpi);
4500 // Update the Golden frame stats as appropriate.
4501 update_golden_frame_stats(cpi);
4504 if (cm->frame_type == KEY_FRAME)
4506 // Tell the caller that the frame was coded as a key frame
4507 *frame_flags = cm->frame_flags | FRAMEFLAGS_KEY;
4509 // As this frame is a key frame the next defaults to an inter frame.
4510 cm->frame_type = INTER_FRAME;
4512 cpi->last_frame_percent_intra = 100;
4516 *frame_flags = cm->frame_flags&~FRAMEFLAGS_KEY;
4518 cpi->last_frame_percent_intra = cpi->this_frame_percent_intra;
4521 // Clear the one shot update flags for segmentation map and mode/ref loop filter deltas.
4522 cpi->mb.e_mbd.update_mb_segmentation_map = 0;
4523 cpi->mb.e_mbd.update_mb_segmentation_data = 0;
4524 cpi->mb.e_mbd.mode_ref_lf_delta_update = 0;
4527 // Dont increment frame counters if this was an altref buffer update not a real frame
4530 cm->current_video_frame++;
4531 cpi->frames_since_key++;
4534 // reset to normal state now that we are done.
4542 sprintf(filename, "enc%04d.yuv", (int) cm->current_video_frame);
4543 recon_file = fopen(filename, "wb");
4544 fwrite(cm->yv12_fb[cm->lst_fb_idx].buffer_alloc,
4545 cm->yv12_fb[cm->lst_fb_idx].frame_size, 1, recon_file);
4551 //vp8_write_yuv_frame("encoder_recon.yuv", cm->frame_to_show);
4557 static void check_gf_quality(VP8_COMP *cpi)
4559 VP8_COMMON *cm = &cpi->common;
4560 int gf_active_pct = (100 * cpi->gf_active_count) / (cm->mb_rows * cm->mb_cols);
4561 int gf_ref_usage_pct = (cpi->count_mb_ref_frame_usage[GOLDEN_FRAME] * 100) / (cm->mb_rows * cm->mb_cols);
4562 int last_ref_zz_useage = (cpi->inter_zz_count * 100) / (cm->mb_rows * cm->mb_cols);
4564 // Gf refresh is not currently being signalled
4565 if (cpi->gf_update_recommended == 0)
4567 if (cpi->common.frames_since_golden > 7)
4570 if ((gf_active_pct < 10) || ((gf_active_pct + gf_ref_usage_pct) < 15))
4572 // ...but last frame zero zero usage is reasonbable so a new gf might be appropriate
4573 if (last_ref_zz_useage >= 25)
4575 cpi->gf_bad_count ++;
4577 if (cpi->gf_bad_count >= 8) // Check that the condition is stable
4579 cpi->gf_update_recommended = 1;
4580 cpi->gf_bad_count = 0;
4584 cpi->gf_bad_count = 0; // Restart count as the background is not stable enough
4587 cpi->gf_bad_count = 0; // Gf useage has picked up so reset count
4590 // If the signal is set but has not been read should we cancel it.
4591 else if (last_ref_zz_useage < 15)
4593 cpi->gf_update_recommended = 0;
4594 cpi->gf_bad_count = 0;
4599 FILE *f = fopen("gfneeded.stt", "a");
4600 fprintf(f, "%10d %10d %10d %10d %10ld \n",
4601 cm->current_video_frame,
4602 cpi->common.frames_since_golden,
4603 gf_active_pct, gf_ref_usage_pct,
4604 cpi->gf_update_recommended);
4611 #if !(CONFIG_REALTIME_ONLY)
4612 static void Pass2Encode(VP8_COMP *cpi, unsigned long *size, unsigned char *dest, unsigned char * dest_end, unsigned int *frame_flags)
4615 if (!cpi->common.refresh_alt_ref_frame)
4616 vp8_second_pass(cpi);
4618 encode_frame_to_data_rate(cpi, size, dest, dest_end, frame_flags);
4619 cpi->twopass.bits_left -= 8 * *size;
4621 if (!cpi->common.refresh_alt_ref_frame)
4623 double two_pass_min_rate = (double)(cpi->oxcf.target_bandwidth
4624 *cpi->oxcf.two_pass_vbrmin_section / 100);
4625 cpi->twopass.bits_left += (int64_t)(two_pass_min_rate / cpi->frame_rate);
4630 //For ARM NEON, d8-d15 are callee-saved registers, and need to be saved by us.
4632 extern void vp8_push_neon(int64_t *store);
4633 extern void vp8_pop_neon(int64_t *store);
4637 int vp8_receive_raw_frame(VP8_COMP *cpi, unsigned int frame_flags, YV12_BUFFER_CONFIG *sd, int64_t time_stamp, int64_t end_time)
4640 int64_t store_reg[8];
4642 VP8_COMMON *cm = &cpi->common;
4643 struct vpx_usec_timer timer;
4647 #if CONFIG_RUNTIME_CPU_DETECT
4648 if (cm->cpu_caps & HAS_NEON)
4651 vp8_push_neon(store_reg);
4655 vpx_usec_timer_start(&timer);
4657 /* Reinit the lookahead buffer if the frame size changes */
4658 if (sd->y_width != cpi->oxcf.Width || sd->y_height != cpi->oxcf.Height)
4660 assert(cpi->oxcf.lag_in_frames < 2);
4661 dealloc_raw_frame_buffers(cpi);
4662 alloc_raw_frame_buffers(cpi);
4665 if(vp8_lookahead_push(cpi->lookahead, sd, time_stamp, end_time,
4666 frame_flags, cpi->active_map_enabled ? cpi->active_map : NULL))
4668 cm->clr_type = sd->clrtype;
4669 vpx_usec_timer_mark(&timer);
4670 cpi->time_receive_data += vpx_usec_timer_elapsed(&timer);
4673 #if CONFIG_RUNTIME_CPU_DETECT
4674 if (cm->cpu_caps & HAS_NEON)
4677 vp8_pop_neon(store_reg);
4685 static int frame_is_reference(const VP8_COMP *cpi)
4687 const VP8_COMMON *cm = &cpi->common;
4688 const MACROBLOCKD *xd = &cpi->mb.e_mbd;
4690 return cm->frame_type == KEY_FRAME || cm->refresh_last_frame
4691 || cm->refresh_golden_frame || cm->refresh_alt_ref_frame
4692 || cm->copy_buffer_to_gf || cm->copy_buffer_to_arf
4693 || cm->refresh_entropy_probs
4694 || xd->mode_ref_lf_delta_update
4695 || xd->update_mb_segmentation_map || xd->update_mb_segmentation_data;
4699 int vp8_get_compressed_data(VP8_COMP *cpi, unsigned int *frame_flags, unsigned long *size, unsigned char *dest, unsigned char *dest_end, int64_t *time_stamp, int64_t *time_end, int flush)
4702 int64_t store_reg[8];
4705 struct vpx_usec_timer tsctimer;
4706 struct vpx_usec_timer ticktimer;
4707 struct vpx_usec_timer cmptimer;
4708 YV12_BUFFER_CONFIG *force_src_buffer = NULL;
4715 if (setjmp(cpi->common.error.jmp))
4717 cpi->common.error.setjmp = 0;
4718 return VPX_CODEC_CORRUPT_FRAME;
4721 cpi->common.error.setjmp = 1;
4724 #if CONFIG_RUNTIME_CPU_DETECT
4725 if (cm->cpu_caps & HAS_NEON)
4728 vp8_push_neon(store_reg);
4732 vpx_usec_timer_start(&cmptimer);
4736 #if !(CONFIG_REALTIME_ONLY)
4737 // Should we code an alternate reference frame
4738 if (cpi->oxcf.error_resilient_mode == 0 &&
4739 cpi->oxcf.play_alternate &&
4740 cpi->source_alt_ref_pending)
4742 if ((cpi->source = vp8_lookahead_peek(cpi->lookahead,
4743 cpi->frames_till_gf_update_due,
4746 cpi->alt_ref_source = cpi->source;
4747 if (cpi->oxcf.arnr_max_frames > 0)
4749 vp8_temporal_filter_prepare_c(cpi,
4750 cpi->frames_till_gf_update_due);
4751 force_src_buffer = &cpi->alt_ref_buffer;
4753 cm->frames_till_alt_ref_frame = cpi->frames_till_gf_update_due;
4754 cm->refresh_alt_ref_frame = 1;
4755 cm->refresh_golden_frame = 0;
4756 cm->refresh_last_frame = 0;
4758 cpi->source_alt_ref_pending = 0; // Clear Pending alt Ref flag.
4759 cpi->is_src_frame_alt_ref = 0;
4766 /* Read last frame source if we are encoding first pass. */
4767 if (cpi->pass == 1 && cm->current_video_frame > 0)
4769 if((cpi->last_source = vp8_lookahead_peek(cpi->lookahead, 1,
4770 PEEK_BACKWARD)) == NULL)
4775 if ((cpi->source = vp8_lookahead_pop(cpi->lookahead, flush)))
4779 cpi->is_src_frame_alt_ref = cpi->alt_ref_source
4780 && (cpi->source == cpi->alt_ref_source);
4782 if(cpi->is_src_frame_alt_ref)
4783 cpi->alt_ref_source = NULL;
4789 cpi->Source = force_src_buffer ? force_src_buffer : &cpi->source->img;
4790 cpi->un_scaled_source = cpi->Source;
4791 *time_stamp = cpi->source->ts_start;
4792 *time_end = cpi->source->ts_end;
4793 *frame_flags = cpi->source->flags;
4795 if (cpi->pass == 1 && cm->current_video_frame > 0)
4797 cpi->last_frame_unscaled_source = &cpi->last_source->img;
4803 #if !(CONFIG_REALTIME_ONLY)
4805 if (flush && cpi->pass == 1 && !cpi->twopass.first_pass_done)
4807 vp8_end_first_pass(cpi); /* get last stats packet */
4808 cpi->twopass.first_pass_done = 1;
4814 #if CONFIG_RUNTIME_CPU_DETECT
4815 if (cm->cpu_caps & HAS_NEON)
4818 vp8_pop_neon(store_reg);
4824 if (cpi->source->ts_start < cpi->first_time_stamp_ever)
4826 cpi->first_time_stamp_ever = cpi->source->ts_start;
4827 cpi->last_end_time_stamp_seen = cpi->source->ts_start;
4830 // adjust frame rates based on timestamps given
4833 int64_t this_duration;
4836 if (cpi->source->ts_start == cpi->first_time_stamp_ever)
4838 this_duration = cpi->source->ts_end - cpi->source->ts_start;
4843 int64_t last_duration;
4845 this_duration = cpi->source->ts_end - cpi->last_end_time_stamp_seen;
4846 last_duration = cpi->last_end_time_stamp_seen
4847 - cpi->last_time_stamp_seen;
4848 // do a step update if the duration changes by 10%
4850 step = ((this_duration - last_duration) * 10 / last_duration);
4856 cpi->ref_frame_rate = 10000000.0 / this_duration;
4859 double avg_duration, interval;
4861 /* Average this frame's rate into the last second's average
4862 * frame rate. If we haven't seen 1 second yet, then average
4863 * over the whole interval seen.
4865 interval = cpi->source->ts_end - cpi->first_time_stamp_ever;
4866 if(interval > 10000000.0)
4867 interval = 10000000;
4869 avg_duration = 10000000.0 / cpi->ref_frame_rate;
4870 avg_duration *= (interval - avg_duration + this_duration);
4871 avg_duration /= interval;
4873 cpi->ref_frame_rate = 10000000.0 / avg_duration;
4876 if (cpi->oxcf.number_of_layers > 1)
4880 // Update frame rates for each layer
4881 for (i=0; i<cpi->oxcf.number_of_layers; i++)
4883 LAYER_CONTEXT *lc = &cpi->layer_context[i];
4884 lc->frame_rate = cpi->ref_frame_rate /
4885 cpi->oxcf.rate_decimator[i];
4889 vp8_new_frame_rate(cpi, cpi->ref_frame_rate);
4892 cpi->last_time_stamp_seen = cpi->source->ts_start;
4893 cpi->last_end_time_stamp_seen = cpi->source->ts_end;
4896 if (cpi->oxcf.number_of_layers > 1)
4900 update_layer_contexts (cpi);
4902 // Restore layer specific context & set frame rate
4903 layer = cpi->oxcf.layer_id[
4904 cm->current_video_frame % cpi->oxcf.periodicity];
4905 restore_layer_context (cpi, layer);
4906 vp8_new_frame_rate (cpi, cpi->layer_context[layer].frame_rate);
4909 if (cpi->compressor_speed == 2)
4911 if (cpi->oxcf.number_of_layers == 1)
4912 check_gf_quality(cpi);
4913 vpx_usec_timer_start(&tsctimer);
4914 vpx_usec_timer_start(&ticktimer);
4917 #if CONFIG_REALTIME_ONLY & CONFIG_ONTHEFLY_BITPACKING
4920 const int num_part = (1 << cm->multi_token_partition);
4921 /* the available bytes in dest */
4922 const unsigned long dest_size = dest_end - dest;
4923 const int tok_part_buff_size = (dest_size * 9) / (10 * num_part);
4925 unsigned char *dp = dest;
4927 cpi->partition_d[0] = dp;
4928 dp += dest_size/10; /* reserve 1/10 for control partition */
4929 cpi->partition_d_end[0] = dp;
4931 for(i = 0; i < num_part; i++)
4933 cpi->partition_d[i + 1] = dp;
4934 dp += tok_part_buff_size;
4935 cpi->partition_d_end[i + 1] = dp;
4940 // start with a 0 size frame
4943 // Clear down mmx registers
4944 vp8_clear_system_state(); //__asm emms;
4946 cm->frame_type = INTER_FRAME;
4947 cm->frame_flags = *frame_flags;
4951 if (cm->refresh_alt_ref_frame)
4953 //cm->refresh_golden_frame = 1;
4954 cm->refresh_golden_frame = 0;
4955 cm->refresh_last_frame = 0;
4959 cm->refresh_golden_frame = 0;
4960 cm->refresh_last_frame = 1;
4964 /* find a free buffer for the new frame */
4967 for(; i < NUM_YV12_BUFFERS; i++)
4969 if(!cm->yv12_fb[i].flags)
4976 assert(i < NUM_YV12_BUFFERS );
4978 #if !(CONFIG_REALTIME_ONLY)
4982 Pass1Encode(cpi, size, dest, frame_flags);
4984 else if (cpi->pass == 2)
4986 Pass2Encode(cpi, size, dest, dest_end, frame_flags);
4990 encode_frame_to_data_rate(cpi, size, dest, dest_end, frame_flags);
4992 if (cpi->compressor_speed == 2)
4994 unsigned int duration, duration2;
4995 vpx_usec_timer_mark(&tsctimer);
4996 vpx_usec_timer_mark(&ticktimer);
4998 duration = vpx_usec_timer_elapsed(&ticktimer);
4999 duration2 = (unsigned int)((double)duration / 2);
5001 if (cm->frame_type != KEY_FRAME)
5003 if (cpi->avg_encode_time == 0)
5004 cpi->avg_encode_time = duration;
5006 cpi->avg_encode_time = (7 * cpi->avg_encode_time + duration) >> 3;
5011 //if(*frame_flags!=1)
5014 if (cpi->avg_pick_mode_time == 0)
5015 cpi->avg_pick_mode_time = duration2;
5017 cpi->avg_pick_mode_time = (7 * cpi->avg_pick_mode_time + duration2) >> 3;
5023 if (cm->refresh_entropy_probs == 0)
5025 vpx_memcpy(&cm->fc, &cm->lfc, sizeof(cm->fc));
5028 // Save the contexts separately for alt ref, gold and last.
5029 // (TODO jbb -> Optimize this with pointers to avoid extra copies. )
5030 if(cm->refresh_alt_ref_frame)
5031 vpx_memcpy(&cpi->lfc_a, &cm->fc, sizeof(cm->fc));
5033 if(cm->refresh_golden_frame)
5034 vpx_memcpy(&cpi->lfc_g, &cm->fc, sizeof(cm->fc));
5036 if(cm->refresh_last_frame)
5037 vpx_memcpy(&cpi->lfc_n, &cm->fc, sizeof(cm->fc));
5039 // if its a dropped frame honor the requests on subsequent frames
5042 cpi->droppable = !frame_is_reference(cpi);
5044 // return to normal state
5045 cm->refresh_entropy_probs = 1;
5046 cm->refresh_alt_ref_frame = 0;
5047 cm->refresh_golden_frame = 0;
5048 cm->refresh_last_frame = 1;
5049 cm->frame_type = INTER_FRAME;
5053 // Save layer specific state
5054 if (cpi->oxcf.number_of_layers > 1)
5055 save_layer_context (cpi);
5057 vpx_usec_timer_mark(&cmptimer);
5058 cpi->time_compress_data += vpx_usec_timer_elapsed(&cmptimer);
5060 if (cpi->b_calculate_psnr && cpi->pass != 1 && cm->show_frame)
5062 generate_psnr_packet(cpi);
5065 #if CONFIG_INTERNAL_STATS
5069 cpi->bytes += *size;
5076 if (cpi->b_calculate_psnr)
5080 YV12_BUFFER_CONFIG *orig = cpi->Source;
5081 YV12_BUFFER_CONFIG *recon = cpi->common.frame_to_show;
5082 int y_samples = orig->y_height * orig->y_width ;
5083 int uv_samples = orig->uv_height * orig->uv_width ;
5084 int t_samples = y_samples + 2 * uv_samples;
5085 int64_t sq_error, sq_error2;
5087 ye = calc_plane_error(orig->y_buffer, orig->y_stride,
5088 recon->y_buffer, recon->y_stride, orig->y_width, orig->y_height);
5090 ue = calc_plane_error(orig->u_buffer, orig->uv_stride,
5091 recon->u_buffer, recon->uv_stride, orig->uv_width, orig->uv_height);
5093 ve = calc_plane_error(orig->v_buffer, orig->uv_stride,
5094 recon->v_buffer, recon->uv_stride, orig->uv_width, orig->uv_height);
5096 sq_error = ye + ue + ve;
5098 frame_psnr = vp8_mse2psnr(t_samples, 255.0, sq_error);
5100 cpi->total_y += vp8_mse2psnr(y_samples, 255.0, ye);
5101 cpi->total_u += vp8_mse2psnr(uv_samples, 255.0, ue);
5102 cpi->total_v += vp8_mse2psnr(uv_samples, 255.0, ve);
5103 cpi->total_sq_error += sq_error;
5104 cpi->total += frame_psnr;
5107 YV12_BUFFER_CONFIG *pp = &cm->post_proc_buffer;
5108 double frame_psnr2, frame_ssim2 = 0;
5111 vp8_deblock(cm->frame_to_show, &cm->post_proc_buffer, cm->filter_level * 10 / 6, 1, 0);
5112 vp8_clear_system_state();
5114 ye = calc_plane_error(orig->y_buffer, orig->y_stride,
5115 pp->y_buffer, pp->y_stride, orig->y_width, orig->y_height);
5117 ue = calc_plane_error(orig->u_buffer, orig->uv_stride,
5118 pp->u_buffer, pp->uv_stride, orig->uv_width, orig->uv_height);
5120 ve = calc_plane_error(orig->v_buffer, orig->uv_stride,
5121 pp->v_buffer, pp->uv_stride, orig->uv_width, orig->uv_height);
5123 sq_error2 = ye + ue + ve;
5125 frame_psnr2 = vp8_mse2psnr(t_samples, 255.0, sq_error2);
5127 cpi->totalp_y += vp8_mse2psnr(y_samples, 255.0, ye);
5128 cpi->totalp_u += vp8_mse2psnr(uv_samples, 255.0, ue);
5129 cpi->totalp_v += vp8_mse2psnr(uv_samples, 255.0, ve);
5130 cpi->total_sq_error2 += sq_error2;
5131 cpi->totalp += frame_psnr2;
5133 frame_ssim2 = vp8_calc_ssim(cpi->Source,
5134 &cm->post_proc_buffer, 1, &weight);
5136 cpi->summed_quality += frame_ssim2 * weight;
5137 cpi->summed_weights += weight;
5139 if (cpi->oxcf.number_of_layers > 1)
5143 for (i=cpi->current_layer;
5144 i<cpi->oxcf.number_of_layers; i++)
5146 cpi->frames_in_layer[i]++;
5148 cpi->bytes_in_layer[i] += *size;
5149 cpi->sum_psnr[i] += frame_psnr;
5150 cpi->sum_psnr_p[i] += frame_psnr2;
5151 cpi->total_error2[i] += sq_error;
5152 cpi->total_error2_p[i] += sq_error2;
5153 cpi->sum_ssim[i] += frame_ssim2 * weight;
5154 cpi->sum_weights[i] += weight;
5161 if (cpi->b_calculate_ssimg)
5163 double y, u, v, frame_all;
5164 frame_all = vp8_calc_ssimg(cpi->Source, cm->frame_to_show,
5167 if (cpi->oxcf.number_of_layers > 1)
5171 for (i=cpi->current_layer;
5172 i<cpi->oxcf.number_of_layers; i++)
5174 if (!cpi->b_calculate_psnr)
5175 cpi->frames_in_layer[i]++;
5177 cpi->total_ssimg_y_in_layer[i] += y;
5178 cpi->total_ssimg_u_in_layer[i] += u;
5179 cpi->total_ssimg_v_in_layer[i] += v;
5180 cpi->total_ssimg_all_in_layer[i] += frame_all;
5185 cpi->total_ssimg_y += y;
5186 cpi->total_ssimg_u += u;
5187 cpi->total_ssimg_v += v;
5188 cpi->total_ssimg_all += frame_all;
5197 if (cpi->common.frame_type != 0 && cpi->common.base_qindex == cpi->oxcf.worst_allowed_q)
5199 skiptruecount += cpi->skip_true_count;
5200 skipfalsecount += cpi->skip_false_count;
5208 FILE *f = fopen("skip.stt", "a");
5209 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);
5211 if (cpi->is_src_frame_alt_ref == 1)
5212 fprintf(f, "skipcount: %4d framesize: %d\n", cpi->skip_true_count , *size);
5221 #if CONFIG_RUNTIME_CPU_DETECT
5222 if (cm->cpu_caps & HAS_NEON)
5225 vp8_pop_neon(store_reg);
5229 cpi->common.error.setjmp = 0;
5234 int vp8_get_preview_raw_frame(VP8_COMP *cpi, YV12_BUFFER_CONFIG *dest, vp8_ppflags_t *flags)
5236 if (cpi->common.refresh_alt_ref_frame)
5242 #if CONFIG_MULTITHREAD
5243 if(cpi->b_lpf_running)
5245 sem_wait(&cpi->h_event_end_lpf);
5246 cpi->b_lpf_running = 0;
5251 ret = vp8_post_proc_frame(&cpi->common, dest, flags);
5254 if (cpi->common.frame_to_show)
5256 *dest = *cpi->common.frame_to_show;
5257 dest->y_width = cpi->common.Width;
5258 dest->y_height = cpi->common.Height;
5259 dest->uv_height = cpi->common.Height / 2;
5267 #endif //!CONFIG_POSTPROC
5268 vp8_clear_system_state();
5273 int vp8_set_roimap(VP8_COMP *cpi, unsigned char *map, unsigned int rows, unsigned int cols, int delta_q[4], int delta_lf[4], unsigned int threshold[4])
5275 signed char feature_data[MB_LVL_MAX][MAX_MB_SEGMENTS];
5277 if (cpi->common.mb_rows != rows || cpi->common.mb_cols != cols)
5282 disable_segmentation(cpi);
5286 // Set the segmentation Map
5287 set_segmentation_map(cpi, map);
5289 // Activate segmentation.
5290 enable_segmentation(cpi);
5292 // Set up the quant segment data
5293 feature_data[MB_LVL_ALT_Q][0] = delta_q[0];
5294 feature_data[MB_LVL_ALT_Q][1] = delta_q[1];
5295 feature_data[MB_LVL_ALT_Q][2] = delta_q[2];
5296 feature_data[MB_LVL_ALT_Q][3] = delta_q[3];
5298 // Set up the loop segment data s
5299 feature_data[MB_LVL_ALT_LF][0] = delta_lf[0];
5300 feature_data[MB_LVL_ALT_LF][1] = delta_lf[1];
5301 feature_data[MB_LVL_ALT_LF][2] = delta_lf[2];
5302 feature_data[MB_LVL_ALT_LF][3] = delta_lf[3];
5304 cpi->segment_encode_breakout[0] = threshold[0];
5305 cpi->segment_encode_breakout[1] = threshold[1];
5306 cpi->segment_encode_breakout[2] = threshold[2];
5307 cpi->segment_encode_breakout[3] = threshold[3];
5309 // Initialise the feature data structure
5310 // SEGMENT_DELTADATA 0, SEGMENT_ABSDATA 1
5311 set_segment_data(cpi, &feature_data[0][0], SEGMENT_DELTADATA);
5316 int vp8_set_active_map(VP8_COMP *cpi, unsigned char *map, unsigned int rows, unsigned int cols)
5318 if (rows == cpi->common.mb_rows && cols == cpi->common.mb_cols)
5322 vpx_memcpy(cpi->active_map, map, rows * cols);
5323 cpi->active_map_enabled = 1;
5326 cpi->active_map_enabled = 0;
5332 //cpi->active_map_enabled = 0;
5337 int vp8_set_internal_size(VP8_COMP *cpi, VPX_SCALING horiz_mode, VPX_SCALING vert_mode)
5339 if (horiz_mode <= ONETWO)
5340 cpi->common.horiz_scale = horiz_mode;
5344 if (vert_mode <= ONETWO)
5345 cpi->common.vert_scale = vert_mode;
5354 int vp8_calc_ss_err(YV12_BUFFER_CONFIG *source, YV12_BUFFER_CONFIG *dest)
5359 unsigned char *src = source->y_buffer;
5360 unsigned char *dst = dest->y_buffer;
5362 // Loop through the Y plane raw and reconstruction data summing (square differences)
5363 for (i = 0; i < source->y_height; i += 16)
5365 for (j = 0; j < source->y_width; j += 16)
5368 Total += vp8_mse16x16(src + j, source->y_stride, dst + j, dest->y_stride, &sse);
5371 src += 16 * source->y_stride;
5372 dst += 16 * dest->y_stride;
5379 int vp8_get_quantizer(VP8_COMP *cpi)
5381 return cpi->common.base_qindex;