2 * Copyright (c) 2010 The WebM project authors. All Rights Reserved.
4 * Use of this source code is governed by a BSD-style license
5 * that can be found in the LICENSE file in the root of the source
6 * tree. An additional intellectual property rights grant can be found
7 * in the file PATENTS. All contributing project authors may
8 * be found in the AUTHORS file in the root of the source tree.
12 #include "vp8/common/onyxc_int.h"
14 #include "vp8/common/systemdependent.h"
16 #include "vp8/common/alloccommon.h"
18 #include "firstpass.h"
20 #include "vpx_scale/vpxscale.h"
21 #include "vp8/common/extend.h"
23 #include "vp8/common/quant_common.h"
24 #include "segmentation.h"
25 #include "vp8/common/g_common.h"
26 #include "vpx_scale/yv12extend.h"
27 #include "vp8/common/postproc.h"
28 #include "vpx_mem/vpx_mem.h"
29 #include "vp8/common/swapyv12buffer.h"
30 #include "vp8/common/threading.h"
31 #include "vpx_ports/vpx_timer.h"
32 #include "temporal_filter.h"
34 #include "vpx_ports/arm.h"
41 #if CONFIG_RUNTIME_CPU_DETECT
42 #define IF_RTCD(x) (x)
43 #define RTCD(x) &cpi->common.rtcd.x
45 #define IF_RTCD(x) NULL
49 extern void vp8cx_pick_filter_level_fast(YV12_BUFFER_CONFIG *sd, VP8_COMP *cpi);
50 extern void vp8cx_set_alt_lf_level(VP8_COMP *cpi, int filt_val);
51 extern void vp8cx_pick_filter_level(YV12_BUFFER_CONFIG *sd, VP8_COMP *cpi);
53 extern void vp8_init_loop_filter(VP8_COMMON *cm);
54 extern void vp8_loop_filter_frame(VP8_COMMON *cm, MACROBLOCKD *mbd, int filt_val);
55 extern void vp8_loop_filter_frame_yonly(VP8_COMMON *cm, MACROBLOCKD *mbd, int filt_val, int sharpness_lvl);
56 extern void vp8_dmachine_specific_config(VP8_COMP *cpi);
57 extern void vp8_cmachine_specific_config(VP8_COMP *cpi);
58 extern void vp8_deblock_frame(YV12_BUFFER_CONFIG *source, YV12_BUFFER_CONFIG *post, int filt_lvl, int low_var_thresh, int flag);
59 extern void print_parms(VP8_CONFIG *ocf, char *filenam);
60 extern unsigned int vp8_get_processor_freq();
61 extern void print_tree_update_probs();
62 extern void vp8cx_create_encoder_threads(VP8_COMP *cpi);
63 extern void vp8cx_remove_encoder_threads(VP8_COMP *cpi);
65 extern void vp8_yv12_copy_frame_func_neon(YV12_BUFFER_CONFIG *src_ybc, YV12_BUFFER_CONFIG *dst_ybc);
66 extern void vp8_yv12_copy_src_frame_func_neon(YV12_BUFFER_CONFIG *src_ybc, YV12_BUFFER_CONFIG *dst_ybc);
69 int vp8_estimate_entropy_savings(VP8_COMP *cpi);
70 int vp8_calc_ss_err(YV12_BUFFER_CONFIG *source, YV12_BUFFER_CONFIG *dest, const vp8_variance_rtcd_vtable_t *rtcd);
72 extern void vp8_temporal_filter_prepare_c(VP8_COMP *cpi, int distance);
74 static void set_default_lf_deltas(VP8_COMP *cpi);
76 extern const int vp8_gf_interval_table[101];
78 #if CONFIG_INTERNAL_STATS
81 extern double vp8_calc_ssim
83 YV12_BUFFER_CONFIG *source,
84 YV12_BUFFER_CONFIG *dest,
87 const vp8_variance_rtcd_vtable_t *rtcd
91 extern double vp8_calc_ssimg
93 YV12_BUFFER_CONFIG *source,
94 YV12_BUFFER_CONFIG *dest,
98 const vp8_variance_rtcd_vtable_t *rtcd
105 #ifdef OUTPUT_YUV_SRC
116 extern int skip_true_count;
117 extern int skip_false_count;
122 extern int intra_mode_stats[10][10][10];
126 unsigned int frames_at_speed[16] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
127 unsigned int tot_pm = 0;
128 unsigned int cnt_pm = 0;
129 unsigned int tot_ef = 0;
130 unsigned int cnt_ef = 0;
134 extern unsigned __int64 Sectionbits[50];
135 extern int y_modes[5] ;
136 extern int uv_modes[4] ;
137 extern int b_modes[10] ;
139 extern int inter_y_modes[10] ;
140 extern int inter_uv_modes[4] ;
141 extern unsigned int inter_b_modes[15];
144 extern void (*vp8_short_fdct4x4)(short *input, short *output, int pitch);
145 extern void (*vp8_short_fdct8x4)(short *input, short *output, int pitch);
147 extern const int vp8_bits_per_mb[2][QINDEX_RANGE];
149 extern const int qrounding_factors[129];
150 extern const int qzbin_factors[129];
151 extern void vp8cx_init_quantizer(VP8_COMP *cpi);
152 extern const int vp8cx_base_skip_false_prob[128];
154 // Tables relating active max Q to active min Q
155 static const int kf_low_motion_minq[QINDEX_RANGE] =
157 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
158 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
159 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
160 0,0,0,0,1,1,1,1,1,1,1,1,2,2,2,2,
161 3,3,3,3,3,3,4,4,4,5,5,5,5,5,6,6,
162 6,6,7,7,8,8,8,8,9,9,10,10,10,10,11,11,
163 11,11,12,12,13,13,13,13,14,14,15,15,15,15,16,16,
164 16,16,17,17,18,18,18,18,19,20,20,21,21,22,23,23
166 static const int kf_high_motion_minq[QINDEX_RANGE] =
168 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
169 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
170 1,1,1,1,1,1,1,1,2,2,2,2,3,3,3,3,
171 3,3,3,3,4,4,4,4,5,5,5,5,5,5,6,6,
172 6,6,7,7,8,8,8,8,9,9,10,10,10,10,11,11,
173 11,11,12,12,13,13,13,13,14,14,15,15,15,15,16,16,
174 16,16,17,17,18,18,18,18,19,19,20,20,20,20,21,21,
175 21,21,22,22,23,23,24,25,25,26,26,27,28,28,29,30
177 static const int gf_low_motion_minq[QINDEX_RANGE] =
179 0,0,0,0,1,1,1,1,1,1,1,1,2,2,2,2,
180 3,3,3,3,4,4,4,4,5,5,5,5,6,6,6,6,
181 7,7,7,7,8,8,8,8,9,9,9,9,10,10,10,10,
182 11,11,12,12,13,13,14,14,15,15,16,16,17,17,18,18,
183 19,19,20,20,21,21,22,22,23,23,24,24,25,25,26,26,
184 27,27,28,28,29,29,30,30,31,31,32,32,33,33,34,34,
185 35,35,36,36,37,37,38,38,39,39,40,40,41,41,42,42,
186 43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58
188 static const int gf_mid_motion_minq[QINDEX_RANGE] =
190 0,0,0,0,1,1,1,1,1,1,2,2,3,3,3,4,
191 4,4,5,5,5,6,6,6,7,7,7,8,8,8,9,9,
192 9,10,10,10,10,11,11,11,12,12,12,12,13,13,13,14,
193 14,14,15,15,16,16,17,17,18,18,19,19,20,20,21,21,
194 22,22,23,23,24,24,25,25,26,26,27,27,28,28,29,29,
195 30,30,31,31,32,32,33,33,34,34,35,35,36,36,37,37,
196 38,39,39,40,40,41,41,42,42,43,43,44,45,46,47,48,
197 49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64
199 static const int gf_high_motion_minq[QINDEX_RANGE] =
201 0,0,0,0,1,1,1,1,1,2,2,2,3,3,3,4,
202 4,4,5,5,5,6,6,6,7,7,7,8,8,8,9,9,
203 9,10,10,10,11,11,12,12,13,13,14,14,15,15,16,16,
204 17,17,18,18,19,19,20,20,21,21,22,22,23,23,24,24,
205 25,25,26,26,27,27,28,28,29,29,30,30,31,31,32,32,
206 33,33,34,34,35,35,36,36,37,37,38,38,39,39,40,40,
207 41,41,42,42,43,44,45,46,47,48,49,50,51,52,53,54,
208 55,56,57,58,59,60,62,64,66,68,70,72,74,76,78,80
210 static const int inter_minq[QINDEX_RANGE] =
212 0,0,1,1,2,3,3,4,4,5,6,6,7,8,8,9,
213 9,10,11,11,12,13,13,14,15,15,16,17,17,18,19,20,
214 20,21,22,22,23,24,24,25,26,27,27,28,29,30,30,31,
215 32,33,33,34,35,36,36,37,38,39,39,40,41,42,42,43,
216 44,45,46,46,47,48,49,50,50,51,52,53,54,55,55,56,
217 57,58,59,60,60,61,62,63,64,65,66,67,67,68,69,70,
218 71,72,73,74,75,75,76,77,78,79,80,81,82,83,84,85,
219 86,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100
222 void vp8_initialize()
224 static int init_done = 0;
228 vp8_scale_machine_specific_config();
229 vp8_initialize_common();
230 //vp8_dmachine_specific_config();
231 vp8_tokenize_initialize();
236 #ifdef PACKET_TESTING
237 extern FILE *vpxlogc;
240 static void setup_features(VP8_COMP *cpi)
242 // Set up default state for MB feature flags
243 cpi->mb.e_mbd.segmentation_enabled = 0;
244 cpi->mb.e_mbd.update_mb_segmentation_map = 0;
245 cpi->mb.e_mbd.update_mb_segmentation_data = 0;
246 vpx_memset(cpi->mb.e_mbd.mb_segment_tree_probs, 255, sizeof(cpi->mb.e_mbd.mb_segment_tree_probs));
247 vpx_memset(cpi->mb.e_mbd.segment_feature_data, 0, sizeof(cpi->mb.e_mbd.segment_feature_data));
249 cpi->mb.e_mbd.mode_ref_lf_delta_enabled = 0;
250 cpi->mb.e_mbd.mode_ref_lf_delta_update = 0;
251 vpx_memset(cpi->mb.e_mbd.ref_lf_deltas, 0, sizeof(cpi->mb.e_mbd.ref_lf_deltas));
252 vpx_memset(cpi->mb.e_mbd.mode_lf_deltas, 0, sizeof(cpi->mb.e_mbd.mode_lf_deltas));
253 vpx_memset(cpi->mb.e_mbd.last_ref_lf_deltas, 0, sizeof(cpi->mb.e_mbd.ref_lf_deltas));
254 vpx_memset(cpi->mb.e_mbd.last_mode_lf_deltas, 0, sizeof(cpi->mb.e_mbd.mode_lf_deltas));
256 set_default_lf_deltas(cpi);
261 static void dealloc_compressor_data(VP8_COMP *cpi)
263 vpx_free(cpi->tplist);
266 // Delete last frame MV storage buffers
270 vpx_free(cpi->lf_ref_frame_sign_bias);
271 cpi->lf_ref_frame_sign_bias = 0;
273 vpx_free(cpi->lf_ref_frame);
274 cpi->lf_ref_frame = 0;
276 // Delete sementation map
277 vpx_free(cpi->segmentation_map);
278 cpi->segmentation_map = 0;
280 vpx_free(cpi->active_map);
283 vp8_de_alloc_frame_buffers(&cpi->common);
285 vp8_yv12_de_alloc_frame_buffer(&cpi->last_frame_uf);
286 vp8_yv12_de_alloc_frame_buffer(&cpi->scaled_source);
287 #if VP8_TEMPORAL_ALT_REF
288 vp8_yv12_de_alloc_frame_buffer(&cpi->alt_ref_buffer);
290 vp8_lookahead_destroy(cpi->lookahead);
295 // Structure used to monitor GF usage
296 vpx_free(cpi->gf_active_flags);
297 cpi->gf_active_flags = 0;
299 // Activity mask based per mb zbin adjustments
300 vpx_free(cpi->mb_activity_map);
301 cpi->mb_activity_map = 0;
302 vpx_free(cpi->mb_norm_activity_map);
303 cpi->mb_norm_activity_map = 0;
305 vpx_free(cpi->mb.pip);
308 #if !(CONFIG_REALTIME_ONLY)
309 vpx_free(cpi->twopass.total_stats);
310 cpi->twopass.total_stats = 0;
312 vpx_free(cpi->twopass.this_frame_stats);
313 cpi->twopass.this_frame_stats = 0;
317 static void enable_segmentation(VP8_PTR ptr)
319 VP8_COMP *cpi = (VP8_COMP *)(ptr);
321 // Set the appropriate feature bit
322 cpi->mb.e_mbd.segmentation_enabled = 1;
323 cpi->mb.e_mbd.update_mb_segmentation_map = 1;
324 cpi->mb.e_mbd.update_mb_segmentation_data = 1;
326 static void disable_segmentation(VP8_PTR ptr)
328 VP8_COMP *cpi = (VP8_COMP *)(ptr);
330 // Clear the appropriate feature bit
331 cpi->mb.e_mbd.segmentation_enabled = 0;
334 // Valid values for a segment are 0 to 3
335 // Segmentation map is arrange as [Rows][Columns]
336 static void set_segmentation_map(VP8_PTR ptr, unsigned char *segmentation_map)
338 VP8_COMP *cpi = (VP8_COMP *)(ptr);
340 // Copy in the new segmentation map
341 vpx_memcpy(cpi->segmentation_map, segmentation_map, (cpi->common.mb_rows * cpi->common.mb_cols));
343 // Signal that the map should be updated.
344 cpi->mb.e_mbd.update_mb_segmentation_map = 1;
345 cpi->mb.e_mbd.update_mb_segmentation_data = 1;
348 // The values given for each segment can be either deltas (from the default value chosen for the frame) or absolute values.
350 // Valid range for abs values is (0-127 for MB_LVL_ALT_Q) , (0-63 for SEGMENT_ALT_LF)
351 // Valid range for delta values are (+/-127 for MB_LVL_ALT_Q) , (+/-63 for SEGMENT_ALT_LF)
353 // abs_delta = SEGMENT_DELTADATA (deltas) abs_delta = SEGMENT_ABSDATA (use the absolute values given).
356 static void set_segment_data(VP8_PTR ptr, signed char *feature_data, unsigned char abs_delta)
358 VP8_COMP *cpi = (VP8_COMP *)(ptr);
360 cpi->mb.e_mbd.mb_segement_abs_delta = abs_delta;
361 vpx_memcpy(cpi->segment_feature_data, feature_data, sizeof(cpi->segment_feature_data));
365 static void segmentation_test_function(VP8_PTR ptr)
367 VP8_COMP *cpi = (VP8_COMP *)(ptr);
369 unsigned char *seg_map;
370 signed char feature_data[MB_LVL_MAX][MAX_MB_SEGMENTS];
372 // Create a temporary map for segmentation data.
373 CHECK_MEM_ERROR(seg_map, vpx_calloc(cpi->common.mb_rows * cpi->common.mb_cols, 1));
375 // MB loop to set local segmentation map
376 /*for ( i = 0; i < cpi->common.mb_rows; i++ )
378 for ( j = 0; j < cpi->common.mb_cols; j++ )
380 //seg_map[(i*cpi->common.mb_cols) + j] = (j % 2) + ((i%2)* 2);
381 //if ( j < cpi->common.mb_cols/2 )
383 // Segment 1 around the edge else 0
384 if ( (i == 0) || (j == 0) || (i == (cpi->common.mb_rows-1)) || (j == (cpi->common.mb_cols-1)) )
385 seg_map[(i*cpi->common.mb_cols) + j] = 1;
386 //else if ( (i < 2) || (j < 2) || (i > (cpi->common.mb_rows-3)) || (j > (cpi->common.mb_cols-3)) )
387 // seg_map[(i*cpi->common.mb_cols) + j] = 2;
388 //else if ( (i < 5) || (j < 5) || (i > (cpi->common.mb_rows-6)) || (j > (cpi->common.mb_cols-6)) )
389 // seg_map[(i*cpi->common.mb_cols) + j] = 3;
391 seg_map[(i*cpi->common.mb_cols) + j] = 0;
395 // Set the segmentation Map
396 set_segmentation_map(ptr, seg_map);
398 // Activate segmentation.
399 enable_segmentation(ptr);
401 // Set up the quant segment data
402 feature_data[MB_LVL_ALT_Q][0] = 0;
403 feature_data[MB_LVL_ALT_Q][1] = 4;
404 feature_data[MB_LVL_ALT_Q][2] = 0;
405 feature_data[MB_LVL_ALT_Q][3] = 0;
406 // Set up the loop segment data
407 feature_data[MB_LVL_ALT_LF][0] = 0;
408 feature_data[MB_LVL_ALT_LF][1] = 0;
409 feature_data[MB_LVL_ALT_LF][2] = 0;
410 feature_data[MB_LVL_ALT_LF][3] = 0;
412 // Initialise the feature data structure
413 // SEGMENT_DELTADATA 0, SEGMENT_ABSDATA 1
414 set_segment_data(ptr, &feature_data[0][0], SEGMENT_DELTADATA);
416 // Delete sementation map
423 // A simple function to cyclically refresh the background at a lower Q
424 static void cyclic_background_refresh(VP8_COMP *cpi, int Q, int lf_adjustment)
426 unsigned char *seg_map;
427 signed char feature_data[MB_LVL_MAX][MAX_MB_SEGMENTS];
429 int block_count = cpi->cyclic_refresh_mode_max_mbs_perframe;
430 int mbs_in_frame = cpi->common.mb_rows * cpi->common.mb_cols;
432 // Create a temporary map for segmentation data.
433 CHECK_MEM_ERROR(seg_map, vpx_calloc(cpi->common.mb_rows * cpi->common.mb_cols, 1));
435 cpi->cyclic_refresh_q = Q;
437 for (i = Q; i > 0; i--)
439 if (vp8_bits_per_mb[cpi->common.frame_type][i] >= ((vp8_bits_per_mb[cpi->common.frame_type][Q]*(Q + 128)) / 64))
440 //if ( vp8_bits_per_mb[cpi->common.frame_type][i] >= ((vp8_bits_per_mb[cpi->common.frame_type][Q]*((2*Q)+96))/64) )
446 cpi->cyclic_refresh_q = i;
448 // Only update for inter frames
449 if (cpi->common.frame_type != KEY_FRAME)
451 // Cycle through the macro_block rows
452 // MB loop to set local segmentation map
453 for (i = cpi->cyclic_refresh_mode_index; i < mbs_in_frame; i++)
455 // If the MB is as a candidate for clean up then mark it for possible boost/refresh (segment 1)
456 // The segment id may get reset to 0 later if the MB gets coded anything other than last frame 0,0
457 // as only (last frame 0,0) MBs are eligable for refresh : that is to say Mbs likely to be background blocks.
458 if (cpi->cyclic_refresh_map[i] == 0)
466 // Skip blocks that have been refreshed recently anyway.
467 if (cpi->cyclic_refresh_map[i] < 0)
468 //cpi->cyclic_refresh_map[i] = cpi->cyclic_refresh_map[i] / 16;
469 cpi->cyclic_refresh_map[i]++;
480 // If we have gone through the frame reset to the start
481 cpi->cyclic_refresh_mode_index = i;
483 if (cpi->cyclic_refresh_mode_index >= mbs_in_frame)
484 cpi->cyclic_refresh_mode_index = 0;
487 // Set the segmentation Map
488 set_segmentation_map((VP8_PTR)cpi, seg_map);
490 // Activate segmentation.
491 enable_segmentation((VP8_PTR)cpi);
493 // Set up the quant segment data
494 feature_data[MB_LVL_ALT_Q][0] = 0;
495 feature_data[MB_LVL_ALT_Q][1] = (cpi->cyclic_refresh_q - Q);
496 feature_data[MB_LVL_ALT_Q][2] = 0;
497 feature_data[MB_LVL_ALT_Q][3] = 0;
499 // Set up the loop segment data
500 feature_data[MB_LVL_ALT_LF][0] = 0;
501 feature_data[MB_LVL_ALT_LF][1] = lf_adjustment;
502 feature_data[MB_LVL_ALT_LF][2] = 0;
503 feature_data[MB_LVL_ALT_LF][3] = 0;
505 // Initialise the feature data structure
506 // SEGMENT_DELTADATA 0, SEGMENT_ABSDATA 1
507 set_segment_data((VP8_PTR)cpi, &feature_data[0][0], SEGMENT_DELTADATA);
509 // Delete sementation map
516 static void set_default_lf_deltas(VP8_COMP *cpi)
518 cpi->mb.e_mbd.mode_ref_lf_delta_enabled = 1;
519 cpi->mb.e_mbd.mode_ref_lf_delta_update = 1;
521 vpx_memset(cpi->mb.e_mbd.ref_lf_deltas, 0, sizeof(cpi->mb.e_mbd.ref_lf_deltas));
522 vpx_memset(cpi->mb.e_mbd.mode_lf_deltas, 0, sizeof(cpi->mb.e_mbd.mode_lf_deltas));
524 // Test of ref frame deltas
525 cpi->mb.e_mbd.ref_lf_deltas[INTRA_FRAME] = 2;
526 cpi->mb.e_mbd.ref_lf_deltas[LAST_FRAME] = 0;
527 cpi->mb.e_mbd.ref_lf_deltas[GOLDEN_FRAME] = -2;
528 cpi->mb.e_mbd.ref_lf_deltas[ALTREF_FRAME] = -2;
530 cpi->mb.e_mbd.mode_lf_deltas[0] = 4; // BPRED
531 cpi->mb.e_mbd.mode_lf_deltas[1] = -2; // Zero
532 cpi->mb.e_mbd.mode_lf_deltas[2] = 2; // New mv
533 cpi->mb.e_mbd.mode_lf_deltas[3] = 4; // Split mv
536 void vp8_set_speed_features(VP8_COMP *cpi)
538 SPEED_FEATURES *sf = &cpi->sf;
539 int Mode = cpi->compressor_speed;
540 int Speed = cpi->Speed;
542 VP8_COMMON *cm = &cpi->common;
543 int last_improved_quant = sf->improved_quant;
545 // Initialise default mode frequency sampling variables
546 for (i = 0; i < MAX_MODES; i ++)
548 cpi->mode_check_freq[i] = 0;
549 cpi->mode_test_hit_counts[i] = 0;
550 cpi->mode_chosen_counts[i] = 0;
553 cpi->mbs_tested_so_far = 0;
555 // best quality defaults
557 sf->search_method = NSTEP;
558 sf->improved_quant = 1;
559 sf->improved_dct = 1;
562 sf->quarter_pixel_search = 1;
563 sf->half_pixel_search = 1;
564 sf->full_freq[0] = 7;
565 sf->full_freq[1] = 7;
566 sf->min_fs_radius = 8;
567 sf->max_fs_radius = 32;
568 sf->iterative_sub_pixel = 1;
569 sf->optimize_coefficients = 1;
570 sf->use_fastquant_for_pick = 0;
571 sf->no_skip_block4x4_search = 1;
574 sf->max_step_search_steps = MAX_MVSEARCH_STEPS;
575 sf->improved_mv_pred = 1;
577 // default thresholds to 0
578 for (i = 0; i < MAX_MODES; i++)
579 sf->thresh_mult[i] = 0;
583 #if !(CONFIG_REALTIME_ONLY)
584 case 0: // best quality mode
585 sf->thresh_mult[THR_ZEROMV ] = 0;
586 sf->thresh_mult[THR_ZEROG ] = 0;
587 sf->thresh_mult[THR_ZEROA ] = 0;
588 sf->thresh_mult[THR_NEARESTMV] = 0;
589 sf->thresh_mult[THR_NEARESTG ] = 0;
590 sf->thresh_mult[THR_NEARESTA ] = 0;
591 sf->thresh_mult[THR_NEARMV ] = 0;
592 sf->thresh_mult[THR_NEARG ] = 0;
593 sf->thresh_mult[THR_NEARA ] = 0;
595 sf->thresh_mult[THR_DC ] = 0;
597 sf->thresh_mult[THR_V_PRED ] = 1000;
598 sf->thresh_mult[THR_H_PRED ] = 1000;
599 sf->thresh_mult[THR_B_PRED ] = 2000;
600 sf->thresh_mult[THR_TM ] = 1000;
602 sf->thresh_mult[THR_NEWMV ] = 1000;
603 sf->thresh_mult[THR_NEWG ] = 1000;
604 sf->thresh_mult[THR_NEWA ] = 1000;
606 sf->thresh_mult[THR_SPLITMV ] = 2500;
607 sf->thresh_mult[THR_SPLITG ] = 5000;
608 sf->thresh_mult[THR_SPLITA ] = 5000;
610 sf->full_freq[0] = 7;
611 sf->full_freq[1] = 15;
614 sf->max_step_search_steps = MAX_MVSEARCH_STEPS;
618 sf->thresh_mult[THR_NEARESTMV] = 0;
619 sf->thresh_mult[THR_ZEROMV ] = 0;
620 sf->thresh_mult[THR_DC ] = 0;
621 sf->thresh_mult[THR_NEARMV ] = 0;
622 sf->thresh_mult[THR_V_PRED ] = 1000;
623 sf->thresh_mult[THR_H_PRED ] = 1000;
624 sf->thresh_mult[THR_B_PRED ] = 2500;
625 sf->thresh_mult[THR_TM ] = 1000;
627 sf->thresh_mult[THR_NEARESTG ] = 1000;
628 sf->thresh_mult[THR_NEARESTA ] = 1000;
630 sf->thresh_mult[THR_ZEROG ] = 1000;
631 sf->thresh_mult[THR_ZEROA ] = 1000;
632 sf->thresh_mult[THR_NEARG ] = 1000;
633 sf->thresh_mult[THR_NEARA ] = 1000;
636 sf->thresh_mult[THR_ZEROMV ] = 0;
637 sf->thresh_mult[THR_ZEROG ] = 0;
638 sf->thresh_mult[THR_ZEROA ] = 0;
639 sf->thresh_mult[THR_NEARESTMV] = 0;
640 sf->thresh_mult[THR_NEARESTG ] = 0;
641 sf->thresh_mult[THR_NEARESTA ] = 0;
642 sf->thresh_mult[THR_NEARMV ] = 0;
643 sf->thresh_mult[THR_NEARG ] = 0;
644 sf->thresh_mult[THR_NEARA ] = 0;
646 // sf->thresh_mult[THR_DC ] = 0;
648 // sf->thresh_mult[THR_V_PRED ] = 1000;
649 // sf->thresh_mult[THR_H_PRED ] = 1000;
650 // sf->thresh_mult[THR_B_PRED ] = 2000;
651 // sf->thresh_mult[THR_TM ] = 1000;
653 sf->thresh_mult[THR_NEWMV ] = 1000;
654 sf->thresh_mult[THR_NEWG ] = 1000;
655 sf->thresh_mult[THR_NEWA ] = 1000;
657 sf->thresh_mult[THR_SPLITMV ] = 1700;
658 sf->thresh_mult[THR_SPLITG ] = 4500;
659 sf->thresh_mult[THR_SPLITA ] = 4500;
661 sf->thresh_mult[THR_NEWMV ] = 1500;
662 sf->thresh_mult[THR_NEWG ] = 1500;
663 sf->thresh_mult[THR_NEWA ] = 1500;
665 sf->thresh_mult[THR_SPLITMV ] = 5000;
666 sf->thresh_mult[THR_SPLITG ] = 10000;
667 sf->thresh_mult[THR_SPLITA ] = 10000;
669 sf->full_freq[0] = 15;
670 sf->full_freq[1] = 31;
674 /* Disable coefficient optimization above speed 0 */
675 sf->optimize_coefficients = 0;
676 sf->use_fastquant_for_pick = 1;
677 sf->no_skip_block4x4_search = 0;
681 cpi->mode_check_freq[THR_SPLITG] = 2;
682 cpi->mode_check_freq[THR_SPLITA] = 2;
683 cpi->mode_check_freq[THR_SPLITMV] = 0;
688 cpi->mode_check_freq[THR_SPLITG] = 4;
689 cpi->mode_check_freq[THR_SPLITA] = 4;
690 cpi->mode_check_freq[THR_SPLITMV] = 2;
692 sf->thresh_mult[THR_TM ] = 1500;
693 sf->thresh_mult[THR_V_PRED ] = 1500;
694 sf->thresh_mult[THR_H_PRED ] = 1500;
695 sf->thresh_mult[THR_B_PRED ] = 5000;
697 if (cpi->ref_frame_flags & VP8_LAST_FLAG)
699 sf->thresh_mult[THR_NEWMV ] = 2000;
700 sf->thresh_mult[THR_SPLITMV ] = 10000;
703 if (cpi->ref_frame_flags & VP8_GOLD_FLAG)
705 sf->thresh_mult[THR_NEARESTG ] = 1500;
706 sf->thresh_mult[THR_ZEROG ] = 1500;
707 sf->thresh_mult[THR_NEARG ] = 1500;
708 sf->thresh_mult[THR_NEWG ] = 2000;
709 sf->thresh_mult[THR_SPLITG ] = 20000;
712 if (cpi->ref_frame_flags & VP8_ALT_FLAG)
714 sf->thresh_mult[THR_NEARESTA ] = 1500;
715 sf->thresh_mult[THR_ZEROA ] = 1500;
716 sf->thresh_mult[THR_NEARA ] = 1500;
717 sf->thresh_mult[THR_NEWA ] = 2000;
718 sf->thresh_mult[THR_SPLITA ] = 20000;
724 cpi->mode_check_freq[THR_SPLITG] = 15;
725 cpi->mode_check_freq[THR_SPLITA] = 15;
726 cpi->mode_check_freq[THR_SPLITMV] = 7;
728 sf->thresh_mult[THR_TM ] = 2000;
729 sf->thresh_mult[THR_V_PRED ] = 2000;
730 sf->thresh_mult[THR_H_PRED ] = 2000;
731 sf->thresh_mult[THR_B_PRED ] = 7500;
733 if (cpi->ref_frame_flags & VP8_LAST_FLAG)
735 sf->thresh_mult[THR_NEWMV ] = 2000;
736 sf->thresh_mult[THR_SPLITMV ] = 25000;
739 if (cpi->ref_frame_flags & VP8_GOLD_FLAG)
741 sf->thresh_mult[THR_NEARESTG ] = 2000;
742 sf->thresh_mult[THR_ZEROG ] = 2000;
743 sf->thresh_mult[THR_NEARG ] = 2000;
744 sf->thresh_mult[THR_NEWG ] = 2500;
745 sf->thresh_mult[THR_SPLITG ] = 50000;
748 if (cpi->ref_frame_flags & VP8_ALT_FLAG)
750 sf->thresh_mult[THR_NEARESTA ] = 2000;
751 sf->thresh_mult[THR_ZEROA ] = 2000;
752 sf->thresh_mult[THR_NEARA ] = 2000;
753 sf->thresh_mult[THR_NEWA ] = 2500;
754 sf->thresh_mult[THR_SPLITA ] = 50000;
757 sf->improved_quant = 0;
758 sf->improved_dct = 0;
760 // Only do recode loop on key frames, golden frames and
764 sf->full_freq[0] = 31;
765 sf->full_freq[1] = 63;
770 sf->thresh_mult[THR_SPLITA ] = INT_MAX;
771 sf->thresh_mult[THR_SPLITG ] = INT_MAX;
772 sf->thresh_mult[THR_SPLITMV ] = INT_MAX;
774 cpi->mode_check_freq[THR_V_PRED] = 0;
775 cpi->mode_check_freq[THR_H_PRED] = 0;
776 cpi->mode_check_freq[THR_B_PRED] = 0;
777 cpi->mode_check_freq[THR_NEARG] = 0;
778 cpi->mode_check_freq[THR_NEWG] = 0;
779 cpi->mode_check_freq[THR_NEARA] = 0;
780 cpi->mode_check_freq[THR_NEWA] = 0;
783 sf->recode_loop = 0; // recode loop off
784 sf->RD = 0; // Turn rd off
786 sf->full_freq[0] = 63;
787 sf->full_freq[1] = 127;
792 sf->auto_filter = 0; // Faster selection of loop filter
793 sf->full_freq[0] = INT_MAX;
794 sf->full_freq[1] = INT_MAX;
796 cpi->mode_check_freq[THR_V_PRED] = 2;
797 cpi->mode_check_freq[THR_H_PRED] = 2;
798 cpi->mode_check_freq[THR_B_PRED] = 2;
800 if (cpi->ref_frame_flags & VP8_GOLD_FLAG)
802 cpi->mode_check_freq[THR_NEARG] = 2;
803 cpi->mode_check_freq[THR_NEWG] = 4;
806 if (cpi->ref_frame_flags & VP8_ALT_FLAG)
808 cpi->mode_check_freq[THR_NEARA] = 2;
809 cpi->mode_check_freq[THR_NEWA] = 4;
812 if (cpi->ref_frame_flags & VP8_GOLD_FLAG)
814 sf->thresh_mult[THR_NEARESTG ] = 2000;
815 sf->thresh_mult[THR_ZEROG ] = 2000;
816 sf->thresh_mult[THR_NEARG ] = 2000;
817 sf->thresh_mult[THR_NEWG ] = 4000;
820 if (cpi->ref_frame_flags & VP8_ALT_FLAG)
822 sf->thresh_mult[THR_NEARESTA ] = 2000;
823 sf->thresh_mult[THR_ZEROA ] = 2000;
824 sf->thresh_mult[THR_NEARA ] = 2000;
825 sf->thresh_mult[THR_NEWA ] = 4000;
832 sf->optimize_coefficients = 0;
835 sf->iterative_sub_pixel = 1;
836 sf->thresh_mult[THR_NEARESTMV] = 0;
837 sf->thresh_mult[THR_ZEROMV ] = 0;
838 sf->thresh_mult[THR_DC ] = 0;
839 sf->thresh_mult[THR_TM ] = 0;
840 sf->thresh_mult[THR_NEARMV ] = 0;
841 sf->thresh_mult[THR_V_PRED ] = 1000;
842 sf->thresh_mult[THR_H_PRED ] = 1000;
843 sf->thresh_mult[THR_B_PRED ] = 2500;
844 sf->thresh_mult[THR_NEARESTG ] = 1000;
845 sf->thresh_mult[THR_ZEROG ] = 1000;
846 sf->thresh_mult[THR_NEARG ] = 1000;
847 sf->thresh_mult[THR_NEARESTA ] = 1000;
848 sf->thresh_mult[THR_ZEROA ] = 1000;
849 sf->thresh_mult[THR_NEARA ] = 1000;
850 sf->thresh_mult[THR_NEWMV ] = 2000;
851 sf->thresh_mult[THR_NEWG ] = 2000;
852 sf->thresh_mult[THR_NEWA ] = 2000;
853 sf->thresh_mult[THR_SPLITMV ] = 5000;
854 sf->thresh_mult[THR_SPLITG ] = 10000;
855 sf->thresh_mult[THR_SPLITA ] = 10000;
856 sf->full_freq[0] = 15;
857 sf->full_freq[1] = 31;
858 sf->search_method = NSTEP;
862 cpi->mode_check_freq[THR_SPLITG] = 4;
863 cpi->mode_check_freq[THR_SPLITA] = 4;
864 cpi->mode_check_freq[THR_SPLITMV] = 2;
866 sf->thresh_mult[THR_DC ] = 0;
867 sf->thresh_mult[THR_TM ] = 1000;
868 sf->thresh_mult[THR_V_PRED ] = 2000;
869 sf->thresh_mult[THR_H_PRED ] = 2000;
870 sf->thresh_mult[THR_B_PRED ] = 5000;
872 if (cpi->ref_frame_flags & VP8_LAST_FLAG)
874 sf->thresh_mult[THR_NEARESTMV] = 0;
875 sf->thresh_mult[THR_ZEROMV ] = 0;
876 sf->thresh_mult[THR_NEARMV ] = 0;
877 sf->thresh_mult[THR_NEWMV ] = 2000;
878 sf->thresh_mult[THR_SPLITMV ] = 10000;
881 if (cpi->ref_frame_flags & VP8_GOLD_FLAG)
883 sf->thresh_mult[THR_NEARESTG ] = 1000;
884 sf->thresh_mult[THR_ZEROG ] = 1000;
885 sf->thresh_mult[THR_NEARG ] = 1000;
886 sf->thresh_mult[THR_NEWG ] = 2000;
887 sf->thresh_mult[THR_SPLITG ] = 20000;
890 if (cpi->ref_frame_flags & VP8_ALT_FLAG)
892 sf->thresh_mult[THR_NEARESTA ] = 1000;
893 sf->thresh_mult[THR_ZEROA ] = 1000;
894 sf->thresh_mult[THR_NEARA ] = 1000;
895 sf->thresh_mult[THR_NEWA ] = 2000;
896 sf->thresh_mult[THR_SPLITA ] = 20000;
899 sf->improved_quant = 0;
900 sf->improved_dct = 0;
905 cpi->mode_check_freq[THR_SPLITMV] = 7;
906 cpi->mode_check_freq[THR_SPLITG] = 15;
907 cpi->mode_check_freq[THR_SPLITA] = 15;
909 sf->thresh_mult[THR_TM ] = 2000;
910 sf->thresh_mult[THR_V_PRED ] = 2000;
911 sf->thresh_mult[THR_H_PRED ] = 2000;
912 sf->thresh_mult[THR_B_PRED ] = 5000;
914 if (cpi->ref_frame_flags & VP8_LAST_FLAG)
916 sf->thresh_mult[THR_NEWMV ] = 2000;
917 sf->thresh_mult[THR_SPLITMV ] = 25000;
920 if (cpi->ref_frame_flags & VP8_GOLD_FLAG)
922 sf->thresh_mult[THR_NEARESTG ] = 2000;
923 sf->thresh_mult[THR_ZEROG ] = 2000;
924 sf->thresh_mult[THR_NEARG ] = 2000;
925 sf->thresh_mult[THR_NEWG ] = 2500;
926 sf->thresh_mult[THR_SPLITG ] = 50000;
929 if (cpi->ref_frame_flags & VP8_ALT_FLAG)
931 sf->thresh_mult[THR_NEARESTA ] = 2000;
932 sf->thresh_mult[THR_ZEROA ] = 2000;
933 sf->thresh_mult[THR_NEARA ] = 2000;
934 sf->thresh_mult[THR_NEWA ] = 2500;
935 sf->thresh_mult[THR_SPLITA ] = 50000;
938 sf->full_freq[0] = 31;
939 sf->full_freq[1] = 63;
944 sf->auto_filter = 0; // Faster selection of loop filter
946 cpi->mode_check_freq[THR_V_PRED] = 2;
947 cpi->mode_check_freq[THR_H_PRED] = 2;
948 cpi->mode_check_freq[THR_B_PRED] = 2;
950 if (cpi->ref_frame_flags & VP8_GOLD_FLAG)
952 cpi->mode_check_freq[THR_NEARG] = 2;
953 cpi->mode_check_freq[THR_NEWG] = 4;
956 if (cpi->ref_frame_flags & VP8_ALT_FLAG)
958 cpi->mode_check_freq[THR_NEARA] = 2;
959 cpi->mode_check_freq[THR_NEWA] = 4;
962 sf->thresh_mult[THR_SPLITMV ] = INT_MAX;
963 sf->thresh_mult[THR_SPLITG ] = INT_MAX;
964 sf->thresh_mult[THR_SPLITA ] = INT_MAX;
966 sf->full_freq[0] = 63;
967 sf->full_freq[1] = 127;
973 sf->full_freq[0] = INT_MAX;
974 sf->full_freq[1] = INT_MAX;
981 sf->auto_filter = 0; // Faster selection of loop filter
983 sf->search_method = HEX;
984 //sf->search_method = DIAMOND;
986 sf->iterative_sub_pixel = 0;
988 cpi->mode_check_freq[THR_V_PRED] = 4;
989 cpi->mode_check_freq[THR_H_PRED] = 4;
990 cpi->mode_check_freq[THR_B_PRED] = 4;
992 if (cpi->ref_frame_flags & VP8_GOLD_FLAG)
994 cpi->mode_check_freq[THR_NEARG] = 2;
995 cpi->mode_check_freq[THR_NEWG] = 4;
998 if (cpi->ref_frame_flags & VP8_ALT_FLAG)
1000 cpi->mode_check_freq[THR_NEARA] = 2;
1001 cpi->mode_check_freq[THR_NEWA] = 4;
1004 sf->thresh_mult[THR_TM ] = 2000;
1005 sf->thresh_mult[THR_B_PRED ] = 5000;
1007 if (cpi->ref_frame_flags & VP8_GOLD_FLAG)
1009 sf->thresh_mult[THR_NEARESTG ] = 2000;
1010 sf->thresh_mult[THR_ZEROG ] = 2000;
1011 sf->thresh_mult[THR_NEARG ] = 2000;
1012 sf->thresh_mult[THR_NEWG ] = 4000;
1015 if (cpi->ref_frame_flags & VP8_ALT_FLAG)
1017 sf->thresh_mult[THR_NEARESTA ] = 2000;
1018 sf->thresh_mult[THR_ZEROA ] = 2000;
1019 sf->thresh_mult[THR_NEARA ] = 2000;
1020 sf->thresh_mult[THR_NEWA ] = 4000;
1026 // Disable split MB intra prediction mode
1027 sf->thresh_mult[THR_B_PRED] = INT_MAX;
1032 unsigned int i, sum = 0;
1033 unsigned int total_mbs = cm->MBs;
1039 if (cpi->oxcf.encode_breakout > 2000)
1040 min = cpi->oxcf.encode_breakout;
1044 for (i = 0; i < min; i++)
1046 sum += cpi->error_bins[i];
1052 // i starts from 2 to make sure thresh started from 2048
1053 for (; i < 1024; i++)
1055 sum += cpi->error_bins[i];
1057 if (10 * sum >= (unsigned int)(cpi->Speed - 6)*(total_mbs - total_skip))
1067 if (cpi->ref_frame_flags & VP8_LAST_FLAG)
1069 sf->thresh_mult[THR_NEWMV] = thresh;
1070 sf->thresh_mult[THR_NEARESTMV ] = thresh >> 1;
1071 sf->thresh_mult[THR_NEARMV ] = thresh >> 1;
1074 if (cpi->ref_frame_flags & VP8_GOLD_FLAG)
1076 sf->thresh_mult[THR_NEWG] = thresh << 1;
1077 sf->thresh_mult[THR_NEARESTG ] = thresh;
1078 sf->thresh_mult[THR_NEARG ] = thresh;
1081 if (cpi->ref_frame_flags & VP8_ALT_FLAG)
1083 sf->thresh_mult[THR_NEWA] = thresh << 1;
1084 sf->thresh_mult[THR_NEARESTA ] = thresh;
1085 sf->thresh_mult[THR_NEARA ] = thresh;
1088 // Disable other intra prediction modes
1089 sf->thresh_mult[THR_TM] = INT_MAX;
1090 sf->thresh_mult[THR_V_PRED] = INT_MAX;
1091 sf->thresh_mult[THR_H_PRED] = INT_MAX;
1093 sf->improved_mv_pred = 0;
1098 sf->quarter_pixel_search = 0;
1103 int Tmp = cpi->Speed - 8;
1108 if (cpi->ref_frame_flags & VP8_GOLD_FLAG)
1110 cpi->mode_check_freq[THR_ZEROG] = 1 << (Tmp - 1);
1111 cpi->mode_check_freq[THR_NEARESTG] = 1 << (Tmp - 1);
1112 cpi->mode_check_freq[THR_NEARG] = 1 << Tmp;
1113 cpi->mode_check_freq[THR_NEWG] = 1 << (Tmp + 1);
1116 if (cpi->ref_frame_flags & VP8_ALT_FLAG)
1118 cpi->mode_check_freq[THR_ZEROA] = 1 << (Tmp - 1);
1119 cpi->mode_check_freq[THR_NEARESTA] = 1 << (Tmp - 1);
1120 cpi->mode_check_freq[THR_NEARA] = 1 << Tmp;
1121 cpi->mode_check_freq[THR_NEWA] = 1 << (Tmp + 1);
1124 cpi->mode_check_freq[THR_NEWMV] = 1 << (Tmp - 1);
1127 cm->filter_type = NORMAL_LOOPFILTER;
1130 cm->filter_type = SIMPLE_LOOPFILTER;
1134 sf->half_pixel_search = 0; // This has a big hit on quality. Last resort
1137 vpx_memset(cpi->error_bins, 0, sizeof(cpi->error_bins));
1141 /* disable frame modes if flags not set */
1142 if (!(cpi->ref_frame_flags & VP8_LAST_FLAG))
1144 sf->thresh_mult[THR_NEWMV ] = INT_MAX;
1145 sf->thresh_mult[THR_NEARESTMV] = INT_MAX;
1146 sf->thresh_mult[THR_ZEROMV ] = INT_MAX;
1147 sf->thresh_mult[THR_NEARMV ] = INT_MAX;
1148 sf->thresh_mult[THR_SPLITMV ] = INT_MAX;
1151 if (!(cpi->ref_frame_flags & VP8_GOLD_FLAG))
1153 sf->thresh_mult[THR_NEARESTG ] = INT_MAX;
1154 sf->thresh_mult[THR_ZEROG ] = INT_MAX;
1155 sf->thresh_mult[THR_NEARG ] = INT_MAX;
1156 sf->thresh_mult[THR_NEWG ] = INT_MAX;
1157 sf->thresh_mult[THR_SPLITG ] = INT_MAX;
1160 if (!(cpi->ref_frame_flags & VP8_ALT_FLAG))
1162 sf->thresh_mult[THR_NEARESTA ] = INT_MAX;
1163 sf->thresh_mult[THR_ZEROA ] = INT_MAX;
1164 sf->thresh_mult[THR_NEARA ] = INT_MAX;
1165 sf->thresh_mult[THR_NEWA ] = INT_MAX;
1166 sf->thresh_mult[THR_SPLITA ] = INT_MAX;
1170 // Slow quant, dct and trellis not worthwhile for first pass
1171 // so make sure they are always turned off.
1172 if ( cpi->pass == 1 )
1174 sf->improved_quant = 0;
1175 sf->optimize_coefficients = 0;
1176 sf->improved_dct = 0;
1179 if (cpi->sf.search_method == NSTEP)
1181 vp8_init3smotion_compensation(&cpi->mb, cm->yv12_fb[cm->lst_fb_idx].y_stride);
1183 else if (cpi->sf.search_method == DIAMOND)
1185 vp8_init_dsmotion_compensation(&cpi->mb, cm->yv12_fb[cm->lst_fb_idx].y_stride);
1188 if (cpi->sf.improved_dct)
1190 cpi->mb.vp8_short_fdct8x4 = FDCT_INVOKE(&cpi->rtcd.fdct, short8x4);
1191 cpi->mb.vp8_short_fdct4x4 = FDCT_INVOKE(&cpi->rtcd.fdct, short4x4);
1195 cpi->mb.vp8_short_fdct8x4 = FDCT_INVOKE(&cpi->rtcd.fdct, fast8x4);
1196 cpi->mb.vp8_short_fdct4x4 = FDCT_INVOKE(&cpi->rtcd.fdct, fast4x4);
1199 cpi->mb.short_walsh4x4 = FDCT_INVOKE(&cpi->rtcd.fdct, walsh_short4x4);
1201 if (cpi->sf.improved_quant)
1203 cpi->mb.quantize_b = QUANTIZE_INVOKE(&cpi->rtcd.quantize, quantb);
1207 cpi->mb.quantize_b = QUANTIZE_INVOKE(&cpi->rtcd.quantize, fastquantb);
1209 if (cpi->sf.improved_quant != last_improved_quant)
1210 vp8cx_init_quantizer(cpi);
1212 #if CONFIG_RUNTIME_CPU_DETECT
1213 cpi->mb.e_mbd.rtcd = &cpi->common.rtcd;
1216 if (cpi->sf.iterative_sub_pixel == 1)
1218 cpi->find_fractional_mv_step = vp8_find_best_sub_pixel_step_iteratively;
1220 else if (cpi->sf.quarter_pixel_search)
1222 cpi->find_fractional_mv_step = vp8_find_best_sub_pixel_step;
1224 else if (cpi->sf.half_pixel_search)
1226 cpi->find_fractional_mv_step = vp8_find_best_half_pixel_step;
1230 cpi->find_fractional_mv_step = vp8_skip_fractional_mv_step;
1233 if (cpi->sf.optimize_coefficients == 1 && cpi->pass!=1)
1234 cpi->mb.optimize = 1;
1236 cpi->mb.optimize = 0;
1238 if (cpi->common.full_pixel)
1239 cpi->find_fractional_mv_step = vp8_skip_fractional_mv_step;
1242 frames_at_speed[cpi->Speed]++;
1245 static void alloc_raw_frame_buffers(VP8_COMP *cpi)
1247 int width = (cpi->oxcf.Width + 15) & ~15;
1248 int height = (cpi->oxcf.Height + 15) & ~15;
1250 cpi->lookahead = vp8_lookahead_init(cpi->oxcf.Width, cpi->oxcf.Height,
1251 cpi->oxcf.lag_in_frames);
1253 vpx_internal_error(&cpi->common.error, VPX_CODEC_MEM_ERROR,
1254 "Failed to allocate lag buffers");
1256 #if VP8_TEMPORAL_ALT_REF
1258 if (vp8_yv12_alloc_frame_buffer(&cpi->alt_ref_buffer,
1260 vpx_internal_error(&cpi->common.error, VPX_CODEC_MEM_ERROR,
1261 "Failed to allocate altref buffer");
1266 static int vp8_alloc_partition_data(VP8_COMP *cpi)
1268 vpx_free(cpi->mb.pip);
1270 cpi->mb.pip = vpx_calloc((cpi->common.mb_cols + 1) *
1271 (cpi->common.mb_rows + 1),
1272 sizeof(PARTITION_INFO));
1276 cpi->mb.pi = cpi->mb.pip + cpi->common.mode_info_stride + 1;
1281 void vp8_alloc_compressor_data(VP8_COMP *cpi)
1283 VP8_COMMON *cm = & cpi->common;
1285 int width = cm->Width;
1286 int height = cm->Height;
1288 if (vp8_alloc_frame_buffers(cm, width, height))
1289 vpx_internal_error(&cpi->common.error, VPX_CODEC_MEM_ERROR,
1290 "Failed to allocate frame buffers");
1292 if (vp8_alloc_partition_data(cpi))
1293 vpx_internal_error(&cpi->common.error, VPX_CODEC_MEM_ERROR,
1294 "Failed to allocate partition data");
1297 if ((width & 0xf) != 0)
1298 width += 16 - (width & 0xf);
1300 if ((height & 0xf) != 0)
1301 height += 16 - (height & 0xf);
1304 if (vp8_yv12_alloc_frame_buffer(&cpi->last_frame_uf,
1305 width, height, VP8BORDERINPIXELS))
1306 vpx_internal_error(&cpi->common.error, VPX_CODEC_MEM_ERROR,
1307 "Failed to allocate last frame buffer");
1309 if (vp8_yv12_alloc_frame_buffer(&cpi->scaled_source, width, height, 16))
1310 vpx_internal_error(&cpi->common.error, VPX_CODEC_MEM_ERROR,
1311 "Failed to allocate scaled source buffer");
1317 unsigned int tokens = cm->mb_rows * cm->mb_cols * 24 * 16;
1319 CHECK_MEM_ERROR(cpi->tok, vpx_calloc(tokens, sizeof(*cpi->tok)));
1322 // Data used for real time vc mode to see if gf needs refreshing
1323 cpi->inter_zz_count = 0;
1324 cpi->gf_bad_count = 0;
1325 cpi->gf_update_recommended = 0;
1328 // Structures used to minitor GF usage
1329 vpx_free(cpi->gf_active_flags);
1330 CHECK_MEM_ERROR(cpi->gf_active_flags,
1331 vpx_calloc(1, cm->mb_rows * cm->mb_cols));
1332 cpi->gf_active_count = cm->mb_rows * cm->mb_cols;
1334 vpx_free(cpi->mb_activity_map);
1335 CHECK_MEM_ERROR(cpi->mb_activity_map,
1336 vpx_calloc(sizeof(unsigned int),
1337 cm->mb_rows * cm->mb_cols));
1339 vpx_free(cpi->mb_norm_activity_map);
1340 CHECK_MEM_ERROR(cpi->mb_norm_activity_map,
1341 vpx_calloc(sizeof(unsigned int),
1342 cm->mb_rows * cm->mb_cols));
1344 #if !(CONFIG_REALTIME_ONLY)
1345 vpx_free(cpi->twopass.total_stats);
1347 cpi->twopass.total_stats = vpx_calloc(1, sizeof(FIRSTPASS_STATS));
1349 vpx_free(cpi->twopass.this_frame_stats);
1351 cpi->twopass.this_frame_stats = vpx_calloc(1, sizeof(FIRSTPASS_STATS));
1353 if(!cpi->twopass.total_stats || !cpi->twopass.this_frame_stats)
1354 vpx_internal_error(&cpi->common.error, VPX_CODEC_MEM_ERROR,
1355 "Failed to allocate firstpass stats");
1358 #if CONFIG_MULTITHREAD
1360 cpi->mt_sync_range = 1;
1361 else if (width <= 1280)
1362 cpi->mt_sync_range = 4;
1363 else if (width <= 2560)
1364 cpi->mt_sync_range = 8;
1366 cpi->mt_sync_range = 16;
1369 vpx_free(cpi->tplist);
1371 CHECK_MEM_ERROR(cpi->tplist, vpx_malloc(sizeof(TOKENLIST) * cpi->common.mb_rows));
1376 static const int q_trans[] =
1378 0, 1, 2, 3, 4, 5, 7, 8,
1379 9, 10, 12, 13, 15, 17, 18, 19,
1380 20, 21, 23, 24, 25, 26, 27, 28,
1381 29, 30, 31, 33, 35, 37, 39, 41,
1382 43, 45, 47, 49, 51, 53, 55, 57,
1383 59, 61, 64, 67, 70, 73, 76, 79,
1384 82, 85, 88, 91, 94, 97, 100, 103,
1385 106, 109, 112, 115, 118, 121, 124, 127,
1388 int vp8_reverse_trans(int x)
1392 for (i = 0; i < 64; i++)
1393 if (q_trans[i] >= x)
1398 void vp8_new_frame_rate(VP8_COMP *cpi, double framerate)
1403 cpi->oxcf.frame_rate = framerate;
1404 cpi->output_frame_rate = cpi->oxcf.frame_rate;
1405 cpi->per_frame_bandwidth = (int)(cpi->oxcf.target_bandwidth / cpi->output_frame_rate);
1406 cpi->av_per_frame_bandwidth = (int)(cpi->oxcf.target_bandwidth / cpi->output_frame_rate);
1407 cpi->min_frame_bandwidth = (int)(cpi->av_per_frame_bandwidth * cpi->oxcf.two_pass_vbrmin_section / 100);
1409 // Set Maximum gf/arf interval
1410 cpi->max_gf_interval = ((int)(cpi->output_frame_rate / 2.0) + 2);
1412 if(cpi->max_gf_interval < 12)
1413 cpi->max_gf_interval = 12;
1415 // Extended interval for genuinely static scenes
1416 cpi->twopass.static_scene_max_gf_interval = cpi->key_frame_frequency >> 1;
1418 // Special conditions when altr ref frame enabled in lagged compress mode
1419 if (cpi->oxcf.play_alternate && cpi->oxcf.lag_in_frames)
1421 if (cpi->max_gf_interval > cpi->oxcf.lag_in_frames - 1)
1422 cpi->max_gf_interval = cpi->oxcf.lag_in_frames - 1;
1424 if (cpi->twopass.static_scene_max_gf_interval > cpi->oxcf.lag_in_frames - 1)
1425 cpi->twopass.static_scene_max_gf_interval = cpi->oxcf.lag_in_frames - 1;
1428 if ( cpi->max_gf_interval > cpi->twopass.static_scene_max_gf_interval )
1429 cpi->max_gf_interval = cpi->twopass.static_scene_max_gf_interval;
1434 rescale(int val, int num, int denom)
1436 int64_t llnum = num;
1437 int64_t llden = denom;
1438 int64_t llval = val;
1440 return llval * llnum / llden;
1444 static void init_config(VP8_PTR ptr, VP8_CONFIG *oxcf)
1446 VP8_COMP *cpi = (VP8_COMP *)(ptr);
1447 VP8_COMMON *cm = &cpi->common;
1452 cpi->auto_adjust_gold_quantizer = 1;
1455 cm->version = oxcf->Version;
1456 vp8_setup_version(cm);
1458 // change includes all joint functionality
1459 vp8_change_config(ptr, oxcf);
1461 // Initialize active best and worst q and average q values.
1462 cpi->active_worst_quality = cpi->oxcf.worst_allowed_q;
1463 cpi->active_best_quality = cpi->oxcf.best_allowed_q;
1464 cpi->avg_frame_qindex = cpi->oxcf.worst_allowed_q;
1466 // Initialise the starting buffer levels
1467 cpi->buffer_level = cpi->oxcf.starting_buffer_level;
1468 cpi->bits_off_target = cpi->oxcf.starting_buffer_level;
1470 cpi->rolling_target_bits = cpi->av_per_frame_bandwidth;
1471 cpi->rolling_actual_bits = cpi->av_per_frame_bandwidth;
1472 cpi->long_rolling_target_bits = cpi->av_per_frame_bandwidth;
1473 cpi->long_rolling_actual_bits = cpi->av_per_frame_bandwidth;
1475 cpi->total_actual_bits = 0;
1476 cpi->total_target_vs_actual = 0;
1478 #if VP8_TEMPORAL_ALT_REF
1482 cpi->fixed_divide[0] = 0;
1484 for (i = 1; i < 512; i++)
1485 cpi->fixed_divide[i] = 0x80000 / i;
1491 void vp8_change_config(VP8_PTR ptr, VP8_CONFIG *oxcf)
1493 VP8_COMP *cpi = (VP8_COMP *)(ptr);
1494 VP8_COMMON *cm = &cpi->common;
1502 if (cm->version != oxcf->Version)
1504 cm->version = oxcf->Version;
1505 vp8_setup_version(cm);
1510 switch (cpi->oxcf.Mode)
1515 cpi->compressor_speed = 2;
1517 if (cpi->oxcf.cpu_used < -16)
1519 cpi->oxcf.cpu_used = -16;
1522 if (cpi->oxcf.cpu_used > 16)
1523 cpi->oxcf.cpu_used = 16;
1527 case MODE_GOODQUALITY:
1529 cpi->compressor_speed = 1;
1531 if (cpi->oxcf.cpu_used < -5)
1533 cpi->oxcf.cpu_used = -5;
1536 if (cpi->oxcf.cpu_used > 5)
1537 cpi->oxcf.cpu_used = 5;
1541 case MODE_BESTQUALITY:
1543 cpi->compressor_speed = 0;
1546 case MODE_FIRSTPASS:
1548 cpi->compressor_speed = 1;
1550 case MODE_SECONDPASS:
1552 cpi->compressor_speed = 1;
1554 if (cpi->oxcf.cpu_used < -5)
1556 cpi->oxcf.cpu_used = -5;
1559 if (cpi->oxcf.cpu_used > 5)
1560 cpi->oxcf.cpu_used = 5;
1563 case MODE_SECONDPASS_BEST:
1565 cpi->compressor_speed = 0;
1570 cpi->auto_worst_q = 1;
1572 cpi->oxcf.worst_allowed_q = q_trans[oxcf->worst_allowed_q];
1573 cpi->oxcf.best_allowed_q = q_trans[oxcf->best_allowed_q];
1574 cpi->oxcf.cq_level = q_trans[cpi->oxcf.cq_level];
1576 if (oxcf->fixed_q >= 0)
1578 if (oxcf->worst_allowed_q < 0)
1579 cpi->oxcf.fixed_q = q_trans[0];
1581 cpi->oxcf.fixed_q = q_trans[oxcf->worst_allowed_q];
1583 if (oxcf->alt_q < 0)
1584 cpi->oxcf.alt_q = q_trans[0];
1586 cpi->oxcf.alt_q = q_trans[oxcf->alt_q];
1588 if (oxcf->key_q < 0)
1589 cpi->oxcf.key_q = q_trans[0];
1591 cpi->oxcf.key_q = q_trans[oxcf->key_q];
1593 if (oxcf->gold_q < 0)
1594 cpi->oxcf.gold_q = q_trans[0];
1596 cpi->oxcf.gold_q = q_trans[oxcf->gold_q];
1600 cpi->baseline_gf_interval =
1601 cpi->oxcf.alt_freq ? cpi->oxcf.alt_freq : DEFAULT_GF_INTERVAL;
1603 cpi->ref_frame_flags = VP8_ALT_FLAG | VP8_GOLD_FLAG | VP8_LAST_FLAG;
1605 //cpi->use_golden_frame_only = 0;
1606 //cpi->use_last_frame_only = 0;
1607 cm->refresh_golden_frame = 0;
1608 cm->refresh_last_frame = 1;
1609 cm->refresh_entropy_probs = 1;
1611 if (cpi->oxcf.token_partitions >= 0 && cpi->oxcf.token_partitions <= 3)
1612 cm->multi_token_partition =
1613 (TOKEN_PARTITION) cpi->oxcf.token_partitions;
1615 setup_features(cpi);
1620 for (i = 0; i < MAX_MB_SEGMENTS; i++)
1621 cpi->segment_encode_breakout[i] = cpi->oxcf.encode_breakout;
1624 // At the moment the first order values may not be > MAXQ
1625 if (cpi->oxcf.fixed_q > MAXQ)
1626 cpi->oxcf.fixed_q = MAXQ;
1628 // local file playback mode == really big buffer
1629 if (cpi->oxcf.end_usage == USAGE_LOCAL_FILE_PLAYBACK)
1631 cpi->oxcf.starting_buffer_level = 60000;
1632 cpi->oxcf.optimal_buffer_level = 60000;
1633 cpi->oxcf.maximum_buffer_size = 240000;
1636 // Convert target bandwidth from Kbit/s to Bit/s
1637 cpi->oxcf.target_bandwidth *= 1000;
1639 cpi->oxcf.starting_buffer_level =
1640 rescale(cpi->oxcf.starting_buffer_level,
1641 cpi->oxcf.target_bandwidth, 1000);
1643 // Set or reset optimal and maximum buffer levels.
1644 if (cpi->oxcf.optimal_buffer_level == 0)
1645 cpi->oxcf.optimal_buffer_level = cpi->oxcf.target_bandwidth / 8;
1647 cpi->oxcf.optimal_buffer_level =
1648 rescale(cpi->oxcf.optimal_buffer_level,
1649 cpi->oxcf.target_bandwidth, 1000);
1651 if (cpi->oxcf.maximum_buffer_size == 0)
1652 cpi->oxcf.maximum_buffer_size = cpi->oxcf.target_bandwidth / 8;
1654 cpi->oxcf.maximum_buffer_size =
1655 rescale(cpi->oxcf.maximum_buffer_size,
1656 cpi->oxcf.target_bandwidth, 1000);
1658 // Set up frame rate and related parameters rate control values.
1659 vp8_new_frame_rate(cpi, cpi->oxcf.frame_rate);
1661 // Set absolute upper and lower quality limits
1662 cpi->worst_quality = cpi->oxcf.worst_allowed_q;
1663 cpi->best_quality = cpi->oxcf.best_allowed_q;
1665 // active values should only be modified if out of new range
1666 if (cpi->active_worst_quality > cpi->oxcf.worst_allowed_q)
1668 cpi->active_worst_quality = cpi->oxcf.worst_allowed_q;
1671 else if (cpi->active_worst_quality < cpi->oxcf.best_allowed_q)
1673 cpi->active_worst_quality = cpi->oxcf.best_allowed_q;
1675 if (cpi->active_best_quality < cpi->oxcf.best_allowed_q)
1677 cpi->active_best_quality = cpi->oxcf.best_allowed_q;
1680 else if (cpi->active_best_quality > cpi->oxcf.worst_allowed_q)
1682 cpi->active_best_quality = cpi->oxcf.worst_allowed_q;
1685 cpi->buffered_mode = (cpi->oxcf.optimal_buffer_level > 0) ? TRUE : FALSE;
1687 cpi->cq_target_quality = cpi->oxcf.cq_level;
1689 // Only allow dropped frames in buffered mode
1690 cpi->drop_frames_allowed = cpi->oxcf.allow_df && cpi->buffered_mode;
1692 if (!cm->use_bilinear_mc_filter)
1693 cm->mcomp_filter_type = SIXTAP;
1695 cm->mcomp_filter_type = BILINEAR;
1697 cpi->target_bandwidth = cpi->oxcf.target_bandwidth;
1699 cm->Width = cpi->oxcf.Width ;
1700 cm->Height = cpi->oxcf.Height ;
1702 cm->horiz_scale = cpi->horiz_scale;
1703 cm->vert_scale = cpi->vert_scale ;
1705 // VP8 sharpness level mapping 0-7 (vs 0-10 in general VPx dialogs)
1706 if (cpi->oxcf.Sharpness > 7)
1707 cpi->oxcf.Sharpness = 7;
1709 cm->sharpness_level = cpi->oxcf.Sharpness;
1711 if (cm->horiz_scale != NORMAL || cm->vert_scale != NORMAL)
1713 int UNINITIALIZED_IS_SAFE(hr), UNINITIALIZED_IS_SAFE(hs);
1714 int UNINITIALIZED_IS_SAFE(vr), UNINITIALIZED_IS_SAFE(vs);
1716 Scale2Ratio(cm->horiz_scale, &hr, &hs);
1717 Scale2Ratio(cm->vert_scale, &vr, &vs);
1719 // always go to the next whole number
1720 cm->Width = (hs - 1 + cpi->oxcf.Width * hr) / hs;
1721 cm->Height = (vs - 1 + cpi->oxcf.Height * vr) / vs;
1724 if (((cm->Width + 15) & 0xfffffff0) !=
1725 cm->yv12_fb[cm->lst_fb_idx].y_width ||
1726 ((cm->Height + 15) & 0xfffffff0) !=
1727 cm->yv12_fb[cm->lst_fb_idx].y_height ||
1728 cm->yv12_fb[cm->lst_fb_idx].y_width == 0)
1730 alloc_raw_frame_buffers(cpi);
1731 vp8_alloc_compressor_data(cpi);
1734 if (cpi->oxcf.fixed_q >= 0)
1736 cpi->last_q[0] = cpi->oxcf.fixed_q;
1737 cpi->last_q[1] = cpi->oxcf.fixed_q;
1740 cpi->Speed = cpi->oxcf.cpu_used;
1742 // force to allowlag to 0 if lag_in_frames is 0;
1743 if (cpi->oxcf.lag_in_frames == 0)
1745 cpi->oxcf.allow_lag = 0;
1747 // Limit on lag buffers as these are not currently dynamically allocated
1748 else if (cpi->oxcf.lag_in_frames > MAX_LAG_BUFFERS)
1749 cpi->oxcf.lag_in_frames = MAX_LAG_BUFFERS;
1752 cpi->alt_ref_source = NULL;
1753 cpi->is_src_frame_alt_ref = 0;
1757 // Experimental RD Code
1758 cpi->frame_distortion = 0;
1759 cpi->last_frame_distortion = 0;
1764 #define M_LOG2_E 0.693147180559945309417
1765 #define log2f(x) (log (x) / (float) M_LOG2_E)
1766 static void cal_mvsadcosts(int *mvsadcost[2])
1770 mvsadcost [0] [0] = 300;
1771 mvsadcost [1] [0] = 300;
1775 double z = 256 * (2 * (log2f(8 * i) + .6));
1776 mvsadcost [0][i] = (int) z;
1777 mvsadcost [1][i] = (int) z;
1778 mvsadcost [0][-i] = (int) z;
1779 mvsadcost [1][-i] = (int) z;
1781 while (++i <= mvfp_max);
1784 VP8_PTR vp8_create_compressor(VP8_CONFIG *oxcf)
1796 cpi = ctx.cpi = vpx_memalign(32, sizeof(VP8_COMP));
1797 // Check that the CPI instance is valid
1803 vpx_memset(cpi, 0, sizeof(VP8_COMP));
1805 if (setjmp(cm->error.jmp))
1807 VP8_PTR ptr = ctx.ptr;
1809 ctx.cpi->common.error.setjmp = 0;
1810 vp8_remove_compressor(&ptr);
1814 cpi->common.error.setjmp = 1;
1816 CHECK_MEM_ERROR(cpi->mb.ss, vpx_calloc(sizeof(search_site), (MAX_MVSEARCH_STEPS * 8) + 1));
1818 vp8_create_common(&cpi->common);
1819 vp8_cmachine_specific_config(cpi);
1821 init_config((VP8_PTR)cpi, oxcf);
1823 memcpy(cpi->base_skip_false_prob, vp8cx_base_skip_false_prob, sizeof(vp8cx_base_skip_false_prob));
1824 cpi->common.current_video_frame = 0;
1825 cpi->kf_overspend_bits = 0;
1826 cpi->kf_bitrate_adjustment = 0;
1827 cpi->frames_till_gf_update_due = 0;
1828 cpi->gf_overspend_bits = 0;
1829 cpi->non_gf_bitrate_adjustment = 0;
1830 cpi->prob_last_coded = 128;
1831 cpi->prob_gf_coded = 128;
1832 cpi->prob_intra_coded = 63;
1834 // Prime the recent reference frame useage counters.
1835 // Hereafter they will be maintained as a sort of moving average
1836 cpi->recent_ref_frame_usage[INTRA_FRAME] = 1;
1837 cpi->recent_ref_frame_usage[LAST_FRAME] = 1;
1838 cpi->recent_ref_frame_usage[GOLDEN_FRAME] = 1;
1839 cpi->recent_ref_frame_usage[ALTREF_FRAME] = 1;
1841 // Set reference frame sign bias for ALTREF frame to 1 (for now)
1842 cpi->common.ref_frame_sign_bias[ALTREF_FRAME] = 1;
1844 cpi->twopass.gf_decay_rate = 0;
1845 cpi->baseline_gf_interval = DEFAULT_GF_INTERVAL;
1847 cpi->gold_is_last = 0 ;
1848 cpi->alt_is_last = 0 ;
1849 cpi->gold_is_alt = 0 ;
1851 // allocate memory for storing last frame's MVs for MV prediction.
1852 CHECK_MEM_ERROR(cpi->lfmv, vpx_calloc((cpi->common.mb_rows+2) * (cpi->common.mb_cols+2), sizeof(int_mv)));
1853 CHECK_MEM_ERROR(cpi->lf_ref_frame_sign_bias, vpx_calloc((cpi->common.mb_rows+2) * (cpi->common.mb_cols+2), sizeof(int)));
1854 CHECK_MEM_ERROR(cpi->lf_ref_frame, vpx_calloc((cpi->common.mb_rows+2) * (cpi->common.mb_cols+2), sizeof(int)));
1856 // Create the encoder segmentation map and set all entries to 0
1857 CHECK_MEM_ERROR(cpi->segmentation_map, vpx_calloc(cpi->common.mb_rows * cpi->common.mb_cols, 1));
1858 CHECK_MEM_ERROR(cpi->active_map, vpx_calloc(cpi->common.mb_rows * cpi->common.mb_cols, 1));
1859 vpx_memset(cpi->active_map , 1, (cpi->common.mb_rows * cpi->common.mb_cols));
1860 cpi->active_map_enabled = 0;
1863 // Experimental code for lagged and one pass
1864 // Initialise one_pass GF frames stats
1865 // Update stats used for GF selection
1868 cpi->one_pass_frame_index = 0;
1870 for (i = 0; i < MAX_LAG_BUFFERS; i++)
1872 cpi->one_pass_frame_stats[i].frames_so_far = 0;
1873 cpi->one_pass_frame_stats[i].frame_intra_error = 0.0;
1874 cpi->one_pass_frame_stats[i].frame_coded_error = 0.0;
1875 cpi->one_pass_frame_stats[i].frame_pcnt_inter = 0.0;
1876 cpi->one_pass_frame_stats[i].frame_pcnt_motion = 0.0;
1877 cpi->one_pass_frame_stats[i].frame_mvr = 0.0;
1878 cpi->one_pass_frame_stats[i].frame_mvr_abs = 0.0;
1879 cpi->one_pass_frame_stats[i].frame_mvc = 0.0;
1880 cpi->one_pass_frame_stats[i].frame_mvc_abs = 0.0;
1885 // Should we use the cyclic refresh method.
1886 // Currently this is tied to error resilliant mode
1887 cpi->cyclic_refresh_mode_enabled = cpi->oxcf.error_resilient_mode;
1888 cpi->cyclic_refresh_mode_max_mbs_perframe = (cpi->common.mb_rows * cpi->common.mb_cols) / 40;
1889 cpi->cyclic_refresh_mode_index = 0;
1890 cpi->cyclic_refresh_q = 32;
1892 if (cpi->cyclic_refresh_mode_enabled)
1894 CHECK_MEM_ERROR(cpi->cyclic_refresh_map, vpx_calloc((cpi->common.mb_rows * cpi->common.mb_cols), 1));
1897 cpi->cyclic_refresh_map = (signed char *) NULL;
1899 // Test function for segmentation
1900 //segmentation_test_function((VP8_PTR) cpi);
1902 #ifdef ENTROPY_STATS
1903 init_context_counters();
1906 /*Initialize the feed-forward activity masking.*/
1907 cpi->activity_avg = 90<<12;
1909 cpi->frames_since_key = 8; // Give a sensible default for the first frame.
1910 cpi->key_frame_frequency = cpi->oxcf.key_freq;
1911 cpi->this_key_frame_forced = FALSE;
1912 cpi->next_key_frame_forced = FALSE;
1914 cpi->source_alt_ref_pending = FALSE;
1915 cpi->source_alt_ref_active = FALSE;
1916 cpi->common.refresh_alt_ref_frame = 0;
1918 cpi->b_calculate_psnr = CONFIG_INTERNAL_STATS;
1919 #if CONFIG_INTERNAL_STATS
1920 cpi->b_calculate_ssimg = 0;
1925 if (cpi->b_calculate_psnr)
1927 cpi->total_sq_error = 0.0;
1928 cpi->total_sq_error2 = 0.0;
1933 cpi->totalp_y = 0.0;
1934 cpi->totalp_u = 0.0;
1935 cpi->totalp_v = 0.0;
1937 cpi->tot_recode_hits = 0;
1938 cpi->summed_quality = 0;
1939 cpi->summed_weights = 0;
1942 if (cpi->b_calculate_ssimg)
1944 cpi->total_ssimg_y = 0;
1945 cpi->total_ssimg_u = 0;
1946 cpi->total_ssimg_v = 0;
1947 cpi->total_ssimg_all = 0;
1951 #define LLONG_MAX 9223372036854775807LL
1953 cpi->first_time_stamp_ever = LLONG_MAX;
1957 cpi->frames_till_gf_update_due = 0;
1958 cpi->key_frame_count = 1;
1960 cpi->ni_av_qi = cpi->oxcf.worst_allowed_q;
1963 cpi->total_byte_count = 0;
1965 cpi->drop_frame = 0;
1966 cpi->drop_count = 0;
1967 cpi->max_drop_count = 0;
1968 cpi->max_consec_dropped_frames = 4;
1970 cpi->rate_correction_factor = 1.0;
1971 cpi->key_frame_rate_correction_factor = 1.0;
1972 cpi->gf_rate_correction_factor = 1.0;
1973 cpi->twopass.est_max_qcorrection_factor = 1.0;
1975 cpi->mb.mvcost[0] = &cpi->mb.mvcosts[0][mv_max+1];
1976 cpi->mb.mvcost[1] = &cpi->mb.mvcosts[1][mv_max+1];
1977 cpi->mb.mvsadcost[0] = &cpi->mb.mvsadcosts[0][mvfp_max+1];
1978 cpi->mb.mvsadcost[1] = &cpi->mb.mvsadcosts[1][mvfp_max+1];
1980 cal_mvsadcosts(cpi->mb.mvsadcost);
1982 for (i = 0; i < KEY_FRAME_CONTEXT; i++)
1984 cpi->prior_key_frame_distance[i] = (int)cpi->output_frame_rate;
1987 #ifdef OUTPUT_YUV_SRC
1988 yuv_file = fopen("bd.yuv", "ab");
1992 framepsnr = fopen("framepsnr.stt", "a");
1993 kf_list = fopen("kf_list.stt", "w");
1996 cpi->output_pkt_list = oxcf->output_pkt_list;
1998 #if !(CONFIG_REALTIME_ONLY)
2002 vp8_init_first_pass(cpi);
2004 else if (cpi->pass == 2)
2006 size_t packet_sz = sizeof(FIRSTPASS_STATS);
2007 int packets = oxcf->two_pass_stats_in.sz / packet_sz;
2009 cpi->twopass.stats_in = oxcf->two_pass_stats_in.buf;
2010 cpi->twopass.stats_in_end = (void*)((char *)cpi->twopass.stats_in
2011 + (packets - 1) * packet_sz);
2012 vp8_init_second_pass(cpi);
2017 if (cpi->compressor_speed == 2)
2019 cpi->cpu_freq = 0; //vp8_get_processor_freq();
2020 cpi->avg_encode_time = 0;
2021 cpi->avg_pick_mode_time = 0;
2024 vp8_set_speed_features(cpi);
2026 // Set starting values of RD threshold multipliers (128 = *1)
2027 for (i = 0; i < MAX_MODES; i++)
2029 cpi->rd_thresh_mult[i] = 128;
2032 #ifdef ENTROPY_STATS
2033 init_mv_ref_counts();
2036 #if CONFIG_MULTITHREAD
2037 vp8cx_create_encoder_threads(cpi);
2040 cpi->fn_ptr[BLOCK_16X16].sdf = VARIANCE_INVOKE(&cpi->rtcd.variance, sad16x16);
2041 cpi->fn_ptr[BLOCK_16X16].vf = VARIANCE_INVOKE(&cpi->rtcd.variance, var16x16);
2042 cpi->fn_ptr[BLOCK_16X16].svf = VARIANCE_INVOKE(&cpi->rtcd.variance, subpixvar16x16);
2043 cpi->fn_ptr[BLOCK_16X16].svf_halfpix_h = VARIANCE_INVOKE(&cpi->rtcd.variance, halfpixvar16x16_h);
2044 cpi->fn_ptr[BLOCK_16X16].svf_halfpix_v = VARIANCE_INVOKE(&cpi->rtcd.variance, halfpixvar16x16_v);
2045 cpi->fn_ptr[BLOCK_16X16].svf_halfpix_hv = VARIANCE_INVOKE(&cpi->rtcd.variance, halfpixvar16x16_hv);
2046 cpi->fn_ptr[BLOCK_16X16].sdx3f = VARIANCE_INVOKE(&cpi->rtcd.variance, sad16x16x3);
2047 cpi->fn_ptr[BLOCK_16X16].sdx8f = VARIANCE_INVOKE(&cpi->rtcd.variance, sad16x16x8);
2048 cpi->fn_ptr[BLOCK_16X16].sdx4df = VARIANCE_INVOKE(&cpi->rtcd.variance, sad16x16x4d);
2050 cpi->fn_ptr[BLOCK_16X8].sdf = VARIANCE_INVOKE(&cpi->rtcd.variance, sad16x8);
2051 cpi->fn_ptr[BLOCK_16X8].vf = VARIANCE_INVOKE(&cpi->rtcd.variance, var16x8);
2052 cpi->fn_ptr[BLOCK_16X8].svf = VARIANCE_INVOKE(&cpi->rtcd.variance, subpixvar16x8);
2053 cpi->fn_ptr[BLOCK_16X8].svf_halfpix_h = NULL;
2054 cpi->fn_ptr[BLOCK_16X8].svf_halfpix_v = NULL;
2055 cpi->fn_ptr[BLOCK_16X8].svf_halfpix_hv = NULL;
2056 cpi->fn_ptr[BLOCK_16X8].sdx3f = VARIANCE_INVOKE(&cpi->rtcd.variance, sad16x8x3);
2057 cpi->fn_ptr[BLOCK_16X8].sdx8f = VARIANCE_INVOKE(&cpi->rtcd.variance, sad16x8x8);
2058 cpi->fn_ptr[BLOCK_16X8].sdx4df = VARIANCE_INVOKE(&cpi->rtcd.variance, sad16x8x4d);
2060 cpi->fn_ptr[BLOCK_8X16].sdf = VARIANCE_INVOKE(&cpi->rtcd.variance, sad8x16);
2061 cpi->fn_ptr[BLOCK_8X16].vf = VARIANCE_INVOKE(&cpi->rtcd.variance, var8x16);
2062 cpi->fn_ptr[BLOCK_8X16].svf = VARIANCE_INVOKE(&cpi->rtcd.variance, subpixvar8x16);
2063 cpi->fn_ptr[BLOCK_8X16].svf_halfpix_h = NULL;
2064 cpi->fn_ptr[BLOCK_8X16].svf_halfpix_v = NULL;
2065 cpi->fn_ptr[BLOCK_8X16].svf_halfpix_hv = NULL;
2066 cpi->fn_ptr[BLOCK_8X16].sdx3f = VARIANCE_INVOKE(&cpi->rtcd.variance, sad8x16x3);
2067 cpi->fn_ptr[BLOCK_8X16].sdx8f = VARIANCE_INVOKE(&cpi->rtcd.variance, sad8x16x8);
2068 cpi->fn_ptr[BLOCK_8X16].sdx4df = VARIANCE_INVOKE(&cpi->rtcd.variance, sad8x16x4d);
2070 cpi->fn_ptr[BLOCK_8X8].sdf = VARIANCE_INVOKE(&cpi->rtcd.variance, sad8x8);
2071 cpi->fn_ptr[BLOCK_8X8].vf = VARIANCE_INVOKE(&cpi->rtcd.variance, var8x8);
2072 cpi->fn_ptr[BLOCK_8X8].svf = VARIANCE_INVOKE(&cpi->rtcd.variance, subpixvar8x8);
2073 cpi->fn_ptr[BLOCK_8X8].svf_halfpix_h = NULL;
2074 cpi->fn_ptr[BLOCK_8X8].svf_halfpix_v = NULL;
2075 cpi->fn_ptr[BLOCK_8X8].svf_halfpix_hv = NULL;
2076 cpi->fn_ptr[BLOCK_8X8].sdx3f = VARIANCE_INVOKE(&cpi->rtcd.variance, sad8x8x3);
2077 cpi->fn_ptr[BLOCK_8X8].sdx8f = VARIANCE_INVOKE(&cpi->rtcd.variance, sad8x8x8);
2078 cpi->fn_ptr[BLOCK_8X8].sdx4df = VARIANCE_INVOKE(&cpi->rtcd.variance, sad8x8x4d);
2080 cpi->fn_ptr[BLOCK_4X4].sdf = VARIANCE_INVOKE(&cpi->rtcd.variance, sad4x4);
2081 cpi->fn_ptr[BLOCK_4X4].vf = VARIANCE_INVOKE(&cpi->rtcd.variance, var4x4);
2082 cpi->fn_ptr[BLOCK_4X4].svf = VARIANCE_INVOKE(&cpi->rtcd.variance, subpixvar4x4);
2083 cpi->fn_ptr[BLOCK_4X4].svf_halfpix_h = NULL;
2084 cpi->fn_ptr[BLOCK_4X4].svf_halfpix_v = NULL;
2085 cpi->fn_ptr[BLOCK_4X4].svf_halfpix_hv = NULL;
2086 cpi->fn_ptr[BLOCK_4X4].sdx3f = VARIANCE_INVOKE(&cpi->rtcd.variance, sad4x4x3);
2087 cpi->fn_ptr[BLOCK_4X4].sdx8f = VARIANCE_INVOKE(&cpi->rtcd.variance, sad4x4x8);
2088 cpi->fn_ptr[BLOCK_4X4].sdx4df = VARIANCE_INVOKE(&cpi->rtcd.variance, sad4x4x4d);
2090 cpi->full_search_sad = SEARCH_INVOKE(&cpi->rtcd.search, full_search);
2091 cpi->diamond_search_sad = SEARCH_INVOKE(&cpi->rtcd.search, diamond_search);
2092 cpi->refining_search_sad = SEARCH_INVOKE(&cpi->rtcd.search, refining_search);
2094 // make sure frame 1 is okay
2095 cpi->error_bins[0] = cpi->common.MBs;
2097 //vp8cx_init_quantizer() is first called here. Add check in vp8cx_frame_init_quantizer() so that vp8cx_init_quantizer is only called later
2098 //when needed. This will avoid unnecessary calls of vp8cx_init_quantizer() for every frame.
2099 vp8cx_init_quantizer(cpi);
2101 vp8_init_loop_filter(cm);
2102 cm->last_frame_type = KEY_FRAME;
2103 cm->last_filter_type = cm->filter_type;
2104 cm->last_sharpness_level = cm->sharpness_level;
2106 cpi->common.error.setjmp = 0;
2107 return (VP8_PTR) cpi;
2112 void vp8_remove_compressor(VP8_PTR *ptr)
2114 VP8_COMP *cpi = (VP8_COMP *)(*ptr);
2119 if (cpi && (cpi->common.current_video_frame > 0))
2121 #if !(CONFIG_REALTIME_ONLY)
2125 vp8_end_second_pass(cpi);
2130 #ifdef ENTROPY_STATS
2131 print_context_counters();
2132 print_tree_update_probs();
2133 print_mode_context();
2136 #if CONFIG_INTERNAL_STATS
2140 FILE *f = fopen("opsnr.stt", "a");
2141 double time_encoded = (cpi->last_end_time_stamp_seen
2142 - cpi->first_time_stamp_ever) / 10000000.000;
2143 double total_encode_time = (cpi->time_receive_data + cpi->time_compress_data) / 1000.000;
2144 double dr = (double)cpi->bytes * (double) 8 / (double)1000 / time_encoded;
2146 if (cpi->b_calculate_psnr)
2148 YV12_BUFFER_CONFIG *lst_yv12 = &cpi->common.yv12_fb[cpi->common.lst_fb_idx];
2149 double samples = 3.0 / 2 * cpi->count * lst_yv12->y_width * lst_yv12->y_height;
2150 double total_psnr = vp8_mse2psnr(samples, 255.0, cpi->total_sq_error);
2151 double total_psnr2 = vp8_mse2psnr(samples, 255.0, cpi->total_sq_error2);
2152 double total_ssim = 100 * pow(cpi->summed_quality / cpi->summed_weights, 8.0);
2154 fprintf(f, "Bitrate\tAVGPsnr\tGLBPsnr\tAVPsnrP\tGLPsnrP\tVPXSSIM\t Time(us)\n");
2155 fprintf(f, "%7.3f\t%7.3f\t%7.3f\t%7.3f\t%7.3f\t%7.3f\t%8.0f\n",
2156 dr, cpi->total / cpi->count, total_psnr, cpi->totalp / cpi->count, total_psnr2, total_ssim,
2160 if (cpi->b_calculate_ssimg)
2162 fprintf(f, "BitRate\tSSIM_Y\tSSIM_U\tSSIM_V\tSSIM_A\t Time(us)\n");
2163 fprintf(f, "%7.3f\t%6.4f\t%6.4f\t%6.4f\t%6.4f\t%8.0f\n", dr,
2164 cpi->total_ssimg_y / cpi->count, cpi->total_ssimg_u / cpi->count,
2165 cpi->total_ssimg_v / cpi->count, cpi->total_ssimg_all / cpi->count, total_encode_time);
2170 f = fopen("qskip.stt", "a");
2171 fprintf(f, "minq:%d -maxq:%d skipture:skipfalse = %d:%d\n", cpi->oxcf.best_allowed_q, cpi->oxcf.worst_allowed_q, skiptruecount, skipfalsecount);
2182 if (cpi->compressor_speed == 2)
2185 FILE *f = fopen("cxspeed.stt", "a");
2186 cnt_pm /= cpi->common.MBs;
2188 for (i = 0; i < 16; i++)
2189 fprintf(f, "%5d", frames_at_speed[i]);
2192 //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);
2201 extern int count_mb_seg[4];
2202 FILE *f = fopen("modes.stt", "a");
2203 double dr = (double)cpi->oxcf.frame_rate * (double)bytes * (double)8 / (double)count / (double)1000 ;
2204 fprintf(f, "intra_mode in Intra Frames:\n");
2205 fprintf(f, "Y: %8d, %8d, %8d, %8d, %8d\n", y_modes[0], y_modes[1], y_modes[2], y_modes[3], y_modes[4]);
2206 fprintf(f, "UV:%8d, %8d, %8d, %8d\n", uv_modes[0], uv_modes[1], uv_modes[2], uv_modes[3]);
2211 for (i = 0; i < 10; i++)
2212 fprintf(f, "%8d, ", b_modes[i]);
2218 fprintf(f, "Modes in Inter Frames:\n");
2219 fprintf(f, "Y: %8d, %8d, %8d, %8d, %8d, %8d, %8d, %8d, %8d, %8d\n",
2220 inter_y_modes[0], inter_y_modes[1], inter_y_modes[2], inter_y_modes[3], inter_y_modes[4],
2221 inter_y_modes[5], inter_y_modes[6], inter_y_modes[7], inter_y_modes[8], inter_y_modes[9]);
2222 fprintf(f, "UV:%8d, %8d, %8d, %8d\n", inter_uv_modes[0], inter_uv_modes[1], inter_uv_modes[2], inter_uv_modes[3]);
2227 for (i = 0; i < 15; i++)
2228 fprintf(f, "%8d, ", inter_b_modes[i]);
2233 fprintf(f, "P:%8d, %8d, %8d, %8d\n", count_mb_seg[0], count_mb_seg[1], count_mb_seg[2], count_mb_seg[3]);
2234 fprintf(f, "PB:%8d, %8d, %8d, %8d\n", inter_b_modes[LEFT4X4], inter_b_modes[ABOVE4X4], inter_b_modes[ZERO4X4], inter_b_modes[NEW4X4]);
2242 #ifdef ENTROPY_STATS
2245 FILE *fmode = fopen("modecontext.c", "w");
2247 fprintf(fmode, "\n#include \"entropymode.h\"\n\n");
2248 fprintf(fmode, "const unsigned int vp8_kf_default_bmode_counts ");
2249 fprintf(fmode, "[VP8_BINTRAMODES] [VP8_BINTRAMODES] [VP8_BINTRAMODES] =\n{\n");
2251 for (i = 0; i < 10; i++)
2254 fprintf(fmode, " { //Above Mode : %d\n", i);
2256 for (j = 0; j < 10; j++)
2259 fprintf(fmode, " {");
2261 for (k = 0; k < 10; k++)
2263 if (!intra_mode_stats[i][j][k])
2264 fprintf(fmode, " %5d, ", 1);
2266 fprintf(fmode, " %5d, ", intra_mode_stats[i][j][k]);
2269 fprintf(fmode, "}, // left_mode %d\n", j);
2273 fprintf(fmode, " },\n");
2277 fprintf(fmode, "};\n");
2283 #if defined(SECTIONBITS_OUTPUT)
2288 FILE *f = fopen("tokenbits.stt", "a");
2290 for (i = 0; i < 28; i++)
2291 fprintf(f, "%8d", (int)(Sectionbits[i] / 256));
2301 printf("\n_pick_loop_filter_level:%d\n", cpi->time_pick_lpf / 1000);
2302 printf("\n_frames recive_data encod_mb_row compress_frame Total\n");
2303 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);
2309 #if CONFIG_MULTITHREAD
2310 vp8cx_remove_encoder_threads(cpi);
2313 dealloc_compressor_data(cpi);
2314 vpx_free(cpi->mb.ss);
2316 vpx_free(cpi->cyclic_refresh_map);
2318 vp8_remove_common(&cpi->common);
2322 #ifdef OUTPUT_YUV_SRC
2342 static uint64_t calc_plane_error(unsigned char *orig, int orig_stride,
2343 unsigned char *recon, int recon_stride,
2344 unsigned int cols, unsigned int rows,
2345 vp8_variance_rtcd_vtable_t *rtcd)
2347 unsigned int row, col;
2348 uint64_t total_sse = 0;
2351 for (row = 0; row + 16 <= rows; row += 16)
2353 for (col = 0; col + 16 <= cols; col += 16)
2357 VARIANCE_INVOKE(rtcd, mse16x16)(orig + col, orig_stride,
2358 recon + col, recon_stride,
2363 /* Handle odd-sized width */
2366 unsigned int border_row, border_col;
2367 unsigned char *border_orig = orig;
2368 unsigned char *border_recon = recon;
2370 for (border_row = 0; border_row < 16; border_row++)
2372 for (border_col = col; border_col < cols; border_col++)
2374 diff = border_orig[border_col] - border_recon[border_col];
2375 total_sse += diff * diff;
2378 border_orig += orig_stride;
2379 border_recon += recon_stride;
2383 orig += orig_stride * 16;
2384 recon += recon_stride * 16;
2387 /* Handle odd-sized height */
2388 for (; row < rows; row++)
2390 for (col = 0; col < cols; col++)
2392 diff = orig[col] - recon[col];
2393 total_sse += diff * diff;
2396 orig += orig_stride;
2397 recon += recon_stride;
2404 static void generate_psnr_packet(VP8_COMP *cpi)
2406 YV12_BUFFER_CONFIG *orig = cpi->Source;
2407 YV12_BUFFER_CONFIG *recon = cpi->common.frame_to_show;
2408 struct vpx_codec_cx_pkt pkt;
2411 unsigned int width = cpi->common.Width;
2412 unsigned int height = cpi->common.Height;
2414 pkt.kind = VPX_CODEC_PSNR_PKT;
2415 sse = calc_plane_error(orig->y_buffer, orig->y_stride,
2416 recon->y_buffer, recon->y_stride,
2418 IF_RTCD(&cpi->rtcd.variance));
2419 pkt.data.psnr.sse[0] = sse;
2420 pkt.data.psnr.sse[1] = sse;
2421 pkt.data.psnr.samples[0] = width * height;
2422 pkt.data.psnr.samples[1] = width * height;
2424 width = (width + 1) / 2;
2425 height = (height + 1) / 2;
2427 sse = calc_plane_error(orig->u_buffer, orig->uv_stride,
2428 recon->u_buffer, recon->uv_stride,
2430 IF_RTCD(&cpi->rtcd.variance));
2431 pkt.data.psnr.sse[0] += sse;
2432 pkt.data.psnr.sse[2] = sse;
2433 pkt.data.psnr.samples[0] += width * height;
2434 pkt.data.psnr.samples[2] = width * height;
2436 sse = calc_plane_error(orig->v_buffer, orig->uv_stride,
2437 recon->v_buffer, recon->uv_stride,
2439 IF_RTCD(&cpi->rtcd.variance));
2440 pkt.data.psnr.sse[0] += sse;
2441 pkt.data.psnr.sse[3] = sse;
2442 pkt.data.psnr.samples[0] += width * height;
2443 pkt.data.psnr.samples[3] = width * height;
2445 for (i = 0; i < 4; i++)
2446 pkt.data.psnr.psnr[i] = vp8_mse2psnr(pkt.data.psnr.samples[i], 255.0,
2447 pkt.data.psnr.sse[i]);
2449 vpx_codec_pkt_list_add(cpi->output_pkt_list, &pkt);
2453 int vp8_use_as_reference(VP8_PTR ptr, int ref_frame_flags)
2455 VP8_COMP *cpi = (VP8_COMP *)(ptr);
2457 if (ref_frame_flags > 7)
2460 cpi->ref_frame_flags = ref_frame_flags;
2463 int vp8_update_reference(VP8_PTR ptr, int ref_frame_flags)
2465 VP8_COMP *cpi = (VP8_COMP *)(ptr);
2467 if (ref_frame_flags > 7)
2470 cpi->common.refresh_golden_frame = 0;
2471 cpi->common.refresh_alt_ref_frame = 0;
2472 cpi->common.refresh_last_frame = 0;
2474 if (ref_frame_flags & VP8_LAST_FLAG)
2475 cpi->common.refresh_last_frame = 1;
2477 if (ref_frame_flags & VP8_GOLD_FLAG)
2478 cpi->common.refresh_golden_frame = 1;
2480 if (ref_frame_flags & VP8_ALT_FLAG)
2481 cpi->common.refresh_alt_ref_frame = 1;
2486 int vp8_get_reference(VP8_PTR ptr, VP8_REFFRAME ref_frame_flag, YV12_BUFFER_CONFIG *sd)
2488 VP8_COMP *cpi = (VP8_COMP *)(ptr);
2489 VP8_COMMON *cm = &cpi->common;
2492 if (ref_frame_flag == VP8_LAST_FLAG)
2493 ref_fb_idx = cm->lst_fb_idx;
2494 else if (ref_frame_flag == VP8_GOLD_FLAG)
2495 ref_fb_idx = cm->gld_fb_idx;
2496 else if (ref_frame_flag == VP8_ALT_FLAG)
2497 ref_fb_idx = cm->alt_fb_idx;
2501 vp8_yv12_copy_frame_ptr(&cm->yv12_fb[ref_fb_idx], sd);
2505 int vp8_set_reference(VP8_PTR ptr, VP8_REFFRAME ref_frame_flag, YV12_BUFFER_CONFIG *sd)
2507 VP8_COMP *cpi = (VP8_COMP *)(ptr);
2508 VP8_COMMON *cm = &cpi->common;
2512 if (ref_frame_flag == VP8_LAST_FLAG)
2513 ref_fb_idx = cm->lst_fb_idx;
2514 else if (ref_frame_flag == VP8_GOLD_FLAG)
2515 ref_fb_idx = cm->gld_fb_idx;
2516 else if (ref_frame_flag == VP8_ALT_FLAG)
2517 ref_fb_idx = cm->alt_fb_idx;
2521 vp8_yv12_copy_frame_ptr(sd, &cm->yv12_fb[ref_fb_idx]);
2525 int vp8_update_entropy(VP8_PTR comp, int update)
2527 VP8_COMP *cpi = (VP8_COMP *) comp;
2528 VP8_COMMON *cm = &cpi->common;
2529 cm->refresh_entropy_probs = update;
2536 void vp8_write_yuv_frame(const char *name, YV12_BUFFER_CONFIG *s)
2538 FILE *yuv_file = fopen(name, "ab");
2539 unsigned char *src = s->y_buffer;
2540 int h = s->y_height;
2544 fwrite(src, s->y_width, 1, yuv_file);
2554 fwrite(src, s->uv_width, 1, yuv_file);
2555 src += s->uv_stride;
2564 fwrite(src, s->uv_width, 1, yuv_file);
2565 src += s->uv_stride;
2574 static void scale_and_extend_source(YV12_BUFFER_CONFIG *sd, VP8_COMP *cpi)
2576 VP8_COMMON *cm = &cpi->common;
2578 // are we resizing the image
2579 if (cm->horiz_scale != 0 || cm->vert_scale != 0)
2581 #if CONFIG_SPATIAL_RESAMPLING
2582 int UNINITIALIZED_IS_SAFE(hr), UNINITIALIZED_IS_SAFE(hs);
2583 int UNINITIALIZED_IS_SAFE(vr), UNINITIALIZED_IS_SAFE(vs);
2586 if (cm->vert_scale == 3)
2591 Scale2Ratio(cm->horiz_scale, &hr, &hs);
2592 Scale2Ratio(cm->vert_scale, &vr, &vs);
2594 vp8_scale_frame(sd, &cpi->scaled_source, cm->temp_scale_frame.y_buffer,
2595 tmp_height, hs, hr, vs, vr, 0);
2597 vp8_yv12_extend_frame_borders(&cpi->scaled_source);
2598 cpi->Source = &cpi->scaled_source;
2604 static void resize_key_frame(VP8_COMP *cpi)
2606 #if CONFIG_SPATIAL_RESAMPLING
2607 VP8_COMMON *cm = &cpi->common;
2609 // Do we need to apply resampling for one pass cbr.
2610 // In one pass this is more limited than in two pass cbr
2611 // The test and any change is only made one per key frame sequence
2612 if (cpi->oxcf.allow_spatial_resampling && (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER))
2614 int UNINITIALIZED_IS_SAFE(hr), UNINITIALIZED_IS_SAFE(hs);
2615 int UNINITIALIZED_IS_SAFE(vr), UNINITIALIZED_IS_SAFE(vs);
2616 int new_width, new_height;
2618 // If we are below the resample DOWN watermark then scale down a notch.
2619 if (cpi->buffer_level < (cpi->oxcf.resample_down_water_mark * cpi->oxcf.optimal_buffer_level / 100))
2621 cm->horiz_scale = (cm->horiz_scale < ONETWO) ? cm->horiz_scale + 1 : ONETWO;
2622 cm->vert_scale = (cm->vert_scale < ONETWO) ? cm->vert_scale + 1 : ONETWO;
2624 // Should we now start scaling back up
2625 else if (cpi->buffer_level > (cpi->oxcf.resample_up_water_mark * cpi->oxcf.optimal_buffer_level / 100))
2627 cm->horiz_scale = (cm->horiz_scale > NORMAL) ? cm->horiz_scale - 1 : NORMAL;
2628 cm->vert_scale = (cm->vert_scale > NORMAL) ? cm->vert_scale - 1 : NORMAL;
2631 // Get the new hieght and width
2632 Scale2Ratio(cm->horiz_scale, &hr, &hs);
2633 Scale2Ratio(cm->vert_scale, &vr, &vs);
2634 new_width = ((hs - 1) + (cpi->oxcf.Width * hr)) / hs;
2635 new_height = ((vs - 1) + (cpi->oxcf.Height * vr)) / vs;
2637 // If the image size has changed we need to reallocate the buffers
2638 // and resample the source image
2639 if ((cm->Width != new_width) || (cm->Height != new_height))
2641 cm->Width = new_width;
2642 cm->Height = new_height;
2643 vp8_alloc_compressor_data(cpi);
2644 scale_and_extend_source(cpi->un_scaled_source, cpi);
2652 static void update_alt_ref_frame_stats(VP8_COMP *cpi)
2654 VP8_COMMON *cm = &cpi->common;
2656 // Select an interval before next GF or altref
2657 if (!cpi->auto_gold)
2658 cpi->frames_till_gf_update_due = cpi->goldfreq;
2660 if ((cpi->pass != 2) && cpi->frames_till_gf_update_due)
2662 cpi->current_gf_interval = cpi->frames_till_gf_update_due;
2664 // Set the bits per frame that we should try and recover in subsequent inter frames
2665 // to account for the extra GF spend... note that his does not apply for GF updates
2666 // that occur coincident with a key frame as the extra cost of key frames is dealt
2669 cpi->gf_overspend_bits += cpi->projected_frame_size;
2670 cpi->non_gf_bitrate_adjustment = cpi->gf_overspend_bits / cpi->frames_till_gf_update_due;
2673 // Update data structure that monitors level of reference to last GF
2674 vpx_memset(cpi->gf_active_flags, 1, (cm->mb_rows * cm->mb_cols));
2675 cpi->gf_active_count = cm->mb_rows * cm->mb_cols;
2677 // this frame refreshes means next frames don't unless specified by user
2678 cpi->common.frames_since_golden = 0;
2680 // Clear the alternate reference update pending flag.
2681 cpi->source_alt_ref_pending = FALSE;
2683 // Set the alternate refernce frame active flag
2684 cpi->source_alt_ref_active = TRUE;
2688 static void update_golden_frame_stats(VP8_COMP *cpi)
2690 VP8_COMMON *cm = &cpi->common;
2692 // Update the Golden frame usage counts.
2693 if (cm->refresh_golden_frame)
2695 // Select an interval before next GF
2696 if (!cpi->auto_gold)
2697 cpi->frames_till_gf_update_due = cpi->goldfreq;
2699 if ((cpi->pass != 2) && (cpi->frames_till_gf_update_due > 0))
2701 cpi->current_gf_interval = cpi->frames_till_gf_update_due;
2703 // Set the bits per frame that we should try and recover in subsequent inter frames
2704 // to account for the extra GF spend... note that his does not apply for GF updates
2705 // that occur coincident with a key frame as the extra cost of key frames is dealt
2707 if ((cm->frame_type != KEY_FRAME) && !cpi->source_alt_ref_active)
2709 // Calcluate GF bits to be recovered
2710 // Projected size - av frame bits available for inter frames for clip as a whole
2711 cpi->gf_overspend_bits += (cpi->projected_frame_size - cpi->inter_frame_target);
2714 cpi->non_gf_bitrate_adjustment = cpi->gf_overspend_bits / cpi->frames_till_gf_update_due;
2718 // Update data structure that monitors level of reference to last GF
2719 vpx_memset(cpi->gf_active_flags, 1, (cm->mb_rows * cm->mb_cols));
2720 cpi->gf_active_count = cm->mb_rows * cm->mb_cols;
2722 // this frame refreshes means next frames don't unless specified by user
2723 cm->refresh_golden_frame = 0;
2724 cpi->common.frames_since_golden = 0;
2726 //if ( cm->frame_type == KEY_FRAME )
2728 cpi->recent_ref_frame_usage[INTRA_FRAME] = 1;
2729 cpi->recent_ref_frame_usage[LAST_FRAME] = 1;
2730 cpi->recent_ref_frame_usage[GOLDEN_FRAME] = 1;
2731 cpi->recent_ref_frame_usage[ALTREF_FRAME] = 1;
2735 // // Carry a potrtion of count over to begining of next gf sequence
2736 // cpi->recent_ref_frame_usage[INTRA_FRAME] >>= 5;
2737 // cpi->recent_ref_frame_usage[LAST_FRAME] >>= 5;
2738 // cpi->recent_ref_frame_usage[GOLDEN_FRAME] >>= 5;
2739 // cpi->recent_ref_frame_usage[ALTREF_FRAME] >>= 5;
2742 // ******** Fixed Q test code only ************
2743 // If we are going to use the ALT reference for the next group of frames set a flag to say so.
2744 if (cpi->oxcf.fixed_q >= 0 &&
2745 cpi->oxcf.play_alternate && !cpi->common.refresh_alt_ref_frame)
2747 cpi->source_alt_ref_pending = TRUE;
2748 cpi->frames_till_gf_update_due = cpi->baseline_gf_interval;
2751 if (!cpi->source_alt_ref_pending)
2752 cpi->source_alt_ref_active = FALSE;
2754 // Decrement count down till next gf
2755 if (cpi->frames_till_gf_update_due > 0)
2756 cpi->frames_till_gf_update_due--;
2759 else if (!cpi->common.refresh_alt_ref_frame)
2761 // Decrement count down till next gf
2762 if (cpi->frames_till_gf_update_due > 0)
2763 cpi->frames_till_gf_update_due--;
2765 if (cpi->common.frames_till_alt_ref_frame)
2766 cpi->common.frames_till_alt_ref_frame --;
2768 cpi->common.frames_since_golden ++;
2770 if (cpi->common.frames_since_golden > 1)
2772 cpi->recent_ref_frame_usage[INTRA_FRAME] += cpi->count_mb_ref_frame_usage[INTRA_FRAME];
2773 cpi->recent_ref_frame_usage[LAST_FRAME] += cpi->count_mb_ref_frame_usage[LAST_FRAME];
2774 cpi->recent_ref_frame_usage[GOLDEN_FRAME] += cpi->count_mb_ref_frame_usage[GOLDEN_FRAME];
2775 cpi->recent_ref_frame_usage[ALTREF_FRAME] += cpi->count_mb_ref_frame_usage[ALTREF_FRAME];
2780 // This function updates the reference frame probability estimates that
2781 // will be used during mode selection
2782 static void update_rd_ref_frame_probs(VP8_COMP *cpi)
2784 VP8_COMMON *cm = &cpi->common;
2787 const int *const rfct = cpi->recent_ref_frame_usage;
2788 const int rf_intra = rfct[INTRA_FRAME];
2789 const int rf_inter = rfct[LAST_FRAME] + rfct[GOLDEN_FRAME] + rfct[ALTREF_FRAME];
2791 if (cm->frame_type == KEY_FRAME)
2793 cpi->prob_intra_coded = 255;
2794 cpi->prob_last_coded = 128;
2795 cpi->prob_gf_coded = 128;
2797 else if (!(rf_intra + rf_inter))
2799 // This is a trap in case this function is called with cpi->recent_ref_frame_usage[] blank.
2800 cpi->prob_intra_coded = 63;
2801 cpi->prob_last_coded = 128;
2802 cpi->prob_gf_coded = 128;
2806 cpi->prob_intra_coded = (rf_intra * 255) / (rf_intra + rf_inter);
2808 if (cpi->prob_intra_coded < 1)
2809 cpi->prob_intra_coded = 1;
2811 if ((cm->frames_since_golden > 0) || cpi->source_alt_ref_active)
2813 cpi->prob_last_coded = rf_inter ? (rfct[LAST_FRAME] * 255) / rf_inter : 128;
2815 if (cpi->prob_last_coded < 1)
2816 cpi->prob_last_coded = 1;
2818 cpi->prob_gf_coded = (rfct[GOLDEN_FRAME] + rfct[ALTREF_FRAME])
2819 ? (rfct[GOLDEN_FRAME] * 255) / (rfct[GOLDEN_FRAME] + rfct[ALTREF_FRAME]) : 128;
2821 if (cpi->prob_gf_coded < 1)
2822 cpi->prob_gf_coded = 1;
2827 const int *const rfct = cpi->count_mb_ref_frame_usage;
2828 const int rf_intra = rfct[INTRA_FRAME];
2829 const int rf_inter = rfct[LAST_FRAME] + rfct[GOLDEN_FRAME] + rfct[ALTREF_FRAME];
2831 if (cm->frame_type == KEY_FRAME)
2833 cpi->prob_intra_coded = 255;
2834 cpi->prob_last_coded = 128;
2835 cpi->prob_gf_coded = 128;
2837 else if (!(rf_intra + rf_inter))
2839 // This is a trap in case this function is called with cpi->recent_ref_frame_usage[] blank.
2840 cpi->prob_intra_coded = 63;
2841 cpi->prob_last_coded = 128;
2842 cpi->prob_gf_coded = 128;
2846 cpi->prob_intra_coded = (rf_intra * 255) / (rf_intra + rf_inter);
2848 if (cpi->prob_intra_coded < 1)
2849 cpi->prob_intra_coded = 1;
2851 cpi->prob_last_coded = rf_inter ? (rfct[LAST_FRAME] * 255) / rf_inter : 128;
2853 if (cpi->prob_last_coded < 1)
2854 cpi->prob_last_coded = 1;
2856 cpi->prob_gf_coded = (rfct[GOLDEN_FRAME] + rfct[ALTREF_FRAME])
2857 ? (rfct[GOLDEN_FRAME] * 255) / (rfct[GOLDEN_FRAME] + rfct[ALTREF_FRAME]) : 128;
2859 if (cpi->prob_gf_coded < 1)
2860 cpi->prob_gf_coded = 1;
2863 // update reference frame costs since we can do better than what we got last frame.
2865 if (cpi->common.refresh_alt_ref_frame)
2867 cpi->prob_intra_coded += 40;
2868 cpi->prob_last_coded = 200;
2869 cpi->prob_gf_coded = 1;
2871 else if (cpi->common.frames_since_golden == 0)
2873 cpi->prob_last_coded = 214;
2874 cpi->prob_gf_coded = 1;
2876 else if (cpi->common.frames_since_golden == 1)
2878 cpi->prob_last_coded = 192;
2879 cpi->prob_gf_coded = 220;
2881 else if (cpi->source_alt_ref_active)
2883 //int dist = cpi->common.frames_till_alt_ref_frame + cpi->common.frames_since_golden;
2884 cpi->prob_gf_coded -= 20;
2886 if (cpi->prob_gf_coded < 10)
2887 cpi->prob_gf_coded = 10;
2894 // 1 = key, 0 = inter
2895 static int decide_key_frame(VP8_COMP *cpi)
2897 VP8_COMMON *cm = &cpi->common;
2899 int code_key_frame = FALSE;
2903 if (cpi->Speed > 11)
2906 // Clear down mmx registers
2907 vp8_clear_system_state(); //__asm emms;
2909 if ((cpi->compressor_speed == 2) && (cpi->Speed >= 5) && (cpi->sf.RD == 0))
2911 double change = 1.0 * abs((int)(cpi->intra_error - cpi->last_intra_error)) / (1 + cpi->last_intra_error);
2912 double change2 = 1.0 * abs((int)(cpi->prediction_error - cpi->last_prediction_error)) / (1 + cpi->last_prediction_error);
2913 double minerror = cm->MBs * 256;
2917 if (10 * cpi->intra_error / (1 + cpi->prediction_error) < 15
2918 && cpi->prediction_error > minerror
2919 && (change > .25 || change2 > .25))
2921 FILE *f = fopen("intra_inter.stt", "a");
2923 if (cpi->prediction_error <= 0)
2924 cpi->prediction_error = 1;
2926 fprintf(f, "%d %d %d %d %14.4f\n",
2927 cm->current_video_frame,
2928 (int) cpi->prediction_error,
2929 (int) cpi->intra_error,
2930 (int)((10 * cpi->intra_error) / cpi->prediction_error),
2938 cpi->last_intra_error = cpi->intra_error;
2939 cpi->last_prediction_error = cpi->prediction_error;
2941 if (10 * cpi->intra_error / (1 + cpi->prediction_error) < 15
2942 && cpi->prediction_error > minerror
2943 && (change > .25 || change2 > .25))
2945 /*(change > 1.4 || change < .75)&& cpi->this_frame_percent_intra > cpi->last_frame_percent_intra + 3*/
2953 // If the following are true we might as well code a key frame
2954 if (((cpi->this_frame_percent_intra == 100) &&
2955 (cpi->this_frame_percent_intra > (cpi->last_frame_percent_intra + 2))) ||
2956 ((cpi->this_frame_percent_intra > 95) &&
2957 (cpi->this_frame_percent_intra >= (cpi->last_frame_percent_intra + 5))))
2959 code_key_frame = TRUE;
2961 // in addition if the following are true and this is not a golden frame then code a key frame
2962 // Note that on golden frames there often seems to be a pop in intra useage anyway hence this
2963 // restriction is designed to prevent spurious key frames. The Intra pop needs to be investigated.
2964 else if (((cpi->this_frame_percent_intra > 60) &&
2965 (cpi->this_frame_percent_intra > (cpi->last_frame_percent_intra * 2))) ||
2966 ((cpi->this_frame_percent_intra > 75) &&
2967 (cpi->this_frame_percent_intra > (cpi->last_frame_percent_intra * 3 / 2))) ||
2968 ((cpi->this_frame_percent_intra > 90) &&
2969 (cpi->this_frame_percent_intra > (cpi->last_frame_percent_intra + 10))))
2971 if (!cm->refresh_golden_frame)
2972 code_key_frame = TRUE;
2975 return code_key_frame;
2979 #if !(CONFIG_REALTIME_ONLY)
2980 static void Pass1Encode(VP8_COMP *cpi, unsigned long *size, unsigned char *dest, unsigned int *frame_flags)
2985 vp8_set_quantizer(cpi, 26);
2987 scale_and_extend_source(cpi->un_scaled_source, cpi);
2988 vp8_first_pass(cpi);
2993 void write_cx_frame_to_file(YV12_BUFFER_CONFIG *frame, int this_frame)
3001 sprintf(filename, "cx\\y%04d.raw", this_frame);
3002 yframe = fopen(filename, "wb");
3004 for (i = 0; i < frame->y_height; i++)
3005 fwrite(frame->y_buffer + i * frame->y_stride, frame->y_width, 1, yframe);
3008 sprintf(filename, "cx\\u%04d.raw", this_frame);
3009 yframe = fopen(filename, "wb");
3011 for (i = 0; i < frame->uv_height; i++)
3012 fwrite(frame->u_buffer + i * frame->uv_stride, frame->uv_width, 1, yframe);
3015 sprintf(filename, "cx\\v%04d.raw", this_frame);
3016 yframe = fopen(filename, "wb");
3018 for (i = 0; i < frame->uv_height; i++)
3019 fwrite(frame->v_buffer + i * frame->uv_stride, frame->uv_width, 1, yframe);
3024 // return of 0 means drop frame
3026 // Function to test for conditions that indeicate we should loop
3027 // back and recode a frame.
3028 static BOOL recode_loop_test( VP8_COMP *cpi,
3029 int high_limit, int low_limit,
3030 int q, int maxq, int minq )
3032 BOOL force_recode = FALSE;
3033 VP8_COMMON *cm = &cpi->common;
3035 // Is frame recode allowed at all
3036 // Yes if either recode mode 1 is selected or mode two is selcted
3037 // and the frame is a key frame. golden frame or alt_ref_frame
3038 if ( (cpi->sf.recode_loop == 1) ||
3039 ( (cpi->sf.recode_loop == 2) &&
3040 ( (cm->frame_type == KEY_FRAME) ||
3041 cm->refresh_golden_frame ||
3042 cm->refresh_alt_ref_frame ) ) )
3044 // General over and under shoot tests
3045 if ( ((cpi->projected_frame_size > high_limit) && (q < maxq)) ||
3046 ((cpi->projected_frame_size < low_limit) && (q > minq)) )
3048 force_recode = TRUE;
3050 // Special Constrained quality tests
3051 else if (cpi->oxcf.end_usage == USAGE_CONSTRAINED_QUALITY)
3053 // Undershoot and below auto cq level
3054 if ( (q > cpi->cq_target_quality) &&
3055 (cpi->projected_frame_size <
3056 ((cpi->this_frame_target * 7) >> 3)))
3058 force_recode = TRUE;
3060 // Severe undershoot and between auto and user cq level
3061 else if ( (q > cpi->oxcf.cq_level) &&
3062 (cpi->projected_frame_size < cpi->min_frame_bandwidth) &&
3063 (cpi->active_best_quality > cpi->oxcf.cq_level))
3065 force_recode = TRUE;
3066 cpi->active_best_quality = cpi->oxcf.cq_level;
3071 return force_recode;
3074 void update_reference_frames(VP8_COMMON *cm)
3076 YV12_BUFFER_CONFIG *yv12_fb = cm->yv12_fb;
3078 // At this point the new frame has been encoded.
3079 // If any buffer copy / swapping is signaled it should be done here.
3081 if (cm->frame_type == KEY_FRAME)
3083 yv12_fb[cm->new_fb_idx].flags |= VP8_GOLD_FLAG | VP8_ALT_FLAG ;
3085 yv12_fb[cm->gld_fb_idx].flags &= ~VP8_GOLD_FLAG;
3086 yv12_fb[cm->alt_fb_idx].flags &= ~VP8_ALT_FLAG;
3088 cm->alt_fb_idx = cm->gld_fb_idx = cm->new_fb_idx;
3090 else /* For non key frames */
3092 if (cm->refresh_alt_ref_frame)
3094 assert(!cm->copy_buffer_to_arf);
3096 cm->yv12_fb[cm->new_fb_idx].flags |= VP8_ALT_FLAG;
3097 cm->yv12_fb[cm->alt_fb_idx].flags &= ~VP8_ALT_FLAG;
3098 cm->alt_fb_idx = cm->new_fb_idx;
3100 else if (cm->copy_buffer_to_arf)
3102 assert(!(cm->copy_buffer_to_arf & ~0x3));
3104 if (cm->copy_buffer_to_arf == 1)
3106 if(cm->alt_fb_idx != cm->lst_fb_idx)
3108 yv12_fb[cm->lst_fb_idx].flags |= VP8_ALT_FLAG;
3109 yv12_fb[cm->alt_fb_idx].flags &= ~VP8_ALT_FLAG;
3110 cm->alt_fb_idx = cm->lst_fb_idx;
3113 else /* if (cm->copy_buffer_to_arf == 2) */
3115 if(cm->alt_fb_idx != cm->gld_fb_idx)
3117 yv12_fb[cm->gld_fb_idx].flags |= VP8_ALT_FLAG;
3118 yv12_fb[cm->alt_fb_idx].flags &= ~VP8_ALT_FLAG;
3119 cm->alt_fb_idx = cm->gld_fb_idx;
3124 if (cm->refresh_golden_frame)
3126 assert(!cm->copy_buffer_to_gf);
3128 cm->yv12_fb[cm->new_fb_idx].flags |= VP8_GOLD_FLAG;
3129 cm->yv12_fb[cm->gld_fb_idx].flags &= ~VP8_GOLD_FLAG;
3130 cm->gld_fb_idx = cm->new_fb_idx;
3132 else if (cm->copy_buffer_to_gf)
3134 assert(!(cm->copy_buffer_to_arf & ~0x3));
3136 if (cm->copy_buffer_to_gf == 1)
3138 if(cm->gld_fb_idx != cm->lst_fb_idx)
3140 yv12_fb[cm->lst_fb_idx].flags |= VP8_GOLD_FLAG;
3141 yv12_fb[cm->gld_fb_idx].flags &= ~VP8_GOLD_FLAG;
3142 cm->gld_fb_idx = cm->lst_fb_idx;
3145 else /* if (cm->copy_buffer_to_gf == 2) */
3147 if(cm->alt_fb_idx != cm->gld_fb_idx)
3149 yv12_fb[cm->alt_fb_idx].flags |= VP8_GOLD_FLAG;
3150 yv12_fb[cm->gld_fb_idx].flags &= ~VP8_GOLD_FLAG;
3151 cm->gld_fb_idx = cm->alt_fb_idx;
3157 if (cm->refresh_last_frame)
3159 cm->yv12_fb[cm->new_fb_idx].flags |= VP8_LAST_FLAG;
3160 cm->yv12_fb[cm->lst_fb_idx].flags &= ~VP8_LAST_FLAG;
3161 cm->lst_fb_idx = cm->new_fb_idx;
3165 void loopfilter_frame(VP8_COMP *cpi, VP8_COMMON *cm)
3169 cm->filter_level = 0;
3173 struct vpx_usec_timer timer;
3175 vp8_clear_system_state();
3177 vpx_usec_timer_start(&timer);
3178 if (cpi->sf.auto_filter == 0)
3179 vp8cx_pick_filter_level_fast(cpi->Source, cpi);
3182 vp8cx_pick_filter_level(cpi->Source, cpi);
3184 vpx_usec_timer_mark(&timer);
3185 cpi->time_pick_lpf += vpx_usec_timer_elapsed(&timer);
3188 #if CONFIG_MULTITHREAD
3189 if (cpi->b_multi_threaded)
3190 sem_post(&cpi->h_event_end_lpf); /* signal that we have set filter_level */
3193 if (cm->filter_level > 0)
3195 vp8cx_set_alt_lf_level(cpi, cm->filter_level);
3196 vp8_loop_filter_frame(cm, &cpi->mb.e_mbd, cm->filter_level);
3197 cm->last_filter_type = cm->filter_type;
3198 cm->last_sharpness_level = cm->sharpness_level;
3201 vp8_yv12_extend_frame_borders_ptr(cm->frame_to_show);
3205 static void encode_frame_to_data_rate
3208 unsigned long *size,
3209 unsigned char *dest,
3210 unsigned int *frame_flags
3214 int frame_over_shoot_limit;
3215 int frame_under_shoot_limit;
3225 int zbin_oq_low = 0;
3228 VP8_COMMON *cm = &cpi->common;
3229 int active_worst_qchanged = FALSE;
3231 int overshoot_seen = FALSE;
3232 int undershoot_seen = FALSE;
3233 int drop_mark = cpi->oxcf.drop_frames_water_mark * cpi->oxcf.optimal_buffer_level / 100;
3234 int drop_mark75 = drop_mark * 2 / 3;
3235 int drop_mark50 = drop_mark / 4;
3236 int drop_mark25 = drop_mark / 8;
3239 // Clear down mmx registers to allow floating point in what follows
3240 vp8_clear_system_state();
3242 // Test code for segmentation of gf/arf (0,0)
3243 //segmentation_test_function((VP8_PTR) cpi);
3245 #if CONFIG_REALTIME_ONLY
3246 if(cpi->oxcf.auto_key && cm->frame_type != KEY_FRAME)
3248 if(cpi->force_next_frame_intra)
3250 cm->frame_type = KEY_FRAME; /* delayed intra frame */
3253 cpi->force_next_frame_intra = 0;
3256 // For an alt ref frame in 2 pass we skip the call to the second pass function that sets the target bandwidth
3257 #if !(CONFIG_REALTIME_ONLY)
3261 if (cpi->common.refresh_alt_ref_frame)
3263 cpi->per_frame_bandwidth = cpi->twopass.gf_bits; // Per frame bit target for the alt ref frame
3264 cpi->target_bandwidth = cpi->twopass.gf_bits * cpi->output_frame_rate; // per second target bitrate
3269 cpi->per_frame_bandwidth = (int)(cpi->target_bandwidth / cpi->output_frame_rate);
3271 // Default turn off buffer to buffer copying
3272 cm->copy_buffer_to_gf = 0;
3273 cm->copy_buffer_to_arf = 0;
3275 // Clear zbin over-quant value and mode boost values.
3276 cpi->zbin_over_quant = 0;
3277 cpi->zbin_mode_boost = 0;
3279 // Enable or disable mode based tweaking of the zbin
3280 // For 2 Pass Only used where GF/ARF prediction quality
3281 // is above a threshold
3282 cpi->zbin_mode_boost = 0;
3283 cpi->zbin_mode_boost_enabled = TRUE;
3286 if ( cpi->gfu_boost <= 400 )
3288 cpi->zbin_mode_boost_enabled = FALSE;
3292 // Current default encoder behaviour for the altref sign bias
3293 if (cpi->source_alt_ref_active)
3294 cpi->common.ref_frame_sign_bias[ALTREF_FRAME] = 1;
3296 cpi->common.ref_frame_sign_bias[ALTREF_FRAME] = 0;
3298 // Check to see if a key frame is signalled
3299 // For two pass with auto key frame enabled cm->frame_type may already be set, but not for one pass.
3300 if ((cm->current_video_frame == 0) ||
3301 (cm->frame_flags & FRAMEFLAGS_KEY) ||
3302 (cpi->oxcf.auto_key && (cpi->frames_since_key % cpi->key_frame_frequency == 0)))
3304 // Key frame from VFW/auto-keyframe/first frame
3305 cm->frame_type = KEY_FRAME;
3308 // Set default state for segment and mode based loop filter update flags
3309 cpi->mb.e_mbd.update_mb_segmentation_map = 0;
3310 cpi->mb.e_mbd.update_mb_segmentation_data = 0;
3311 cpi->mb.e_mbd.mode_ref_lf_delta_update = 0;
3313 // Set various flags etc to special state if it is a key frame
3314 if (cm->frame_type == KEY_FRAME)
3318 // Reset the loop filter deltas and segmentation map
3319 setup_features(cpi);
3321 // If segmentation is enabled force a map update for key frames
3322 if (cpi->mb.e_mbd.segmentation_enabled)
3324 cpi->mb.e_mbd.update_mb_segmentation_map = 1;
3325 cpi->mb.e_mbd.update_mb_segmentation_data = 1;
3328 // The alternate reference frame cannot be active for a key frame
3329 cpi->source_alt_ref_active = FALSE;
3331 // Reset the RD threshold multipliers to default of * 1 (128)
3332 for (i = 0; i < MAX_MODES; i++)
3334 cpi->rd_thresh_mult[i] = 128;
3338 // Test code for segmentation
3339 //if ( (cm->frame_type == KEY_FRAME) || ((cm->current_video_frame % 2) == 0))
3340 //if ( (cm->current_video_frame % 2) == 0 )
3341 // enable_segmentation((VP8_PTR)cpi);
3343 // disable_segmentation((VP8_PTR)cpi);
3346 // Experimental code for lagged compress and one pass
3347 // Initialise one_pass GF frames stats
3348 // Update stats used for GF selection
3349 //if ( cpi->pass == 0 )
3351 cpi->one_pass_frame_index = cm->current_video_frame % MAX_LAG_BUFFERS;
3353 cpi->one_pass_frame_stats[cpi->one_pass_frame_index ].frames_so_far = 0;
3354 cpi->one_pass_frame_stats[cpi->one_pass_frame_index ].frame_intra_error = 0.0;
3355 cpi->one_pass_frame_stats[cpi->one_pass_frame_index ].frame_coded_error = 0.0;
3356 cpi->one_pass_frame_stats[cpi->one_pass_frame_index ].frame_pcnt_inter = 0.0;
3357 cpi->one_pass_frame_stats[cpi->one_pass_frame_index ].frame_pcnt_motion = 0.0;
3358 cpi->one_pass_frame_stats[cpi->one_pass_frame_index ].frame_mvr = 0.0;
3359 cpi->one_pass_frame_stats[cpi->one_pass_frame_index ].frame_mvr_abs = 0.0;
3360 cpi->one_pass_frame_stats[cpi->one_pass_frame_index ].frame_mvc = 0.0;
3361 cpi->one_pass_frame_stats[cpi->one_pass_frame_index ].frame_mvc_abs = 0.0;
3365 update_rd_ref_frame_probs(cpi);
3367 if (cpi->drop_frames_allowed)
3369 // The reset to decimation 0 is only done here for one pass.
3370 // Once it is set two pass leaves decimation on till the next kf.
3371 if ((cpi->buffer_level > drop_mark) && (cpi->decimation_factor > 0))
3372 cpi->decimation_factor --;
3374 if (cpi->buffer_level > drop_mark75 && cpi->decimation_factor > 0)
3375 cpi->decimation_factor = 1;
3377 else if (cpi->buffer_level < drop_mark25 && (cpi->decimation_factor == 2 || cpi->decimation_factor == 3))
3379 cpi->decimation_factor = 3;
3381 else if (cpi->buffer_level < drop_mark50 && (cpi->decimation_factor == 1 || cpi->decimation_factor == 2))
3383 cpi->decimation_factor = 2;
3385 else if (cpi->buffer_level < drop_mark75 && (cpi->decimation_factor == 0 || cpi->decimation_factor == 1))
3387 cpi->decimation_factor = 1;
3390 //vpx_log("Encoder: Decimation Factor: %d \n",cpi->decimation_factor);
3393 // The following decimates the frame rate according to a regular pattern (i.e. to 1/2 or 2/3 frame rate)
3394 // This can be used to help prevent buffer under-run in CBR mode. Alternatively it might be desirable in
3395 // some situations to drop frame rate but throw more bits at each frame.
3397 // Note that dropping a key frame can be problematic if spatial resampling is also active
3398 if (cpi->decimation_factor > 0)
3400 switch (cpi->decimation_factor)
3403 cpi->per_frame_bandwidth = cpi->per_frame_bandwidth * 3 / 2;
3406 cpi->per_frame_bandwidth = cpi->per_frame_bandwidth * 5 / 4;
3409 cpi->per_frame_bandwidth = cpi->per_frame_bandwidth * 5 / 4;
3413 // Note that we should not throw out a key frame (especially when spatial resampling is enabled).
3414 if ((cm->frame_type == KEY_FRAME)) // && cpi->oxcf.allow_spatial_resampling )
3416 cpi->decimation_count = cpi->decimation_factor;
3418 else if (cpi->decimation_count > 0)
3420 cpi->decimation_count --;
3421 cpi->bits_off_target += cpi->av_per_frame_bandwidth;
3422 cm->current_video_frame++;
3423 cpi->frames_since_key++;
3425 #if CONFIG_INTERNAL_STATS
3429 cpi->buffer_level = cpi->bits_off_target;
3434 cpi->decimation_count = cpi->decimation_factor;
3437 // Decide how big to make the frame
3438 if (!vp8_pick_frame_size(cpi))
3440 cm->current_video_frame++;
3441 cpi->frames_since_key++;
3445 // Reduce active_worst_allowed_q for CBR if our buffer is getting too full.
3446 // This has a knock on effect on active best quality as well.
3447 // For CBR if the buffer reaches its maximum level then we can no longer
3448 // save up bits for later frames so we might as well use them up
3449 // on the current frame.
3450 if ((cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER) &&
3451 (cpi->buffer_level >= cpi->oxcf.optimal_buffer_level) && cpi->buffered_mode)
3453 int Adjustment = cpi->active_worst_quality / 4; // Max adjustment is 1/4
3459 if (cpi->buffer_level < cpi->oxcf.maximum_buffer_size)
3461 buff_lvl_step = (cpi->oxcf.maximum_buffer_size - cpi->oxcf.optimal_buffer_level) / Adjustment;
3464 Adjustment = (cpi->buffer_level - cpi->oxcf.optimal_buffer_level) / buff_lvl_step;
3469 cpi->active_worst_quality -= Adjustment;
3471 if(cpi->active_worst_quality < cpi->active_best_quality)
3472 cpi->active_worst_quality = cpi->active_best_quality;
3476 // Set an active best quality and if necessary active worst quality
3477 // There is some odd behaviour for one pass here that needs attention.
3478 if ( (cpi->pass == 2) || (cpi->ni_frames > 150))
3480 vp8_clear_system_state();
3482 Q = cpi->active_worst_quality;
3484 if ( cm->frame_type == KEY_FRAME )
3486 if ( cpi->pass == 2 )
3488 if (cpi->gfu_boost > 600)
3489 cpi->active_best_quality = kf_low_motion_minq[Q];
3491 cpi->active_best_quality = kf_high_motion_minq[Q];
3493 // Special case for key frames forced because we have reached
3494 // the maximum key frame interval. Here force the Q to a range
3495 // based on the ambient Q to reduce the risk of popping
3496 if ( cpi->this_key_frame_forced )
3498 if ( cpi->active_best_quality > cpi->avg_frame_qindex * 7/8)
3499 cpi->active_best_quality = cpi->avg_frame_qindex * 7/8;
3500 else if ( cpi->active_best_quality < cpi->avg_frame_qindex >> 2 )
3501 cpi->active_best_quality = cpi->avg_frame_qindex >> 2;
3504 // One pass more conservative
3506 cpi->active_best_quality = kf_high_motion_minq[Q];
3509 else if (cm->refresh_golden_frame || cpi->common.refresh_alt_ref_frame)
3511 // Use the lower of cpi->active_worst_quality and recent
3512 // average Q as basis for GF/ARF Q limit unless last frame was
3514 if ( (cpi->frames_since_key > 1) &&
3515 (cpi->avg_frame_qindex < cpi->active_worst_quality) )
3517 Q = cpi->avg_frame_qindex;
3519 if ( (cpi->oxcf.end_usage == USAGE_CONSTRAINED_QUALITY) &&
3520 (Q < cpi->oxcf.cq_level) )
3522 Q = cpi->oxcf.cq_level;
3526 if ( cpi->pass == 2 )
3528 if ( cpi->gfu_boost > 1000 )
3529 cpi->active_best_quality = gf_low_motion_minq[Q];
3530 else if ( cpi->gfu_boost < 400 )
3531 cpi->active_best_quality = gf_high_motion_minq[Q];
3533 cpi->active_best_quality = gf_mid_motion_minq[Q];
3535 // One pass more conservative
3537 cpi->active_best_quality = gf_high_motion_minq[Q];
3541 cpi->active_best_quality = inter_minq[Q];
3543 // For the constant/constrained quality mode we dont want
3544 // the quality to rise above the cq level.
3545 if ((cpi->oxcf.end_usage == USAGE_CONSTRAINED_QUALITY) &&
3546 (cpi->active_best_quality < cpi->cq_target_quality) )
3548 // If we are strongly undershooting the target rate in the last
3549 // frames then use the user passed in cq value not the auto
3551 if ( cpi->rolling_actual_bits < cpi->min_frame_bandwidth )
3552 cpi->active_best_quality = cpi->oxcf.cq_level;
3554 cpi->active_best_quality = cpi->cq_target_quality;
3558 // If CBR and the buffer is as full then it is reasonable to allow
3559 // higher quality on the frames to prevent bits just going to waste.
3560 if (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER)
3562 // Note that the use of >= here elliminates the risk of a devide
3563 // by 0 error in the else if clause
3564 if (cpi->buffer_level >= cpi->oxcf.maximum_buffer_size)
3565 cpi->active_best_quality = cpi->best_quality;
3567 else if (cpi->buffer_level > cpi->oxcf.optimal_buffer_level)
3569 int Fraction = ((cpi->buffer_level - cpi->oxcf.optimal_buffer_level) * 128) / (cpi->oxcf.maximum_buffer_size - cpi->oxcf.optimal_buffer_level);
3570 int min_qadjustment = ((cpi->active_best_quality - cpi->best_quality) * Fraction) / 128;
3572 cpi->active_best_quality -= min_qadjustment;
3576 // Make sure constrained quality mode limits are adhered to for the first
3577 // few frames of one pass encodes
3578 else if (cpi->oxcf.end_usage == USAGE_CONSTRAINED_QUALITY)
3580 if ( (cm->frame_type == KEY_FRAME) ||
3581 cm->refresh_golden_frame || cpi->common.refresh_alt_ref_frame )
3583 cpi->active_best_quality = cpi->best_quality;
3585 else if (cpi->active_best_quality < cpi->cq_target_quality)
3587 cpi->active_best_quality = cpi->cq_target_quality;
3591 // Clip the active best and worst quality values to limits
3592 if (cpi->active_worst_quality > cpi->worst_quality)
3593 cpi->active_worst_quality = cpi->worst_quality;
3595 if (cpi->active_best_quality < cpi->best_quality)
3596 cpi->active_best_quality = cpi->best_quality;
3597 else if (cpi->active_best_quality > cpi->active_worst_quality)
3598 cpi->active_best_quality = cpi->active_worst_quality;
3600 // Determine initial Q to try
3601 Q = vp8_regulate_q(cpi, cpi->this_frame_target);
3602 last_zbin_oq = cpi->zbin_over_quant;
3604 // Set highest allowed value for Zbin over quant
3605 if (cm->frame_type == KEY_FRAME)
3606 zbin_oq_high = 0; //ZBIN_OQ_MAX/16
3607 else if (cm->refresh_alt_ref_frame || (cm->refresh_golden_frame && !cpi->source_alt_ref_active))
3610 zbin_oq_high = ZBIN_OQ_MAX;
3612 // Setup background Q adjustment for error resilliant mode
3613 if (cpi->cyclic_refresh_mode_enabled)
3614 cyclic_background_refresh(cpi, Q, 0);
3616 vp8_compute_frame_size_bounds(cpi, &frame_under_shoot_limit, &frame_over_shoot_limit);
3618 // Limit Q range for the adaptive loop.
3619 bottom_index = cpi->active_best_quality;
3620 top_index = cpi->active_worst_quality;
3621 q_low = cpi->active_best_quality;
3622 q_high = cpi->active_worst_quality;
3624 vp8_save_coding_context(cpi);
3629 scale_and_extend_source(cpi->un_scaled_source, cpi);
3630 #if !(CONFIG_REALTIME_ONLY) && CONFIG_POSTPROC
3632 if (cpi->oxcf.noise_sensitivity > 0)
3637 switch (cpi->oxcf.noise_sensitivity)
3660 if (cm->frame_type == KEY_FRAME)
3662 vp8_de_noise(cpi->Source, cpi->Source, l , 1, 0, RTCD(postproc));
3666 vp8_de_noise(cpi->Source, cpi->Source, l , 1, 0, RTCD(postproc));
3668 src = cpi->Source->y_buffer;
3670 if (cpi->Source->y_stride < 0)
3672 src += cpi->Source->y_stride * (cpi->Source->y_height - 1);
3679 #ifdef OUTPUT_YUV_SRC
3680 vp8_write_yuv_frame(cpi->Source);
3685 vp8_clear_system_state(); //__asm emms;
3688 if(cpi->is_src_frame_alt_ref)
3692 vp8_set_quantizer(cpi, Q);
3695 // setup skip prob for costing in mode/mv decision
3696 if (cpi->common.mb_no_coeff_skip)
3698 cpi->prob_skip_false = cpi->base_skip_false_prob[Q];
3700 if (cm->frame_type != KEY_FRAME)
3702 if (cpi->common.refresh_alt_ref_frame)
3704 if (cpi->last_skip_false_probs[2] != 0)
3705 cpi->prob_skip_false = cpi->last_skip_false_probs[2];
3708 if(cpi->last_skip_false_probs[2]!=0 && abs(Q- cpi->last_skip_probs_q[2])<=16 )
3709 cpi->prob_skip_false = cpi->last_skip_false_probs[2];
3710 else if (cpi->last_skip_false_probs[2]!=0)
3711 cpi->prob_skip_false = (cpi->last_skip_false_probs[2] + cpi->prob_skip_false ) / 2;
3714 else if (cpi->common.refresh_golden_frame)
3716 if (cpi->last_skip_false_probs[1] != 0)
3717 cpi->prob_skip_false = cpi->last_skip_false_probs[1];
3720 if(cpi->last_skip_false_probs[1]!=0 && abs(Q- cpi->last_skip_probs_q[1])<=16 )
3721 cpi->prob_skip_false = cpi->last_skip_false_probs[1];
3722 else if (cpi->last_skip_false_probs[1]!=0)
3723 cpi->prob_skip_false = (cpi->last_skip_false_probs[1] + cpi->prob_skip_false ) / 2;
3728 if (cpi->last_skip_false_probs[0] != 0)
3729 cpi->prob_skip_false = cpi->last_skip_false_probs[0];
3732 if(cpi->last_skip_false_probs[0]!=0 && abs(Q- cpi->last_skip_probs_q[0])<=16 )
3733 cpi->prob_skip_false = cpi->last_skip_false_probs[0];
3734 else if(cpi->last_skip_false_probs[0]!=0)
3735 cpi->prob_skip_false = (cpi->last_skip_false_probs[0] + cpi->prob_skip_false ) / 2;
3739 //as this is for cost estimate, let's make sure it does not go extreme eitehr way
3740 if (cpi->prob_skip_false < 5)
3741 cpi->prob_skip_false = 5;
3743 if (cpi->prob_skip_false > 250)
3744 cpi->prob_skip_false = 250;
3746 if (cpi->is_src_frame_alt_ref)
3747 cpi->prob_skip_false = 1;
3756 FILE *f = fopen("skip.stt", "a");
3757 fprintf(f, "%d, %d, %4d ", cpi->common.refresh_golden_frame, cpi->common.refresh_alt_ref_frame, cpi->prob_skip_false);
3765 if (cm->frame_type == KEY_FRAME)
3767 resize_key_frame(cpi);
3768 vp8_setup_key_frame(cpi);
3771 // transform / motion compensation build reconstruction frame
3772 vp8_encode_frame(cpi);
3774 cpi->projected_frame_size -= vp8_estimate_entropy_savings(cpi);
3775 cpi->projected_frame_size = (cpi->projected_frame_size > 0) ? cpi->projected_frame_size : 0;
3777 vp8_clear_system_state(); //__asm emms;
3779 // Test to see if the stats generated for this frame indicate that we should have coded a key frame
3780 // (assuming that we didn't)!
3781 if (cpi->pass != 2 && cpi->oxcf.auto_key && cm->frame_type != KEY_FRAME)
3784 #if CONFIG_REALTIME_ONLY
3786 /* we don't do re-encoding in realtime mode
3787 * if key frame is decided than we force it on next frame */
3788 cpi->force_next_frame_intra = decide_key_frame(cpi);
3791 if (decide_key_frame(cpi))
3793 // Reset all our sizing numbers and recode
3794 cm->frame_type = KEY_FRAME;
3796 vp8_pick_frame_size(cpi);
3798 // Clear the Alt reference frame active flag when we have a key frame
3799 cpi->source_alt_ref_active = FALSE;
3801 // Reset the loop filter deltas and segmentation map
3802 setup_features(cpi);
3804 // If segmentation is enabled force a map update for key frames
3805 if (cpi->mb.e_mbd.segmentation_enabled)
3807 cpi->mb.e_mbd.update_mb_segmentation_map = 1;
3808 cpi->mb.e_mbd.update_mb_segmentation_data = 1;
3811 vp8_restore_coding_context(cpi);
3813 Q = vp8_regulate_q(cpi, cpi->this_frame_target);
3815 vp8_compute_frame_size_bounds(cpi, &frame_under_shoot_limit, &frame_over_shoot_limit);
3817 // Limit Q range for the adaptive loop.
3818 bottom_index = cpi->active_best_quality;
3819 top_index = cpi->active_worst_quality;
3820 q_low = cpi->active_best_quality;
3821 q_high = cpi->active_worst_quality;
3831 vp8_clear_system_state();
3833 if (frame_over_shoot_limit == 0)
3834 frame_over_shoot_limit = 1;
3836 // Are we are overshooting and up against the limit of active max Q.
3837 if (((cpi->pass != 2) || (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER)) &&
3838 (Q == cpi->active_worst_quality) &&
3839 (cpi->active_worst_quality < cpi->worst_quality) &&
3840 (cpi->projected_frame_size > frame_over_shoot_limit))
3842 int over_size_percent = ((cpi->projected_frame_size - frame_over_shoot_limit) * 100) / frame_over_shoot_limit;
3844 // If so is there any scope for relaxing it
3845 while ((cpi->active_worst_quality < cpi->worst_quality) && (over_size_percent > 0))
3847 cpi->active_worst_quality++;
3848 top_index = cpi->active_worst_quality;
3849 over_size_percent = (int)(over_size_percent * 0.96); // Assume 1 qstep = about 4% on frame size.
3852 // If we have updated the active max Q do not call vp8_update_rate_correction_factors() this loop.
3853 active_worst_qchanged = TRUE;
3856 active_worst_qchanged = FALSE;
3858 #if !(CONFIG_REALTIME_ONLY)
3859 // Special case handling for forced key frames
3860 if ( (cm->frame_type == KEY_FRAME) && cpi->this_key_frame_forced )
3863 int kf_err = vp8_calc_ss_err(cpi->Source,
3864 &cm->yv12_fb[cm->new_fb_idx],
3865 IF_RTCD(&cpi->rtcd.variance));
3867 // The key frame is not good enough
3868 if ( kf_err > ((cpi->ambient_err * 7) >> 3) )
3871 q_high = (Q > q_low) ? (Q - 1) : q_low;
3874 Q = (q_high + q_low) >> 1;
3876 // The key frame is much better than the previous frame
3877 else if ( kf_err < (cpi->ambient_err >> 1) )
3880 q_low = (Q < q_high) ? (Q + 1) : q_high;
3883 Q = (q_high + q_low + 1) >> 1;
3886 // Clamp Q to upper and lower limits:
3892 Loop = ((Q != last_q)) ? TRUE : FALSE;
3895 // Is the projected frame size out of range and are we allowed to attempt to recode.
3896 else if ( recode_loop_test( cpi,
3897 frame_over_shoot_limit, frame_under_shoot_limit,
3898 Q, top_index, bottom_index ) )
3903 // Frame size out of permitted range:
3904 // Update correction factor & compute new Q to try...
3906 // Frame is too large
3907 if (cpi->projected_frame_size > cpi->this_frame_target)
3909 //if ( cpi->zbin_over_quant == 0 )
3910 q_low = (Q < q_high) ? (Q + 1) : q_high; // Raise Qlow as to at least the current value
3912 if (cpi->zbin_over_quant > 0) // If we are using over quant do the same for zbin_oq_low
3913 zbin_oq_low = (cpi->zbin_over_quant < zbin_oq_high) ? (cpi->zbin_over_quant + 1) : zbin_oq_high;
3915 //if ( undershoot_seen || (Q == MAXQ) )
3916 if (undershoot_seen)
3918 // Update rate_correction_factor unless cpi->active_worst_quality has changed.
3919 if (!active_worst_qchanged)
3920 vp8_update_rate_correction_factors(cpi, 1);
3922 Q = (q_high + q_low + 1) / 2;
3924 // Adjust cpi->zbin_over_quant (only allowed when Q is max)
3926 cpi->zbin_over_quant = 0;
3929 zbin_oq_low = (cpi->zbin_over_quant < zbin_oq_high) ? (cpi->zbin_over_quant + 1) : zbin_oq_high;
3930 cpi->zbin_over_quant = (zbin_oq_high + zbin_oq_low) / 2;
3935 // Update rate_correction_factor unless cpi->active_worst_quality has changed.
3936 if (!active_worst_qchanged)
3937 vp8_update_rate_correction_factors(cpi, 0);
3939 Q = vp8_regulate_q(cpi, cpi->this_frame_target);
3941 while (((Q < q_low) || (cpi->zbin_over_quant < zbin_oq_low)) && (Retries < 10))
3943 vp8_update_rate_correction_factors(cpi, 0);
3944 Q = vp8_regulate_q(cpi, cpi->this_frame_target);
3949 overshoot_seen = TRUE;
3951 // Frame is too small
3954 if (cpi->zbin_over_quant == 0)
3955 q_high = (Q > q_low) ? (Q - 1) : q_low; // Lower q_high if not using over quant
3956 else // else lower zbin_oq_high
3957 zbin_oq_high = (cpi->zbin_over_quant > zbin_oq_low) ? (cpi->zbin_over_quant - 1) : zbin_oq_low;
3961 // Update rate_correction_factor unless cpi->active_worst_quality has changed.
3962 if (!active_worst_qchanged)
3963 vp8_update_rate_correction_factors(cpi, 1);
3965 Q = (q_high + q_low) / 2;
3967 // Adjust cpi->zbin_over_quant (only allowed when Q is max)
3969 cpi->zbin_over_quant = 0;
3971 cpi->zbin_over_quant = (zbin_oq_high + zbin_oq_low) / 2;
3975 // Update rate_correction_factor unless cpi->active_worst_quality has changed.
3976 if (!active_worst_qchanged)
3977 vp8_update_rate_correction_factors(cpi, 0);
3979 Q = vp8_regulate_q(cpi, cpi->this_frame_target);
3981 // Special case reset for qlow for constrained quality.
3982 // This should only trigger where there is very substantial
3983 // undershoot on a frame and the auto cq level is above
3984 // the user passsed in value.
3985 if ( (cpi->oxcf.end_usage == USAGE_CONSTRAINED_QUALITY) &&
3991 while (((Q > q_high) || (cpi->zbin_over_quant > zbin_oq_high)) && (Retries < 10))
3993 vp8_update_rate_correction_factors(cpi, 0);
3994 Q = vp8_regulate_q(cpi, cpi->this_frame_target);
3999 undershoot_seen = TRUE;
4002 // Clamp Q to upper and lower limits:
4008 // Clamp cpi->zbin_over_quant
4009 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;
4011 //Loop = ((Q != last_q) || (last_zbin_oq != cpi->zbin_over_quant)) ? TRUE : FALSE;
4012 Loop = ((Q != last_q)) ? TRUE : FALSE;
4013 last_zbin_oq = cpi->zbin_over_quant;
4019 if (cpi->is_src_frame_alt_ref)
4024 vp8_restore_coding_context(cpi);
4026 #if CONFIG_INTERNAL_STATS
4027 cpi->tot_recode_hits++;
4031 while (Loop == TRUE);
4034 // Experimental code for lagged and one pass
4035 // Update stats used for one pass GF selection
4039 double frame_intra_error;
4040 double frame_coded_error;
4041 double frame_pcnt_inter;
4042 double frame_pcnt_motion;
4044 double frame_mvr_abs;
4046 double frame_mvc_abs;
4049 cpi->one_pass_frame_stats[cpi->one_pass_frame_index].frame_coded_error = (double)cpi->prediction_error;
4050 cpi->one_pass_frame_stats[cpi->one_pass_frame_index].frame_intra_error = (double)cpi->intra_error;
4051 cpi->one_pass_frame_stats[cpi->one_pass_frame_index].frame_pcnt_inter = (double)(100 - cpi->this_frame_percent_intra) / 100.0;
4055 // Special case code to reduce pulsing when key frames are forced at a
4056 // fixed interval. Note the reconstruction error if it is the frame before
4057 // the force key frame
4058 if ( cpi->next_key_frame_forced && (cpi->twopass.frames_to_key == 0) )
4060 cpi->ambient_err = vp8_calc_ss_err(cpi->Source,
4061 &cm->yv12_fb[cm->new_fb_idx],
4062 IF_RTCD(&cpi->rtcd.variance));
4065 // This frame's MVs are saved and will be used in next frame's MV prediction.
4066 // Last frame has one more line(add to bottom) and one more column(add to right) than cm->mip. The edge elements are initialized to 0.
4067 if(cm->show_frame) //do not save for altref frame
4071 MODE_INFO *tmp = cm->mip; //point to beginning of allocated MODE_INFO arrays.
4073 if(cm->frame_type != KEY_FRAME)
4075 for (mb_row = 0; mb_row < cm->mb_rows+1; mb_row ++)
4077 for (mb_col = 0; mb_col < cm->mb_cols+1; mb_col ++)
4079 if(tmp->mbmi.ref_frame != INTRA_FRAME)
4080 cpi->lfmv[mb_col + mb_row*(cm->mode_info_stride+1)].as_int = tmp->mbmi.mv.as_int;
4082 cpi->lf_ref_frame_sign_bias[mb_col + mb_row*(cm->mode_info_stride+1)] = cm->ref_frame_sign_bias[tmp->mbmi.ref_frame];
4083 cpi->lf_ref_frame[mb_col + mb_row*(cm->mode_info_stride+1)] = tmp->mbmi.ref_frame;
4090 // Update the GF useage maps.
4091 // This is done after completing the compression of a frame when all modes etc. are finalized but before loop filter
4092 // This is done after completing the compression of a frame when all modes etc. are finalized but before loop filter
4093 vp8_update_gf_useage_maps(cpi, cm, &cpi->mb);
4095 if (cm->frame_type == KEY_FRAME)
4096 cm->refresh_last_frame = 1;
4100 FILE *f = fopen("gfactive.stt", "a");
4101 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);
4106 // For inter frames the current default behavior is that when
4107 // cm->refresh_golden_frame is set we copy the old GF over to the ARF buffer
4108 // This is purely an encoder decision at present.
4109 if (!cpi->oxcf.error_resilient_mode && cm->refresh_golden_frame)
4110 cm->copy_buffer_to_arf = 2;
4112 cm->copy_buffer_to_arf = 0;
4114 cm->frame_to_show = &cm->yv12_fb[cm->new_fb_idx];
4116 #if CONFIG_MULTITHREAD
4117 if (cpi->b_multi_threaded)
4119 sem_post(&cpi->h_event_start_lpf); /* start loopfilter in separate thread */
4124 loopfilter_frame(cpi, cm);
4127 update_reference_frames(cm);
4129 if (cpi->oxcf.error_resilient_mode == 1)
4131 cm->refresh_entropy_probs = 0;
4134 #if CONFIG_MULTITHREAD
4135 /* wait that filter_level is picked so that we can continue with stream packing */
4136 if (cpi->b_multi_threaded)
4137 sem_wait(&cpi->h_event_end_lpf);
4140 // build the bitstream
4141 vp8_pack_bitstream(cpi, dest, size);
4143 #if CONFIG_MULTITHREAD
4144 /* wait for loopfilter thread done */
4145 if (cpi->b_multi_threaded)
4147 sem_wait(&cpi->h_event_end_lpf);
4151 /* Move storing frame_type out of the above loop since it is also
4152 * needed in motion search besides loopfilter */
4153 cm->last_frame_type = cm->frame_type;
4155 // Update rate control heuristics
4156 cpi->total_byte_count += (*size);
4157 cpi->projected_frame_size = (*size) << 3;
4159 if (!active_worst_qchanged)
4160 vp8_update_rate_correction_factors(cpi, 2);
4162 cpi->last_q[cm->frame_type] = cm->base_qindex;
4164 if (cm->frame_type == KEY_FRAME)
4166 vp8_adjust_key_frame_context(cpi);
4169 // Keep a record of ambient average Q.
4170 if (cm->frame_type != KEY_FRAME)
4171 cpi->avg_frame_qindex = (2 + 3 * cpi->avg_frame_qindex + cm->base_qindex) >> 2;
4173 // Keep a record from which we can calculate the average Q excluding GF updates and key frames
4174 if ((cm->frame_type != KEY_FRAME) && !cm->refresh_golden_frame && !cm->refresh_alt_ref_frame)
4178 // Calculate the average Q for normal inter frames (not key or GFU
4180 if ( cpi->pass == 2 )
4182 cpi->ni_tot_qi += Q;
4183 cpi->ni_av_qi = (cpi->ni_tot_qi / cpi->ni_frames);
4187 // Damp value for first few frames
4188 if (cpi->ni_frames > 150 )
4190 cpi->ni_tot_qi += Q;
4191 cpi->ni_av_qi = (cpi->ni_tot_qi / cpi->ni_frames);
4193 // For one pass, early in the clip ... average the current frame Q
4194 // value with the worstq entered by the user as a dampening measure
4197 cpi->ni_tot_qi += Q;
4198 cpi->ni_av_qi = ((cpi->ni_tot_qi / cpi->ni_frames) + cpi->worst_quality + 1) / 2;
4201 // If the average Q is higher than what was used in the last frame
4202 // (after going through the recode loop to keep the frame size within range)
4203 // then use the last frame value - 1.
4204 // The -1 is designed to stop Q and hence the data rate, from progressively
4205 // falling away during difficult sections, but at the same time reduce the number of
4206 // itterations around the recode loop.
4207 if (Q > cpi->ni_av_qi)
4208 cpi->ni_av_qi = Q - 1;
4214 // If the frame was massively oversize and we are below optimal buffer level drop next frame
4215 if ((cpi->drop_frames_allowed) &&
4216 (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER) &&
4217 (cpi->buffer_level < cpi->oxcf.drop_frames_water_mark * cpi->oxcf.optimal_buffer_level / 100) &&
4218 (cpi->projected_frame_size > (4 * cpi->this_frame_target)))
4220 cpi->drop_frame = TRUE;
4225 // Set the count for maximum consequative dropped frames based upon the ratio of
4226 // this frame size to the target average per frame bandwidth.
4227 // (cpi->av_per_frame_bandwidth > 0) is just a sanity check to prevent / 0.
4228 if (cpi->drop_frames_allowed && (cpi->av_per_frame_bandwidth > 0))
4230 cpi->max_drop_count = cpi->projected_frame_size / cpi->av_per_frame_bandwidth;
4232 if (cpi->max_drop_count > cpi->max_consec_dropped_frames)
4233 cpi->max_drop_count = cpi->max_consec_dropped_frames;
4236 // Update the buffer level variable.
4237 // Non-viewable frames are a special case and are treated as pure overhead.
4238 if ( !cm->show_frame )
4239 cpi->bits_off_target -= cpi->projected_frame_size;
4241 cpi->bits_off_target += cpi->av_per_frame_bandwidth - cpi->projected_frame_size;
4243 // Rolling monitors of whether we are over or underspending used to help regulate min and Max Q in two pass.
4244 cpi->rolling_target_bits = ((cpi->rolling_target_bits * 3) + cpi->this_frame_target + 2) / 4;
4245 cpi->rolling_actual_bits = ((cpi->rolling_actual_bits * 3) + cpi->projected_frame_size + 2) / 4;
4246 cpi->long_rolling_target_bits = ((cpi->long_rolling_target_bits * 31) + cpi->this_frame_target + 16) / 32;
4247 cpi->long_rolling_actual_bits = ((cpi->long_rolling_actual_bits * 31) + cpi->projected_frame_size + 16) / 32;
4249 // Actual bits spent
4250 cpi->total_actual_bits += cpi->projected_frame_size;
4253 cpi->total_target_vs_actual += (cpi->this_frame_target - cpi->projected_frame_size);
4255 cpi->buffer_level = cpi->bits_off_target;
4257 // Update bits left to the kf and gf groups to account for overshoot or undershoot on these frames
4258 if (cm->frame_type == KEY_FRAME)
4260 cpi->twopass.kf_group_bits += cpi->this_frame_target - cpi->projected_frame_size;
4262 if (cpi->twopass.kf_group_bits < 0)
4263 cpi->twopass.kf_group_bits = 0 ;
4265 else if (cm->refresh_golden_frame || cm->refresh_alt_ref_frame)
4267 cpi->twopass.gf_group_bits += cpi->this_frame_target - cpi->projected_frame_size;
4269 if (cpi->twopass.gf_group_bits < 0)
4270 cpi->twopass.gf_group_bits = 0 ;
4273 if (cm->frame_type != KEY_FRAME)
4275 if (cpi->common.refresh_alt_ref_frame)
4277 cpi->last_skip_false_probs[2] = cpi->prob_skip_false;
4278 cpi->last_skip_probs_q[2] = cm->base_qindex;
4280 else if (cpi->common.refresh_golden_frame)
4282 cpi->last_skip_false_probs[1] = cpi->prob_skip_false;
4283 cpi->last_skip_probs_q[1] = cm->base_qindex;
4287 cpi->last_skip_false_probs[0] = cpi->prob_skip_false;
4288 cpi->last_skip_probs_q[0] = cm->base_qindex;
4290 //update the baseline
4291 cpi->base_skip_false_prob[cm->base_qindex] = cpi->prob_skip_false;
4296 #if 0 && CONFIG_INTERNAL_STATS
4298 FILE *f = fopen("tmp.stt", "a");
4300 vp8_clear_system_state(); //__asm emms;
4302 if (cpi->twopass.total_coded_error_left != 0.0)
4303 fprintf(f, "%10d %10d %10d %10d %10d %10d %10d %10d %6d %6d"
4304 "%6d %6d %6d %5d %5d %5d %8d %8.2f %10d %10.3f"
4306 cpi->common.current_video_frame, cpi->this_frame_target,
4307 cpi->projected_frame_size,
4308 (cpi->projected_frame_size - cpi->this_frame_target),
4309 (int)cpi->total_target_vs_actual,
4310 (cpi->oxcf.starting_buffer_level-cpi->bits_off_target),
4311 (int)cpi->total_actual_bits, cm->base_qindex,
4312 cpi->active_best_quality, cpi->active_worst_quality,
4313 cpi->ni_av_qi, cpi->cq_target_quality, cpi->zbin_over_quant,
4314 //cpi->avg_frame_qindex, cpi->zbin_over_quant,
4315 cm->refresh_golden_frame, cm->refresh_alt_ref_frame,
4316 cm->frame_type, cpi->gfu_boost,
4317 cpi->twopass.est_max_qcorrection_factor, (int)cpi->twopass.bits_left,
4318 cpi->twopass.total_coded_error_left,
4319 (double)cpi->twopass.bits_left / cpi->twopass.total_coded_error_left,
4320 cpi->tot_recode_hits);
4322 fprintf(f, "%10d %10d %10d %10d %10d %10d %10d %10d %6d %6d"
4323 "%6d %6d %6d %5d %5d %5d %8d %8.2f %10d %10.3f"
4325 cpi->common.current_video_frame,
4326 cpi->this_frame_target, cpi->projected_frame_size,
4327 (cpi->projected_frame_size - cpi->this_frame_target),
4328 (int)cpi->total_target_vs_actual,
4329 (cpi->oxcf.starting_buffer_level-cpi->bits_off_target),
4330 (int)cpi->total_actual_bits, cm->base_qindex,
4331 cpi->active_best_quality, cpi->active_worst_quality,
4332 cpi->ni_av_qi, cpi->cq_target_quality, cpi->zbin_over_quant,
4333 //cpi->avg_frame_qindex, cpi->zbin_over_quant,
4334 cm->refresh_golden_frame, cm->refresh_alt_ref_frame,
4335 cm->frame_type, cpi->gfu_boost,
4336 cpi->twopass.est_max_qcorrection_factor, (int)cpi->twopass.bits_left,
4337 cpi->twopass.total_coded_error_left, cpi->tot_recode_hits);
4342 FILE *fmodes = fopen("Modes.stt", "a");
4345 fprintf(fmodes, "%6d:%1d:%1d:%1d ",
4346 cpi->common.current_video_frame,
4347 cm->frame_type, cm->refresh_golden_frame,
4348 cm->refresh_alt_ref_frame);
4350 for (i = 0; i < MAX_MODES; i++)
4351 fprintf(fmodes, "%5d ", cpi->mode_chosen_counts[i]);
4353 fprintf(fmodes, "\n");
4361 // If this was a kf or Gf note the Q
4362 if ((cm->frame_type == KEY_FRAME) || cm->refresh_golden_frame || cm->refresh_alt_ref_frame)
4363 cm->last_kf_gf_q = cm->base_qindex;
4365 if (cm->refresh_golden_frame == 1)
4366 cm->frame_flags = cm->frame_flags | FRAMEFLAGS_GOLDEN;
4368 cm->frame_flags = cm->frame_flags&~FRAMEFLAGS_GOLDEN;
4370 if (cm->refresh_alt_ref_frame == 1)
4371 cm->frame_flags = cm->frame_flags | FRAMEFLAGS_ALTREF;
4373 cm->frame_flags = cm->frame_flags&~FRAMEFLAGS_ALTREF;
4376 if (cm->refresh_last_frame & cm->refresh_golden_frame) // both refreshed
4377 cpi->gold_is_last = 1;
4378 else if (cm->refresh_last_frame ^ cm->refresh_golden_frame) // 1 refreshed but not the other
4379 cpi->gold_is_last = 0;
4381 if (cm->refresh_last_frame & cm->refresh_alt_ref_frame) // both refreshed
4382 cpi->alt_is_last = 1;
4383 else if (cm->refresh_last_frame ^ cm->refresh_alt_ref_frame) // 1 refreshed but not the other
4384 cpi->alt_is_last = 0;
4386 if (cm->refresh_alt_ref_frame & cm->refresh_golden_frame) // both refreshed
4387 cpi->gold_is_alt = 1;
4388 else if (cm->refresh_alt_ref_frame ^ cm->refresh_golden_frame) // 1 refreshed but not the other
4389 cpi->gold_is_alt = 0;
4391 cpi->ref_frame_flags = VP8_ALT_FLAG | VP8_GOLD_FLAG | VP8_LAST_FLAG;
4393 if (cpi->gold_is_last)
4394 cpi->ref_frame_flags &= ~VP8_GOLD_FLAG;
4396 if (cpi->alt_is_last)
4397 cpi->ref_frame_flags &= ~VP8_ALT_FLAG;
4399 if (cpi->gold_is_alt)
4400 cpi->ref_frame_flags &= ~VP8_ALT_FLAG;
4403 if (!cpi->oxcf.error_resilient_mode)
4405 if (cpi->oxcf.play_alternate && cm->refresh_alt_ref_frame && (cm->frame_type != KEY_FRAME))
4406 // Update the alternate reference frame stats as appropriate.
4407 update_alt_ref_frame_stats(cpi);
4409 // Update the Golden frame stats as appropriate.
4410 update_golden_frame_stats(cpi);
4413 if (cm->frame_type == KEY_FRAME)
4415 // Tell the caller that the frame was coded as a key frame
4416 *frame_flags = cm->frame_flags | FRAMEFLAGS_KEY;
4418 // As this frame is a key frame the next defaults to an inter frame.
4419 cm->frame_type = INTER_FRAME;
4421 cpi->last_frame_percent_intra = 100;
4425 *frame_flags = cm->frame_flags&~FRAMEFLAGS_KEY;
4427 cpi->last_frame_percent_intra = cpi->this_frame_percent_intra;
4430 // Clear the one shot update flags for segmentation map and mode/ref loop filter deltas.
4431 cpi->mb.e_mbd.update_mb_segmentation_map = 0;
4432 cpi->mb.e_mbd.update_mb_segmentation_data = 0;
4433 cpi->mb.e_mbd.mode_ref_lf_delta_update = 0;
4436 // Dont increment frame counters if this was an altref buffer update not a real frame
4439 cm->current_video_frame++;
4440 cpi->frames_since_key++;
4443 // reset to normal state now that we are done.
4451 sprintf(filename, "enc%04d.yuv", (int) cm->current_video_frame);
4452 recon_file = fopen(filename, "wb");
4453 fwrite(cm->yv12_fb[cm->lst_fb_idx].buffer_alloc,
4454 cm->yv12_fb[cm->lst_fb_idx].frame_size, 1, recon_file);
4460 //vp8_write_yuv_frame("encoder_recon.yuv", cm->frame_to_show);
4466 static void check_gf_quality(VP8_COMP *cpi)
4468 VP8_COMMON *cm = &cpi->common;
4469 int gf_active_pct = (100 * cpi->gf_active_count) / (cm->mb_rows * cm->mb_cols);
4470 int gf_ref_usage_pct = (cpi->count_mb_ref_frame_usage[GOLDEN_FRAME] * 100) / (cm->mb_rows * cm->mb_cols);
4471 int last_ref_zz_useage = (cpi->inter_zz_count * 100) / (cm->mb_rows * cm->mb_cols);
4473 // Gf refresh is not currently being signalled
4474 if (cpi->gf_update_recommended == 0)
4476 if (cpi->common.frames_since_golden > 7)
4479 if ((gf_active_pct < 10) || ((gf_active_pct + gf_ref_usage_pct) < 15))
4481 // ...but last frame zero zero usage is reasonbable so a new gf might be appropriate
4482 if (last_ref_zz_useage >= 25)
4484 cpi->gf_bad_count ++;
4486 if (cpi->gf_bad_count >= 8) // Check that the condition is stable
4488 cpi->gf_update_recommended = 1;
4489 cpi->gf_bad_count = 0;
4493 cpi->gf_bad_count = 0; // Restart count as the background is not stable enough
4496 cpi->gf_bad_count = 0; // Gf useage has picked up so reset count
4499 // If the signal is set but has not been read should we cancel it.
4500 else if (last_ref_zz_useage < 15)
4502 cpi->gf_update_recommended = 0;
4503 cpi->gf_bad_count = 0;
4508 FILE *f = fopen("gfneeded.stt", "a");
4509 fprintf(f, "%10d %10d %10d %10d %10ld \n",
4510 cm->current_video_frame,
4511 cpi->common.frames_since_golden,
4512 gf_active_pct, gf_ref_usage_pct,
4513 cpi->gf_update_recommended);
4520 #if !(CONFIG_REALTIME_ONLY)
4521 static void Pass2Encode(VP8_COMP *cpi, unsigned long *size, unsigned char *dest, unsigned int *frame_flags)
4524 if (!cpi->common.refresh_alt_ref_frame)
4525 vp8_second_pass(cpi);
4527 encode_frame_to_data_rate(cpi, size, dest, frame_flags);
4528 cpi->twopass.bits_left -= 8 * *size;
4530 if (!cpi->common.refresh_alt_ref_frame)
4532 double two_pass_min_rate = (double)(cpi->oxcf.target_bandwidth
4533 *cpi->oxcf.two_pass_vbrmin_section / 100);
4534 cpi->twopass.bits_left += (long long)(two_pass_min_rate / cpi->oxcf.frame_rate);
4539 //For ARM NEON, d8-d15 are callee-saved registers, and need to be saved by us.
4541 extern void vp8_push_neon(INT64 *store);
4542 extern void vp8_pop_neon(INT64 *store);
4546 int vp8_receive_raw_frame(VP8_PTR ptr, unsigned int frame_flags, YV12_BUFFER_CONFIG *sd, INT64 time_stamp, INT64 end_time)
4551 VP8_COMP *cpi = (VP8_COMP *) ptr;
4552 VP8_COMMON *cm = &cpi->common;
4553 struct vpx_usec_timer timer;
4557 #if CONFIG_RUNTIME_CPU_DETECT
4558 if (cm->rtcd.flags & HAS_NEON)
4561 vp8_push_neon(store_reg);
4565 vpx_usec_timer_start(&timer);
4566 if(vp8_lookahead_push(cpi->lookahead, sd, time_stamp, end_time,
4569 cm->clr_type = sd->clrtype;
4570 vpx_usec_timer_mark(&timer);
4571 cpi->time_receive_data += vpx_usec_timer_elapsed(&timer);
4574 #if CONFIG_RUNTIME_CPU_DETECT
4575 if (cm->rtcd.flags & HAS_NEON)
4578 vp8_pop_neon(store_reg);
4586 int vp8_get_compressed_data(VP8_PTR ptr, unsigned int *frame_flags, unsigned long *size, unsigned char *dest, INT64 *time_stamp, INT64 *time_end, int flush)
4591 VP8_COMP *cpi = (VP8_COMP *) ptr;
4592 VP8_COMMON *cm = &cpi->common;
4593 struct vpx_usec_timer tsctimer;
4594 struct vpx_usec_timer ticktimer;
4595 struct vpx_usec_timer cmptimer;
4596 YV12_BUFFER_CONFIG *force_src_buffer = NULL;
4602 #if CONFIG_RUNTIME_CPU_DETECT
4603 if (cm->rtcd.flags & HAS_NEON)
4606 vp8_push_neon(store_reg);
4610 vpx_usec_timer_start(&cmptimer);
4614 #if !(CONFIG_REALTIME_ONLY)
4615 // Should we code an alternate reference frame
4616 if (cpi->oxcf.error_resilient_mode == 0 &&
4617 cpi->oxcf.play_alternate &&
4618 cpi->source_alt_ref_pending)
4620 if ((cpi->source = vp8_lookahead_peek(cpi->lookahead,
4621 cpi->frames_till_gf_update_due)))
4623 cpi->alt_ref_source = cpi->source;
4624 if (cpi->oxcf.arnr_max_frames > 0)
4626 vp8_temporal_filter_prepare_c(cpi,
4627 cpi->frames_till_gf_update_due);
4628 force_src_buffer = &cpi->alt_ref_buffer;
4630 cm->frames_till_alt_ref_frame = cpi->frames_till_gf_update_due;
4631 cm->refresh_alt_ref_frame = 1;
4632 cm->refresh_golden_frame = 0;
4633 cm->refresh_last_frame = 0;
4635 cpi->source_alt_ref_pending = FALSE; // Clear Pending altf Ref flag.
4636 cpi->is_src_frame_alt_ref = 0;
4643 if ((cpi->source = vp8_lookahead_pop(cpi->lookahead, flush)))
4647 cpi->is_src_frame_alt_ref = cpi->alt_ref_source
4648 && (cpi->source == cpi->alt_ref_source);
4650 if(cpi->is_src_frame_alt_ref)
4651 cpi->alt_ref_source = NULL;
4657 cpi->un_scaled_source =
4658 cpi->Source = force_src_buffer ? force_src_buffer : &cpi->source->img;
4659 *time_stamp = cpi->source->ts_start;
4660 *time_end = cpi->source->ts_end;
4661 *frame_flags = cpi->source->flags;
4666 #if !(CONFIG_REALTIME_ONLY)
4668 if (flush && cpi->pass == 1 && !cpi->twopass.first_pass_done)
4670 vp8_end_first_pass(cpi); /* get last stats packet */
4671 cpi->twopass.first_pass_done = 1;
4677 #if CONFIG_RUNTIME_CPU_DETECT
4678 if (cm->rtcd.flags & HAS_NEON)
4681 vp8_pop_neon(store_reg);
4687 if (cpi->source->ts_start < cpi->first_time_stamp_ever)
4689 cpi->first_time_stamp_ever = cpi->source->ts_start;
4690 cpi->last_end_time_stamp_seen = cpi->source->ts_start;
4693 // adjust frame rates based on timestamps given
4694 if (!cm->refresh_alt_ref_frame)
4696 long long this_duration;
4699 if (cpi->source->ts_start == cpi->first_time_stamp_ever)
4701 this_duration = cpi->source->ts_end - cpi->source->ts_start;
4706 long long last_duration;
4708 this_duration = cpi->source->ts_end - cpi->last_end_time_stamp_seen;
4709 last_duration = cpi->last_end_time_stamp_seen
4710 - cpi->last_time_stamp_seen;
4711 // do a step update if the duration changes by 10%
4713 step = ((this_duration - last_duration) * 10 / last_duration);
4719 vp8_new_frame_rate(cpi, 10000000.0 / this_duration);
4722 double avg_duration, interval;
4724 /* Average this frame's rate into the last second's average
4725 * frame rate. If we haven't seen 1 second yet, then average
4726 * over the whole interval seen.
4728 interval = cpi->source->ts_end - cpi->first_time_stamp_ever;
4729 if(interval > 10000000.0)
4730 interval = 10000000;
4732 avg_duration = 10000000.0 / cpi->oxcf.frame_rate;
4733 avg_duration *= (interval - avg_duration + this_duration);
4734 avg_duration /= interval;
4736 vp8_new_frame_rate(cpi, 10000000.0 / avg_duration);
4740 cpi->last_time_stamp_seen = cpi->source->ts_start;
4741 cpi->last_end_time_stamp_seen = cpi->source->ts_end;
4744 if (cpi->compressor_speed == 2)
4746 check_gf_quality(cpi);
4747 vpx_usec_timer_start(&tsctimer);
4748 vpx_usec_timer_start(&ticktimer);
4751 // start with a 0 size frame
4754 // Clear down mmx registers
4755 vp8_clear_system_state(); //__asm emms;
4757 cm->frame_type = INTER_FRAME;
4758 cm->frame_flags = *frame_flags;
4762 if (cm->refresh_alt_ref_frame)
4764 //cm->refresh_golden_frame = 1;
4765 cm->refresh_golden_frame = 0;
4766 cm->refresh_last_frame = 0;
4770 cm->refresh_golden_frame = 0;
4771 cm->refresh_last_frame = 1;
4775 /* find a free buffer for the new frame */
4778 for(; i < NUM_YV12_BUFFERS; i++)
4780 if(!cm->yv12_fb[i].flags)
4787 assert(i < NUM_YV12_BUFFERS );
4789 #if !(CONFIG_REALTIME_ONLY)
4793 Pass1Encode(cpi, size, dest, frame_flags);
4795 else if (cpi->pass == 2)
4797 Pass2Encode(cpi, size, dest, frame_flags);
4801 encode_frame_to_data_rate(cpi, size, dest, frame_flags);
4803 if (cpi->compressor_speed == 2)
4805 unsigned int duration, duration2;
4806 vpx_usec_timer_mark(&tsctimer);
4807 vpx_usec_timer_mark(&ticktimer);
4809 duration = vpx_usec_timer_elapsed(&ticktimer);
4810 duration2 = (unsigned int)((double)duration / 2);
4812 if (cm->frame_type != KEY_FRAME)
4814 if (cpi->avg_encode_time == 0)
4815 cpi->avg_encode_time = duration;
4817 cpi->avg_encode_time = (7 * cpi->avg_encode_time + duration) >> 3;
4822 //if(*frame_flags!=1)
4825 if (cpi->avg_pick_mode_time == 0)
4826 cpi->avg_pick_mode_time = duration2;
4828 cpi->avg_pick_mode_time = (7 * cpi->avg_pick_mode_time + duration2) >> 3;
4834 if (cm->refresh_entropy_probs == 0)
4836 vpx_memcpy(&cm->fc, &cm->lfc, sizeof(cm->fc));
4839 // if its a dropped frame honor the requests on subsequent frames
4843 // return to normal state
4844 cm->refresh_entropy_probs = 1;
4845 cm->refresh_alt_ref_frame = 0;
4846 cm->refresh_golden_frame = 0;
4847 cm->refresh_last_frame = 1;
4848 cm->frame_type = INTER_FRAME;
4852 vpx_usec_timer_mark(&cmptimer);
4853 cpi->time_compress_data += vpx_usec_timer_elapsed(&cmptimer);
4855 if (cpi->b_calculate_psnr && cpi->pass != 1 && cm->show_frame)
4857 generate_psnr_packet(cpi);
4860 #if CONFIG_INTERNAL_STATS
4864 cpi->bytes += *size;
4871 if (cpi->b_calculate_psnr)
4875 YV12_BUFFER_CONFIG *orig = cpi->Source;
4876 YV12_BUFFER_CONFIG *recon = cpi->common.frame_to_show;
4877 YV12_BUFFER_CONFIG *pp = &cm->post_proc_buffer;
4878 int y_samples = orig->y_height * orig->y_width ;
4879 int uv_samples = orig->uv_height * orig->uv_width ;
4880 int t_samples = y_samples + 2 * uv_samples;
4883 ye = calc_plane_error(orig->y_buffer, orig->y_stride,
4884 recon->y_buffer, recon->y_stride, orig->y_width, orig->y_height,
4885 IF_RTCD(&cpi->rtcd.variance));
4887 ue = calc_plane_error(orig->u_buffer, orig->uv_stride,
4888 recon->u_buffer, recon->uv_stride, orig->uv_width, orig->uv_height,
4889 IF_RTCD(&cpi->rtcd.variance));
4891 ve = calc_plane_error(orig->v_buffer, orig->uv_stride,
4892 recon->v_buffer, recon->uv_stride, orig->uv_width, orig->uv_height,
4893 IF_RTCD(&cpi->rtcd.variance));
4895 sq_error = ye + ue + ve;
4897 frame_psnr = vp8_mse2psnr(t_samples, 255.0, sq_error);
4899 cpi->total_y += vp8_mse2psnr(y_samples, 255.0, ye);
4900 cpi->total_u += vp8_mse2psnr(uv_samples, 255.0, ue);
4901 cpi->total_v += vp8_mse2psnr(uv_samples, 255.0, ve);
4902 cpi->total_sq_error += sq_error;
4903 cpi->total += frame_psnr;
4905 double frame_psnr2, frame_ssim2 = 0;
4908 vp8_deblock(cm->frame_to_show, &cm->post_proc_buffer, cm->filter_level * 10 / 6, 1, 0, IF_RTCD(&cm->rtcd.postproc));
4909 vp8_clear_system_state();
4911 ye = calc_plane_error(orig->y_buffer, orig->y_stride,
4912 pp->y_buffer, pp->y_stride, orig->y_width, orig->y_height,
4913 IF_RTCD(&cpi->rtcd.variance));
4915 ue = calc_plane_error(orig->u_buffer, orig->uv_stride,
4916 pp->u_buffer, pp->uv_stride, orig->uv_width, orig->uv_height,
4917 IF_RTCD(&cpi->rtcd.variance));
4919 ve = calc_plane_error(orig->v_buffer, orig->uv_stride,
4920 pp->v_buffer, pp->uv_stride, orig->uv_width, orig->uv_height,
4921 IF_RTCD(&cpi->rtcd.variance));
4923 sq_error = ye + ue + ve;
4925 frame_psnr2 = vp8_mse2psnr(t_samples, 255.0, sq_error);
4927 cpi->totalp_y += vp8_mse2psnr(y_samples, 255.0, ye);
4928 cpi->totalp_u += vp8_mse2psnr(uv_samples, 255.0, ue);
4929 cpi->totalp_v += vp8_mse2psnr(uv_samples, 255.0, ve);
4930 cpi->total_sq_error2 += sq_error;
4931 cpi->totalp += frame_psnr2;
4933 frame_ssim2 = vp8_calc_ssim(cpi->Source,
4934 &cm->post_proc_buffer, 1, &weight,
4935 IF_RTCD(&cpi->rtcd.variance));
4937 cpi->summed_quality += frame_ssim2 * weight;
4938 cpi->summed_weights += weight;
4943 if (cpi->b_calculate_ssimg)
4945 double y, u, v, frame_all;
4946 frame_all = vp8_calc_ssimg(cpi->Source, cm->frame_to_show,
4947 &y, &u, &v, IF_RTCD(&cpi->rtcd.variance));
4948 cpi->total_ssimg_y += y;
4949 cpi->total_ssimg_u += u;
4950 cpi->total_ssimg_v += v;
4951 cpi->total_ssimg_all += frame_all;
4959 if (cpi->common.frame_type != 0 && cpi->common.base_qindex == cpi->oxcf.worst_allowed_q)
4961 skiptruecount += cpi->skip_true_count;
4962 skipfalsecount += cpi->skip_false_count;
4970 FILE *f = fopen("skip.stt", "a");
4971 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);
4973 if (cpi->is_src_frame_alt_ref == 1)
4974 fprintf(f, "skipcount: %4d framesize: %d\n", cpi->skip_true_count , *size);
4983 #if CONFIG_RUNTIME_CPU_DETECT
4984 if (cm->rtcd.flags & HAS_NEON)
4987 vp8_pop_neon(store_reg);
4994 int vp8_get_preview_raw_frame(VP8_PTR comp, YV12_BUFFER_CONFIG *dest, vp8_ppflags_t *flags)
4996 VP8_COMP *cpi = (VP8_COMP *) comp;
4998 if (cpi->common.refresh_alt_ref_frame)
5004 ret = vp8_post_proc_frame(&cpi->common, dest, flags);
5007 if (cpi->common.frame_to_show)
5009 *dest = *cpi->common.frame_to_show;
5010 dest->y_width = cpi->common.Width;
5011 dest->y_height = cpi->common.Height;
5012 dest->uv_height = cpi->common.Height / 2;
5020 #endif //!CONFIG_POSTPROC
5021 vp8_clear_system_state();
5026 int vp8_set_roimap(VP8_PTR comp, unsigned char *map, unsigned int rows, unsigned int cols, int delta_q[4], int delta_lf[4], unsigned int threshold[4])
5028 VP8_COMP *cpi = (VP8_COMP *) comp;
5029 signed char feature_data[MB_LVL_MAX][MAX_MB_SEGMENTS];
5031 if (cpi->common.mb_rows != rows || cpi->common.mb_cols != cols)
5036 disable_segmentation((VP8_PTR)cpi);
5040 // Set the segmentation Map
5041 set_segmentation_map((VP8_PTR)cpi, map);
5043 // Activate segmentation.
5044 enable_segmentation((VP8_PTR)cpi);
5046 // Set up the quant segment data
5047 feature_data[MB_LVL_ALT_Q][0] = delta_q[0];
5048 feature_data[MB_LVL_ALT_Q][1] = delta_q[1];
5049 feature_data[MB_LVL_ALT_Q][2] = delta_q[2];
5050 feature_data[MB_LVL_ALT_Q][3] = delta_q[3];
5052 // Set up the loop segment data s
5053 feature_data[MB_LVL_ALT_LF][0] = delta_lf[0];
5054 feature_data[MB_LVL_ALT_LF][1] = delta_lf[1];
5055 feature_data[MB_LVL_ALT_LF][2] = delta_lf[2];
5056 feature_data[MB_LVL_ALT_LF][3] = delta_lf[3];
5058 cpi->segment_encode_breakout[0] = threshold[0];
5059 cpi->segment_encode_breakout[1] = threshold[1];
5060 cpi->segment_encode_breakout[2] = threshold[2];
5061 cpi->segment_encode_breakout[3] = threshold[3];
5063 // Initialise the feature data structure
5064 // SEGMENT_DELTADATA 0, SEGMENT_ABSDATA 1
5065 set_segment_data((VP8_PTR)cpi, &feature_data[0][0], SEGMENT_DELTADATA);
5070 int vp8_set_active_map(VP8_PTR comp, unsigned char *map, unsigned int rows, unsigned int cols)
5072 VP8_COMP *cpi = (VP8_COMP *) comp;
5074 if (rows == cpi->common.mb_rows && cols == cpi->common.mb_cols)
5078 vpx_memcpy(cpi->active_map, map, rows * cols);
5079 cpi->active_map_enabled = 1;
5082 cpi->active_map_enabled = 0;
5088 //cpi->active_map_enabled = 0;
5093 int vp8_set_internal_size(VP8_PTR comp, VPX_SCALING horiz_mode, VPX_SCALING vert_mode)
5095 VP8_COMP *cpi = (VP8_COMP *) comp;
5097 if (horiz_mode <= ONETWO)
5098 cpi->common.horiz_scale = horiz_mode;
5102 if (vert_mode <= ONETWO)
5103 cpi->common.vert_scale = vert_mode;
5112 int vp8_calc_ss_err(YV12_BUFFER_CONFIG *source, YV12_BUFFER_CONFIG *dest, const vp8_variance_rtcd_vtable_t *rtcd)
5117 unsigned char *src = source->y_buffer;
5118 unsigned char *dst = dest->y_buffer;
5121 // Loop through the Y plane raw and reconstruction data summing (square differences)
5122 for (i = 0; i < source->y_height; i += 16)
5124 for (j = 0; j < source->y_width; j += 16)
5127 Total += VARIANCE_INVOKE(rtcd, mse16x16)(src + j, source->y_stride, dst + j, dest->y_stride, &sse);
5130 src += 16 * source->y_stride;
5131 dst += 16 * dest->y_stride;
5138 int vp8_get_quantizer(VP8_PTR c)
5140 VP8_COMP *cpi = (VP8_COMP *) c;
5141 return cpi->common.base_qindex;