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_init_mv_bits_sadcost();
50 extern void vp8cx_pick_filter_level_fast(YV12_BUFFER_CONFIG *sd, VP8_COMP *cpi);
51 extern void vp8cx_set_alt_lf_level(VP8_COMP *cpi, int filt_val);
52 extern void vp8cx_pick_filter_level(YV12_BUFFER_CONFIG *sd, VP8_COMP *cpi);
54 extern void vp8_init_loop_filter(VP8_COMMON *cm);
55 extern void vp8_loop_filter_frame(VP8_COMMON *cm, MACROBLOCKD *mbd, int filt_val);
56 extern void vp8_loop_filter_frame_yonly(VP8_COMMON *cm, MACROBLOCKD *mbd, int filt_val, int sharpness_lvl);
57 extern void vp8_dmachine_specific_config(VP8_COMP *cpi);
58 extern void vp8_cmachine_specific_config(VP8_COMP *cpi);
59 extern void vp8_deblock_frame(YV12_BUFFER_CONFIG *source, YV12_BUFFER_CONFIG *post, int filt_lvl, int low_var_thresh, int flag);
60 extern void print_parms(VP8_CONFIG *ocf, char *filenam);
61 extern unsigned int vp8_get_processor_freq();
62 extern void print_tree_update_probs();
63 extern void vp8cx_create_encoder_threads(VP8_COMP *cpi);
64 extern void vp8cx_remove_encoder_threads(VP8_COMP *cpi);
66 extern void vp8_yv12_copy_frame_func_neon(YV12_BUFFER_CONFIG *src_ybc, YV12_BUFFER_CONFIG *dst_ybc);
67 extern void vp8_yv12_copy_src_frame_func_neon(YV12_BUFFER_CONFIG *src_ybc, YV12_BUFFER_CONFIG *dst_ybc);
70 int vp8_estimate_entropy_savings(VP8_COMP *cpi);
71 int vp8_calc_ss_err(YV12_BUFFER_CONFIG *source, YV12_BUFFER_CONFIG *dest, const vp8_variance_rtcd_vtable_t *rtcd);
73 extern void vp8_temporal_filter_prepare_c(VP8_COMP *cpi, int distance);
75 static void set_default_lf_deltas(VP8_COMP *cpi);
77 extern const int vp8_gf_interval_table[101];
82 extern double vp8_calc_ssim
84 YV12_BUFFER_CONFIG *source,
85 YV12_BUFFER_CONFIG *dest,
88 const vp8_variance_rtcd_vtable_t *rtcd
92 extern double vp8_calc_ssimg
94 YV12_BUFFER_CONFIG *source,
95 YV12_BUFFER_CONFIG *dest,
99 const vp8_variance_rtcd_vtable_t *rtcd
106 #ifdef OUTPUT_YUV_SRC
117 extern int skip_true_count;
118 extern int skip_false_count;
123 extern int intra_mode_stats[10][10][10];
127 unsigned int frames_at_speed[16] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
128 unsigned int tot_pm = 0;
129 unsigned int cnt_pm = 0;
130 unsigned int tot_ef = 0;
131 unsigned int cnt_ef = 0;
135 extern unsigned __int64 Sectionbits[50];
136 extern int y_modes[5] ;
137 extern int uv_modes[4] ;
138 extern int b_modes[10] ;
140 extern int inter_y_modes[10] ;
141 extern int inter_uv_modes[4] ;
142 extern unsigned int inter_b_modes[15];
145 extern void (*vp8_short_fdct4x4)(short *input, short *output, int pitch);
146 extern void (*vp8_short_fdct8x4)(short *input, short *output, int pitch);
148 extern const int vp8_bits_per_mb[2][QINDEX_RANGE];
150 extern const int qrounding_factors[129];
151 extern const int qzbin_factors[129];
152 extern void vp8cx_init_quantizer(VP8_COMP *cpi);
153 extern const int vp8cx_base_skip_false_prob[128];
155 // Tables relating active max Q to active min Q
156 static const int kf_low_motion_minq[QINDEX_RANGE] =
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,0,0,0,0,0,0,0,0,0,0,0,0,
161 0,0,0,0,1,1,1,1,1,1,1,1,2,2,2,2,
162 3,3,3,3,3,3,4,4,4,5,5,5,5,5,6,6,
163 6,6,7,7,8,8,8,8,9,9,10,10,10,10,11,11,
164 11,11,12,12,13,13,13,13,14,14,15,15,15,15,16,16,
165 16,16,17,17,18,18,18,18,19,20,20,21,21,22,23,23
167 static const int kf_high_motion_minq[QINDEX_RANGE] =
169 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
170 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
171 1,1,1,1,1,1,1,1,2,2,2,2,3,3,3,3,
172 3,3,3,3,4,4,4,4,5,5,5,5,5,5,6,6,
173 6,6,7,7,8,8,8,8,9,9,10,10,10,10,11,11,
174 11,11,12,12,13,13,13,13,14,14,15,15,15,15,16,16,
175 16,16,17,17,18,18,18,18,19,19,20,20,20,20,21,21,
176 21,21,22,22,23,23,24,25,25,26,26,27,28,28,29,30
178 static const int gf_low_motion_minq[QINDEX_RANGE] =
180 0,0,0,0,1,1,1,1,1,1,1,1,2,2,2,2,
181 3,3,3,3,4,4,4,4,5,5,5,5,6,6,6,6,
182 7,7,7,7,8,8,8,8,9,9,9,9,10,10,10,10,
183 11,11,12,12,13,13,14,14,15,15,16,16,17,17,18,18,
184 19,19,20,20,21,21,22,22,23,23,24,24,25,25,26,26,
185 27,27,28,28,29,29,30,30,31,31,32,32,33,33,34,34,
186 35,35,36,36,37,37,38,38,39,39,40,40,41,41,42,42,
187 43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58
189 static const int gf_mid_motion_minq[QINDEX_RANGE] =
191 0,0,0,0,1,1,1,1,1,1,2,2,3,3,3,4,
192 4,4,5,5,5,6,6,6,7,7,7,8,8,8,9,9,
193 9,10,10,10,10,11,11,11,12,12,12,12,13,13,13,14,
194 14,14,15,15,16,16,17,17,18,18,19,19,20,20,21,21,
195 22,22,23,23,24,24,25,25,26,26,27,27,28,28,29,29,
196 30,30,31,31,32,32,33,33,34,34,35,35,36,36,37,37,
197 38,39,39,40,40,41,41,42,42,43,43,44,45,46,47,48,
198 49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64
200 static const int gf_high_motion_minq[QINDEX_RANGE] =
202 0,0,0,0,1,1,1,1,1,2,2,2,3,3,3,4,
203 4,4,5,5,5,6,6,6,7,7,7,8,8,8,9,9,
204 9,10,10,10,11,11,12,12,13,13,14,14,15,15,16,16,
205 17,17,18,18,19,19,20,20,21,21,22,22,23,23,24,24,
206 25,25,26,26,27,27,28,28,29,29,30,30,31,31,32,32,
207 33,33,34,34,35,35,36,36,37,37,38,38,39,39,40,40,
208 41,41,42,42,43,44,45,46,47,48,49,50,51,52,53,54,
209 55,56,57,58,59,60,62,64,66,68,70,72,74,76,78,80
211 static const int inter_minq[QINDEX_RANGE] =
213 0,0,1,1,2,3,3,4,4,5,6,6,7,8,8,9,
214 9,10,11,11,12,13,13,14,15,15,16,17,17,18,19,20,
215 20,21,22,22,23,24,24,25,26,27,27,28,29,30,30,31,
216 32,33,33,34,35,36,36,37,38,39,39,40,41,42,42,43,
217 44,45,46,46,47,48,49,50,50,51,52,53,54,55,55,56,
218 57,58,59,60,60,61,62,63,64,65,66,67,67,68,69,70,
219 71,72,73,74,75,75,76,77,78,79,80,81,82,83,84,85,
220 86,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100
223 void vp8_initialize()
225 static int init_done = 0;
229 vp8_scale_machine_specific_config();
230 vp8_initialize_common();
231 //vp8_dmachine_specific_config();
232 vp8_tokenize_initialize();
234 vp8cx_init_mv_bits_sadcost();
238 #ifdef PACKET_TESTING
239 extern FILE *vpxlogc;
242 static void setup_features(VP8_COMP *cpi)
244 // Set up default state for MB feature flags
245 cpi->mb.e_mbd.segmentation_enabled = 0;
246 cpi->mb.e_mbd.update_mb_segmentation_map = 0;
247 cpi->mb.e_mbd.update_mb_segmentation_data = 0;
248 vpx_memset(cpi->mb.e_mbd.mb_segment_tree_probs, 255, sizeof(cpi->mb.e_mbd.mb_segment_tree_probs));
249 vpx_memset(cpi->mb.e_mbd.segment_feature_data, 0, sizeof(cpi->mb.e_mbd.segment_feature_data));
251 cpi->mb.e_mbd.mode_ref_lf_delta_enabled = 0;
252 cpi->mb.e_mbd.mode_ref_lf_delta_update = 0;
253 vpx_memset(cpi->mb.e_mbd.ref_lf_deltas, 0, sizeof(cpi->mb.e_mbd.ref_lf_deltas));
254 vpx_memset(cpi->mb.e_mbd.mode_lf_deltas, 0, sizeof(cpi->mb.e_mbd.mode_lf_deltas));
255 vpx_memset(cpi->mb.e_mbd.last_ref_lf_deltas, 0, sizeof(cpi->mb.e_mbd.ref_lf_deltas));
256 vpx_memset(cpi->mb.e_mbd.last_mode_lf_deltas, 0, sizeof(cpi->mb.e_mbd.mode_lf_deltas));
258 set_default_lf_deltas(cpi);
263 static void dealloc_compressor_data(VP8_COMP *cpi)
265 vpx_free(cpi->tplist);
268 // Delete last frame MV storage buffers
272 vpx_free(cpi->lf_ref_frame_sign_bias);
273 cpi->lf_ref_frame_sign_bias = 0;
275 vpx_free(cpi->lf_ref_frame);
276 cpi->lf_ref_frame = 0;
278 // Delete sementation map
279 vpx_free(cpi->segmentation_map);
280 cpi->segmentation_map = 0;
282 vpx_free(cpi->active_map);
285 vp8_de_alloc_frame_buffers(&cpi->common);
287 vp8_yv12_de_alloc_frame_buffer(&cpi->last_frame_uf);
288 vp8_yv12_de_alloc_frame_buffer(&cpi->scaled_source);
289 #if VP8_TEMPORAL_ALT_REF
290 vp8_yv12_de_alloc_frame_buffer(&cpi->alt_ref_buffer);
292 vp8_lookahead_destroy(cpi->lookahead);
297 // Structure used to monitor GF usage
298 vpx_free(cpi->gf_active_flags);
299 cpi->gf_active_flags = 0;
301 // Activity mask based per mb zbin adjustments
302 vpx_free(cpi->mb_activity_map);
303 cpi->mb_activity_map = 0;
304 vpx_free(cpi->mb_norm_activity_map);
305 cpi->mb_norm_activity_map = 0;
307 vpx_free(cpi->mb.pip);
310 #if !(CONFIG_REALTIME_ONLY)
311 vpx_free(cpi->total_stats);
312 cpi->total_stats = 0;
314 vpx_free(cpi->this_frame_stats);
315 cpi->this_frame_stats = 0;
319 static void enable_segmentation(VP8_PTR ptr)
321 VP8_COMP *cpi = (VP8_COMP *)(ptr);
323 // Set the appropriate feature bit
324 cpi->mb.e_mbd.segmentation_enabled = 1;
325 cpi->mb.e_mbd.update_mb_segmentation_map = 1;
326 cpi->mb.e_mbd.update_mb_segmentation_data = 1;
328 static void disable_segmentation(VP8_PTR ptr)
330 VP8_COMP *cpi = (VP8_COMP *)(ptr);
332 // Clear the appropriate feature bit
333 cpi->mb.e_mbd.segmentation_enabled = 0;
336 // Valid values for a segment are 0 to 3
337 // Segmentation map is arrange as [Rows][Columns]
338 static void set_segmentation_map(VP8_PTR ptr, unsigned char *segmentation_map)
340 VP8_COMP *cpi = (VP8_COMP *)(ptr);
342 // Copy in the new segmentation map
343 vpx_memcpy(cpi->segmentation_map, segmentation_map, (cpi->common.mb_rows * cpi->common.mb_cols));
345 // Signal that the map should be updated.
346 cpi->mb.e_mbd.update_mb_segmentation_map = 1;
347 cpi->mb.e_mbd.update_mb_segmentation_data = 1;
350 // The values given for each segment can be either deltas (from the default value chosen for the frame) or absolute values.
352 // Valid range for abs values is (0-127 for MB_LVL_ALT_Q) , (0-63 for SEGMENT_ALT_LF)
353 // Valid range for delta values are (+/-127 for MB_LVL_ALT_Q) , (+/-63 for SEGMENT_ALT_LF)
355 // abs_delta = SEGMENT_DELTADATA (deltas) abs_delta = SEGMENT_ABSDATA (use the absolute values given).
358 static void set_segment_data(VP8_PTR ptr, signed char *feature_data, unsigned char abs_delta)
360 VP8_COMP *cpi = (VP8_COMP *)(ptr);
362 cpi->mb.e_mbd.mb_segement_abs_delta = abs_delta;
363 vpx_memcpy(cpi->segment_feature_data, feature_data, sizeof(cpi->segment_feature_data));
367 static void segmentation_test_function(VP8_PTR ptr)
369 VP8_COMP *cpi = (VP8_COMP *)(ptr);
371 unsigned char *seg_map;
372 signed char feature_data[MB_LVL_MAX][MAX_MB_SEGMENTS];
374 // Create a temporary map for segmentation data.
375 CHECK_MEM_ERROR(seg_map, vpx_calloc(cpi->common.mb_rows * cpi->common.mb_cols, 1));
377 // MB loop to set local segmentation map
378 /*for ( i = 0; i < cpi->common.mb_rows; i++ )
380 for ( j = 0; j < cpi->common.mb_cols; j++ )
382 //seg_map[(i*cpi->common.mb_cols) + j] = (j % 2) + ((i%2)* 2);
383 //if ( j < cpi->common.mb_cols/2 )
385 // Segment 1 around the edge else 0
386 if ( (i == 0) || (j == 0) || (i == (cpi->common.mb_rows-1)) || (j == (cpi->common.mb_cols-1)) )
387 seg_map[(i*cpi->common.mb_cols) + j] = 1;
388 //else if ( (i < 2) || (j < 2) || (i > (cpi->common.mb_rows-3)) || (j > (cpi->common.mb_cols-3)) )
389 // seg_map[(i*cpi->common.mb_cols) + j] = 2;
390 //else if ( (i < 5) || (j < 5) || (i > (cpi->common.mb_rows-6)) || (j > (cpi->common.mb_cols-6)) )
391 // seg_map[(i*cpi->common.mb_cols) + j] = 3;
393 seg_map[(i*cpi->common.mb_cols) + j] = 0;
397 // Set the segmentation Map
398 set_segmentation_map(ptr, seg_map);
400 // Activate segmentation.
401 enable_segmentation(ptr);
403 // Set up the quant segment data
404 feature_data[MB_LVL_ALT_Q][0] = 0;
405 feature_data[MB_LVL_ALT_Q][1] = 4;
406 feature_data[MB_LVL_ALT_Q][2] = 0;
407 feature_data[MB_LVL_ALT_Q][3] = 0;
408 // Set up the loop segment data
409 feature_data[MB_LVL_ALT_LF][0] = 0;
410 feature_data[MB_LVL_ALT_LF][1] = 0;
411 feature_data[MB_LVL_ALT_LF][2] = 0;
412 feature_data[MB_LVL_ALT_LF][3] = 0;
414 // Initialise the feature data structure
415 // SEGMENT_DELTADATA 0, SEGMENT_ABSDATA 1
416 set_segment_data(ptr, &feature_data[0][0], SEGMENT_DELTADATA);
418 // Delete sementation map
425 // A simple function to cyclically refresh the background at a lower Q
426 static void cyclic_background_refresh(VP8_COMP *cpi, int Q, int lf_adjustment)
428 unsigned char *seg_map;
429 signed char feature_data[MB_LVL_MAX][MAX_MB_SEGMENTS];
431 int block_count = cpi->cyclic_refresh_mode_max_mbs_perframe;
432 int mbs_in_frame = cpi->common.mb_rows * cpi->common.mb_cols;
434 // Create a temporary map for segmentation data.
435 CHECK_MEM_ERROR(seg_map, vpx_calloc(cpi->common.mb_rows * cpi->common.mb_cols, 1));
437 cpi->cyclic_refresh_q = Q;
439 for (i = Q; i > 0; i--)
441 if (vp8_bits_per_mb[cpi->common.frame_type][i] >= ((vp8_bits_per_mb[cpi->common.frame_type][Q]*(Q + 128)) / 64))
442 //if ( vp8_bits_per_mb[cpi->common.frame_type][i] >= ((vp8_bits_per_mb[cpi->common.frame_type][Q]*((2*Q)+96))/64) )
448 cpi->cyclic_refresh_q = i;
450 // Only update for inter frames
451 if (cpi->common.frame_type != KEY_FRAME)
453 // Cycle through the macro_block rows
454 // MB loop to set local segmentation map
455 for (i = cpi->cyclic_refresh_mode_index; i < mbs_in_frame; i++)
457 // If the MB is as a candidate for clean up then mark it for possible boost/refresh (segment 1)
458 // The segment id may get reset to 0 later if the MB gets coded anything other than last frame 0,0
459 // as only (last frame 0,0) MBs are eligable for refresh : that is to say Mbs likely to be background blocks.
460 if (cpi->cyclic_refresh_map[i] == 0)
468 // Skip blocks that have been refreshed recently anyway.
469 if (cpi->cyclic_refresh_map[i] < 0)
470 //cpi->cyclic_refresh_map[i] = cpi->cyclic_refresh_map[i] / 16;
471 cpi->cyclic_refresh_map[i]++;
482 // If we have gone through the frame reset to the start
483 cpi->cyclic_refresh_mode_index = i;
485 if (cpi->cyclic_refresh_mode_index >= mbs_in_frame)
486 cpi->cyclic_refresh_mode_index = 0;
489 // Set the segmentation Map
490 set_segmentation_map((VP8_PTR)cpi, seg_map);
492 // Activate segmentation.
493 enable_segmentation((VP8_PTR)cpi);
495 // Set up the quant segment data
496 feature_data[MB_LVL_ALT_Q][0] = 0;
497 feature_data[MB_LVL_ALT_Q][1] = (cpi->cyclic_refresh_q - Q);
498 feature_data[MB_LVL_ALT_Q][2] = 0;
499 feature_data[MB_LVL_ALT_Q][3] = 0;
501 // Set up the loop segment data
502 feature_data[MB_LVL_ALT_LF][0] = 0;
503 feature_data[MB_LVL_ALT_LF][1] = lf_adjustment;
504 feature_data[MB_LVL_ALT_LF][2] = 0;
505 feature_data[MB_LVL_ALT_LF][3] = 0;
507 // Initialise the feature data structure
508 // SEGMENT_DELTADATA 0, SEGMENT_ABSDATA 1
509 set_segment_data((VP8_PTR)cpi, &feature_data[0][0], SEGMENT_DELTADATA);
511 // Delete sementation map
518 static void set_default_lf_deltas(VP8_COMP *cpi)
520 cpi->mb.e_mbd.mode_ref_lf_delta_enabled = 1;
521 cpi->mb.e_mbd.mode_ref_lf_delta_update = 1;
523 vpx_memset(cpi->mb.e_mbd.ref_lf_deltas, 0, sizeof(cpi->mb.e_mbd.ref_lf_deltas));
524 vpx_memset(cpi->mb.e_mbd.mode_lf_deltas, 0, sizeof(cpi->mb.e_mbd.mode_lf_deltas));
526 // Test of ref frame deltas
527 cpi->mb.e_mbd.ref_lf_deltas[INTRA_FRAME] = 2;
528 cpi->mb.e_mbd.ref_lf_deltas[LAST_FRAME] = 0;
529 cpi->mb.e_mbd.ref_lf_deltas[GOLDEN_FRAME] = -2;
530 cpi->mb.e_mbd.ref_lf_deltas[ALTREF_FRAME] = -2;
532 cpi->mb.e_mbd.mode_lf_deltas[0] = 4; // BPRED
533 cpi->mb.e_mbd.mode_lf_deltas[1] = -2; // Zero
534 cpi->mb.e_mbd.mode_lf_deltas[2] = 2; // New mv
535 cpi->mb.e_mbd.mode_lf_deltas[3] = 4; // Split mv
538 void vp8_set_speed_features(VP8_COMP *cpi)
540 SPEED_FEATURES *sf = &cpi->sf;
541 int Mode = cpi->compressor_speed;
542 int Speed = cpi->Speed;
544 VP8_COMMON *cm = &cpi->common;
545 int last_improved_quant = sf->improved_quant;
547 // Initialise default mode frequency sampling variables
548 for (i = 0; i < MAX_MODES; i ++)
550 cpi->mode_check_freq[i] = 0;
551 cpi->mode_test_hit_counts[i] = 0;
552 cpi->mode_chosen_counts[i] = 0;
555 cpi->mbs_tested_so_far = 0;
557 // best quality defaults
559 sf->search_method = NSTEP;
560 sf->improved_quant = 1;
561 sf->improved_dct = 1;
564 sf->quarter_pixel_search = 1;
565 sf->half_pixel_search = 1;
566 sf->full_freq[0] = 7;
567 sf->full_freq[1] = 7;
568 sf->min_fs_radius = 8;
569 sf->max_fs_radius = 32;
570 sf->iterative_sub_pixel = 1;
571 sf->optimize_coefficients = 1;
572 sf->use_fastquant_for_pick = 0;
573 sf->no_skip_block4x4_search = 1;
576 sf->max_step_search_steps = MAX_MVSEARCH_STEPS;
577 sf->improved_mv_pred = 1;
579 // default thresholds to 0
580 for (i = 0; i < MAX_MODES; i++)
581 sf->thresh_mult[i] = 0;
585 #if !(CONFIG_REALTIME_ONLY)
586 case 0: // best quality mode
587 sf->thresh_mult[THR_ZEROMV ] = 0;
588 sf->thresh_mult[THR_ZEROG ] = 0;
589 sf->thresh_mult[THR_ZEROA ] = 0;
590 sf->thresh_mult[THR_NEARESTMV] = 0;
591 sf->thresh_mult[THR_NEARESTG ] = 0;
592 sf->thresh_mult[THR_NEARESTA ] = 0;
593 sf->thresh_mult[THR_NEARMV ] = 0;
594 sf->thresh_mult[THR_NEARG ] = 0;
595 sf->thresh_mult[THR_NEARA ] = 0;
597 sf->thresh_mult[THR_DC ] = 0;
599 sf->thresh_mult[THR_V_PRED ] = 1000;
600 sf->thresh_mult[THR_H_PRED ] = 1000;
601 sf->thresh_mult[THR_B_PRED ] = 2000;
602 sf->thresh_mult[THR_TM ] = 1000;
604 sf->thresh_mult[THR_NEWMV ] = 1000;
605 sf->thresh_mult[THR_NEWG ] = 1000;
606 sf->thresh_mult[THR_NEWA ] = 1000;
608 sf->thresh_mult[THR_SPLITMV ] = 2500;
609 sf->thresh_mult[THR_SPLITG ] = 5000;
610 sf->thresh_mult[THR_SPLITA ] = 5000;
612 sf->full_freq[0] = 7;
613 sf->full_freq[1] = 15;
616 sf->max_step_search_steps = MAX_MVSEARCH_STEPS;
620 sf->thresh_mult[THR_NEARESTMV] = 0;
621 sf->thresh_mult[THR_ZEROMV ] = 0;
622 sf->thresh_mult[THR_DC ] = 0;
623 sf->thresh_mult[THR_NEARMV ] = 0;
624 sf->thresh_mult[THR_V_PRED ] = 1000;
625 sf->thresh_mult[THR_H_PRED ] = 1000;
626 sf->thresh_mult[THR_B_PRED ] = 2500;
627 sf->thresh_mult[THR_TM ] = 1000;
629 sf->thresh_mult[THR_NEARESTG ] = 1000;
630 sf->thresh_mult[THR_NEARESTA ] = 1000;
632 sf->thresh_mult[THR_ZEROG ] = 1000;
633 sf->thresh_mult[THR_ZEROA ] = 1000;
634 sf->thresh_mult[THR_NEARG ] = 1000;
635 sf->thresh_mult[THR_NEARA ] = 1000;
638 sf->thresh_mult[THR_ZEROMV ] = 0;
639 sf->thresh_mult[THR_ZEROG ] = 0;
640 sf->thresh_mult[THR_ZEROA ] = 0;
641 sf->thresh_mult[THR_NEARESTMV] = 0;
642 sf->thresh_mult[THR_NEARESTG ] = 0;
643 sf->thresh_mult[THR_NEARESTA ] = 0;
644 sf->thresh_mult[THR_NEARMV ] = 0;
645 sf->thresh_mult[THR_NEARG ] = 0;
646 sf->thresh_mult[THR_NEARA ] = 0;
648 // sf->thresh_mult[THR_DC ] = 0;
650 // sf->thresh_mult[THR_V_PRED ] = 1000;
651 // sf->thresh_mult[THR_H_PRED ] = 1000;
652 // sf->thresh_mult[THR_B_PRED ] = 2000;
653 // sf->thresh_mult[THR_TM ] = 1000;
655 sf->thresh_mult[THR_NEWMV ] = 1000;
656 sf->thresh_mult[THR_NEWG ] = 1000;
657 sf->thresh_mult[THR_NEWA ] = 1000;
659 sf->thresh_mult[THR_SPLITMV ] = 1700;
660 sf->thresh_mult[THR_SPLITG ] = 4500;
661 sf->thresh_mult[THR_SPLITA ] = 4500;
663 sf->thresh_mult[THR_NEWMV ] = 1500;
664 sf->thresh_mult[THR_NEWG ] = 1500;
665 sf->thresh_mult[THR_NEWA ] = 1500;
667 sf->thresh_mult[THR_SPLITMV ] = 5000;
668 sf->thresh_mult[THR_SPLITG ] = 10000;
669 sf->thresh_mult[THR_SPLITA ] = 10000;
671 sf->full_freq[0] = 15;
672 sf->full_freq[1] = 31;
676 /* Disable coefficient optimization above speed 0 */
677 sf->optimize_coefficients = 0;
678 sf->use_fastquant_for_pick = 1;
679 sf->no_skip_block4x4_search = 0;
683 cpi->mode_check_freq[THR_SPLITG] = 2;
684 cpi->mode_check_freq[THR_SPLITA] = 2;
685 cpi->mode_check_freq[THR_SPLITMV] = 0;
690 cpi->mode_check_freq[THR_SPLITG] = 4;
691 cpi->mode_check_freq[THR_SPLITA] = 4;
692 cpi->mode_check_freq[THR_SPLITMV] = 2;
694 sf->thresh_mult[THR_TM ] = 1500;
695 sf->thresh_mult[THR_V_PRED ] = 1500;
696 sf->thresh_mult[THR_H_PRED ] = 1500;
697 sf->thresh_mult[THR_B_PRED ] = 5000;
699 if (cpi->ref_frame_flags & VP8_LAST_FLAG)
701 sf->thresh_mult[THR_NEWMV ] = 2000;
702 sf->thresh_mult[THR_SPLITMV ] = 10000;
705 if (cpi->ref_frame_flags & VP8_GOLD_FLAG)
707 sf->thresh_mult[THR_NEARESTG ] = 1500;
708 sf->thresh_mult[THR_ZEROG ] = 1500;
709 sf->thresh_mult[THR_NEARG ] = 1500;
710 sf->thresh_mult[THR_NEWG ] = 2000;
711 sf->thresh_mult[THR_SPLITG ] = 20000;
714 if (cpi->ref_frame_flags & VP8_ALT_FLAG)
716 sf->thresh_mult[THR_NEARESTA ] = 1500;
717 sf->thresh_mult[THR_ZEROA ] = 1500;
718 sf->thresh_mult[THR_NEARA ] = 1500;
719 sf->thresh_mult[THR_NEWA ] = 2000;
720 sf->thresh_mult[THR_SPLITA ] = 20000;
726 cpi->mode_check_freq[THR_SPLITG] = 15;
727 cpi->mode_check_freq[THR_SPLITA] = 15;
728 cpi->mode_check_freq[THR_SPLITMV] = 7;
730 sf->thresh_mult[THR_TM ] = 2000;
731 sf->thresh_mult[THR_V_PRED ] = 2000;
732 sf->thresh_mult[THR_H_PRED ] = 2000;
733 sf->thresh_mult[THR_B_PRED ] = 7500;
735 if (cpi->ref_frame_flags & VP8_LAST_FLAG)
737 sf->thresh_mult[THR_NEWMV ] = 2000;
738 sf->thresh_mult[THR_SPLITMV ] = 25000;
741 if (cpi->ref_frame_flags & VP8_GOLD_FLAG)
743 sf->thresh_mult[THR_NEARESTG ] = 2000;
744 sf->thresh_mult[THR_ZEROG ] = 2000;
745 sf->thresh_mult[THR_NEARG ] = 2000;
746 sf->thresh_mult[THR_NEWG ] = 2500;
747 sf->thresh_mult[THR_SPLITG ] = 50000;
750 if (cpi->ref_frame_flags & VP8_ALT_FLAG)
752 sf->thresh_mult[THR_NEARESTA ] = 2000;
753 sf->thresh_mult[THR_ZEROA ] = 2000;
754 sf->thresh_mult[THR_NEARA ] = 2000;
755 sf->thresh_mult[THR_NEWA ] = 2500;
756 sf->thresh_mult[THR_SPLITA ] = 50000;
759 sf->improved_quant = 0;
760 sf->improved_dct = 0;
762 // Only do recode loop on key frames, golden frames and
766 sf->full_freq[0] = 31;
767 sf->full_freq[1] = 63;
772 sf->thresh_mult[THR_SPLITA ] = INT_MAX;
773 sf->thresh_mult[THR_SPLITG ] = INT_MAX;
774 sf->thresh_mult[THR_SPLITMV ] = INT_MAX;
776 cpi->mode_check_freq[THR_V_PRED] = 0;
777 cpi->mode_check_freq[THR_H_PRED] = 0;
778 cpi->mode_check_freq[THR_B_PRED] = 0;
779 cpi->mode_check_freq[THR_NEARG] = 0;
780 cpi->mode_check_freq[THR_NEWG] = 0;
781 cpi->mode_check_freq[THR_NEARA] = 0;
782 cpi->mode_check_freq[THR_NEWA] = 0;
785 sf->recode_loop = 0; // recode loop off
786 sf->RD = 0; // Turn rd off
788 sf->full_freq[0] = 63;
789 sf->full_freq[1] = 127;
794 sf->auto_filter = 0; // Faster selection of loop filter
795 sf->full_freq[0] = INT_MAX;
796 sf->full_freq[1] = INT_MAX;
798 cpi->mode_check_freq[THR_V_PRED] = 2;
799 cpi->mode_check_freq[THR_H_PRED] = 2;
800 cpi->mode_check_freq[THR_B_PRED] = 2;
802 if (cpi->ref_frame_flags & VP8_GOLD_FLAG)
804 cpi->mode_check_freq[THR_NEARG] = 2;
805 cpi->mode_check_freq[THR_NEWG] = 4;
808 if (cpi->ref_frame_flags & VP8_ALT_FLAG)
810 cpi->mode_check_freq[THR_NEARA] = 2;
811 cpi->mode_check_freq[THR_NEWA] = 4;
814 if (cpi->ref_frame_flags & VP8_GOLD_FLAG)
816 sf->thresh_mult[THR_NEARESTG ] = 2000;
817 sf->thresh_mult[THR_ZEROG ] = 2000;
818 sf->thresh_mult[THR_NEARG ] = 2000;
819 sf->thresh_mult[THR_NEWG ] = 4000;
822 if (cpi->ref_frame_flags & VP8_ALT_FLAG)
824 sf->thresh_mult[THR_NEARESTA ] = 2000;
825 sf->thresh_mult[THR_ZEROA ] = 2000;
826 sf->thresh_mult[THR_NEARA ] = 2000;
827 sf->thresh_mult[THR_NEWA ] = 4000;
834 sf->optimize_coefficients = 0;
837 sf->iterative_sub_pixel = 1;
838 sf->thresh_mult[THR_NEARESTMV] = 0;
839 sf->thresh_mult[THR_ZEROMV ] = 0;
840 sf->thresh_mult[THR_DC ] = 0;
841 sf->thresh_mult[THR_TM ] = 0;
842 sf->thresh_mult[THR_NEARMV ] = 0;
843 sf->thresh_mult[THR_V_PRED ] = 1000;
844 sf->thresh_mult[THR_H_PRED ] = 1000;
845 sf->thresh_mult[THR_B_PRED ] = 2500;
846 sf->thresh_mult[THR_NEARESTG ] = 1000;
847 sf->thresh_mult[THR_ZEROG ] = 1000;
848 sf->thresh_mult[THR_NEARG ] = 1000;
849 sf->thresh_mult[THR_NEARESTA ] = 1000;
850 sf->thresh_mult[THR_ZEROA ] = 1000;
851 sf->thresh_mult[THR_NEARA ] = 1000;
852 sf->thresh_mult[THR_NEWMV ] = 2000;
853 sf->thresh_mult[THR_NEWG ] = 2000;
854 sf->thresh_mult[THR_NEWA ] = 2000;
855 sf->thresh_mult[THR_SPLITMV ] = 5000;
856 sf->thresh_mult[THR_SPLITG ] = 10000;
857 sf->thresh_mult[THR_SPLITA ] = 10000;
858 sf->full_freq[0] = 15;
859 sf->full_freq[1] = 31;
860 sf->search_method = NSTEP;
864 cpi->mode_check_freq[THR_SPLITG] = 4;
865 cpi->mode_check_freq[THR_SPLITA] = 4;
866 cpi->mode_check_freq[THR_SPLITMV] = 2;
868 sf->thresh_mult[THR_DC ] = 0;
869 sf->thresh_mult[THR_TM ] = 1000;
870 sf->thresh_mult[THR_V_PRED ] = 2000;
871 sf->thresh_mult[THR_H_PRED ] = 2000;
872 sf->thresh_mult[THR_B_PRED ] = 5000;
874 if (cpi->ref_frame_flags & VP8_LAST_FLAG)
876 sf->thresh_mult[THR_NEARESTMV] = 0;
877 sf->thresh_mult[THR_ZEROMV ] = 0;
878 sf->thresh_mult[THR_NEARMV ] = 0;
879 sf->thresh_mult[THR_NEWMV ] = 2000;
880 sf->thresh_mult[THR_SPLITMV ] = 10000;
883 if (cpi->ref_frame_flags & VP8_GOLD_FLAG)
885 sf->thresh_mult[THR_NEARESTG ] = 1000;
886 sf->thresh_mult[THR_ZEROG ] = 1000;
887 sf->thresh_mult[THR_NEARG ] = 1000;
888 sf->thresh_mult[THR_NEWG ] = 2000;
889 sf->thresh_mult[THR_SPLITG ] = 20000;
892 if (cpi->ref_frame_flags & VP8_ALT_FLAG)
894 sf->thresh_mult[THR_NEARESTA ] = 1000;
895 sf->thresh_mult[THR_ZEROA ] = 1000;
896 sf->thresh_mult[THR_NEARA ] = 1000;
897 sf->thresh_mult[THR_NEWA ] = 2000;
898 sf->thresh_mult[THR_SPLITA ] = 20000;
901 sf->improved_quant = 0;
902 sf->improved_dct = 0;
907 cpi->mode_check_freq[THR_SPLITMV] = 7;
908 cpi->mode_check_freq[THR_SPLITG] = 15;
909 cpi->mode_check_freq[THR_SPLITA] = 15;
911 sf->thresh_mult[THR_TM ] = 2000;
912 sf->thresh_mult[THR_V_PRED ] = 2000;
913 sf->thresh_mult[THR_H_PRED ] = 2000;
914 sf->thresh_mult[THR_B_PRED ] = 5000;
916 if (cpi->ref_frame_flags & VP8_LAST_FLAG)
918 sf->thresh_mult[THR_NEWMV ] = 2000;
919 sf->thresh_mult[THR_SPLITMV ] = 25000;
922 if (cpi->ref_frame_flags & VP8_GOLD_FLAG)
924 sf->thresh_mult[THR_NEARESTG ] = 2000;
925 sf->thresh_mult[THR_ZEROG ] = 2000;
926 sf->thresh_mult[THR_NEARG ] = 2000;
927 sf->thresh_mult[THR_NEWG ] = 2500;
928 sf->thresh_mult[THR_SPLITG ] = 50000;
931 if (cpi->ref_frame_flags & VP8_ALT_FLAG)
933 sf->thresh_mult[THR_NEARESTA ] = 2000;
934 sf->thresh_mult[THR_ZEROA ] = 2000;
935 sf->thresh_mult[THR_NEARA ] = 2000;
936 sf->thresh_mult[THR_NEWA ] = 2500;
937 sf->thresh_mult[THR_SPLITA ] = 50000;
940 sf->full_freq[0] = 31;
941 sf->full_freq[1] = 63;
946 sf->auto_filter = 0; // Faster selection of loop filter
948 cpi->mode_check_freq[THR_V_PRED] = 2;
949 cpi->mode_check_freq[THR_H_PRED] = 2;
950 cpi->mode_check_freq[THR_B_PRED] = 2;
952 if (cpi->ref_frame_flags & VP8_GOLD_FLAG)
954 cpi->mode_check_freq[THR_NEARG] = 2;
955 cpi->mode_check_freq[THR_NEWG] = 4;
958 if (cpi->ref_frame_flags & VP8_ALT_FLAG)
960 cpi->mode_check_freq[THR_NEARA] = 2;
961 cpi->mode_check_freq[THR_NEWA] = 4;
964 sf->thresh_mult[THR_SPLITMV ] = INT_MAX;
965 sf->thresh_mult[THR_SPLITG ] = INT_MAX;
966 sf->thresh_mult[THR_SPLITA ] = INT_MAX;
968 sf->full_freq[0] = 63;
969 sf->full_freq[1] = 127;
975 sf->full_freq[0] = INT_MAX;
976 sf->full_freq[1] = INT_MAX;
983 sf->auto_filter = 0; // Faster selection of loop filter
985 #if CONFIG_REALTIME_ONLY
986 sf->search_method = HEX;
988 sf->search_method = DIAMOND;
990 sf->iterative_sub_pixel = 0;
992 cpi->mode_check_freq[THR_V_PRED] = 4;
993 cpi->mode_check_freq[THR_H_PRED] = 4;
994 cpi->mode_check_freq[THR_B_PRED] = 4;
996 if (cpi->ref_frame_flags & VP8_GOLD_FLAG)
998 cpi->mode_check_freq[THR_NEARG] = 2;
999 cpi->mode_check_freq[THR_NEWG] = 4;
1002 if (cpi->ref_frame_flags & VP8_ALT_FLAG)
1004 cpi->mode_check_freq[THR_NEARA] = 2;
1005 cpi->mode_check_freq[THR_NEWA] = 4;
1008 sf->thresh_mult[THR_TM ] = 2000;
1009 sf->thresh_mult[THR_B_PRED ] = 5000;
1011 if (cpi->ref_frame_flags & VP8_GOLD_FLAG)
1013 sf->thresh_mult[THR_NEARESTG ] = 2000;
1014 sf->thresh_mult[THR_ZEROG ] = 2000;
1015 sf->thresh_mult[THR_NEARG ] = 2000;
1016 sf->thresh_mult[THR_NEWG ] = 4000;
1019 if (cpi->ref_frame_flags & VP8_ALT_FLAG)
1021 sf->thresh_mult[THR_NEARESTA ] = 2000;
1022 sf->thresh_mult[THR_ZEROA ] = 2000;
1023 sf->thresh_mult[THR_NEARA ] = 2000;
1024 sf->thresh_mult[THR_NEWA ] = 4000;
1030 // Disable split MB intra prediction mode
1031 sf->thresh_mult[THR_B_PRED] = INT_MAX;
1036 unsigned int i, sum = 0;
1037 unsigned int total_mbs = cm->MBs;
1043 if (cpi->oxcf.encode_breakout > 2000)
1044 min = cpi->oxcf.encode_breakout;
1048 for (i = 0; i < min; i++)
1050 sum += cpi->error_bins[i];
1056 // i starts from 2 to make sure thresh started from 2048
1057 for (; i < 1024; i++)
1059 sum += cpi->error_bins[i];
1061 if (10 * sum >= (unsigned int)(cpi->Speed - 6)*(total_mbs - total_skip))
1071 if (cpi->ref_frame_flags & VP8_LAST_FLAG)
1073 sf->thresh_mult[THR_NEWMV] = thresh;
1074 sf->thresh_mult[THR_NEARESTMV ] = thresh >> 1;
1075 sf->thresh_mult[THR_NEARMV ] = thresh >> 1;
1078 if (cpi->ref_frame_flags & VP8_GOLD_FLAG)
1080 sf->thresh_mult[THR_NEWG] = thresh << 1;
1081 sf->thresh_mult[THR_NEARESTG ] = thresh;
1082 sf->thresh_mult[THR_NEARG ] = thresh;
1085 if (cpi->ref_frame_flags & VP8_ALT_FLAG)
1087 sf->thresh_mult[THR_NEWA] = thresh << 1;
1088 sf->thresh_mult[THR_NEARESTA ] = thresh;
1089 sf->thresh_mult[THR_NEARA ] = thresh;
1092 // Disable other intra prediction modes
1093 sf->thresh_mult[THR_TM] = INT_MAX;
1094 sf->thresh_mult[THR_V_PRED] = INT_MAX;
1095 sf->thresh_mult[THR_H_PRED] = INT_MAX;
1097 sf->improved_mv_pred = 0;
1102 sf->quarter_pixel_search = 0;
1107 int Tmp = cpi->Speed - 8;
1112 if (cpi->ref_frame_flags & VP8_GOLD_FLAG)
1114 cpi->mode_check_freq[THR_ZEROG] = 1 << (Tmp - 1);
1115 cpi->mode_check_freq[THR_NEARESTG] = 1 << (Tmp - 1);
1116 cpi->mode_check_freq[THR_NEARG] = 1 << Tmp;
1117 cpi->mode_check_freq[THR_NEWG] = 1 << (Tmp + 1);
1120 if (cpi->ref_frame_flags & VP8_ALT_FLAG)
1122 cpi->mode_check_freq[THR_ZEROA] = 1 << (Tmp - 1);
1123 cpi->mode_check_freq[THR_NEARESTA] = 1 << (Tmp - 1);
1124 cpi->mode_check_freq[THR_NEARA] = 1 << Tmp;
1125 cpi->mode_check_freq[THR_NEWA] = 1 << (Tmp + 1);
1128 cpi->mode_check_freq[THR_NEWMV] = 1 << (Tmp - 1);
1131 cm->filter_type = NORMAL_LOOPFILTER;
1134 cm->filter_type = SIMPLE_LOOPFILTER;
1138 sf->half_pixel_search = 0; // This has a big hit on quality. Last resort
1141 vpx_memset(cpi->error_bins, 0, sizeof(cpi->error_bins));
1145 /* disable frame modes if flags not set */
1146 if (!(cpi->ref_frame_flags & VP8_LAST_FLAG))
1148 sf->thresh_mult[THR_NEWMV ] = INT_MAX;
1149 sf->thresh_mult[THR_NEARESTMV] = INT_MAX;
1150 sf->thresh_mult[THR_ZEROMV ] = INT_MAX;
1151 sf->thresh_mult[THR_NEARMV ] = INT_MAX;
1152 sf->thresh_mult[THR_SPLITMV ] = INT_MAX;
1155 if (!(cpi->ref_frame_flags & VP8_GOLD_FLAG))
1157 sf->thresh_mult[THR_NEARESTG ] = INT_MAX;
1158 sf->thresh_mult[THR_ZEROG ] = INT_MAX;
1159 sf->thresh_mult[THR_NEARG ] = INT_MAX;
1160 sf->thresh_mult[THR_NEWG ] = INT_MAX;
1161 sf->thresh_mult[THR_SPLITG ] = INT_MAX;
1164 if (!(cpi->ref_frame_flags & VP8_ALT_FLAG))
1166 sf->thresh_mult[THR_NEARESTA ] = INT_MAX;
1167 sf->thresh_mult[THR_ZEROA ] = INT_MAX;
1168 sf->thresh_mult[THR_NEARA ] = INT_MAX;
1169 sf->thresh_mult[THR_NEWA ] = INT_MAX;
1170 sf->thresh_mult[THR_SPLITA ] = INT_MAX;
1174 // Slow quant, dct and trellis not worthwhile for first pass
1175 // so make sure they are always turned off.
1176 if ( cpi->pass == 1 )
1178 sf->improved_quant = 0;
1179 sf->optimize_coefficients = 0;
1180 sf->improved_dct = 0;
1183 if (cpi->sf.search_method == NSTEP)
1185 vp8_init3smotion_compensation(&cpi->mb, cm->yv12_fb[cm->lst_fb_idx].y_stride);
1187 else if (cpi->sf.search_method == DIAMOND)
1189 vp8_init_dsmotion_compensation(&cpi->mb, cm->yv12_fb[cm->lst_fb_idx].y_stride);
1192 if (cpi->sf.improved_dct)
1194 cpi->mb.vp8_short_fdct8x4 = FDCT_INVOKE(&cpi->rtcd.fdct, short8x4);
1195 cpi->mb.vp8_short_fdct4x4 = FDCT_INVOKE(&cpi->rtcd.fdct, short4x4);
1199 cpi->mb.vp8_short_fdct8x4 = FDCT_INVOKE(&cpi->rtcd.fdct, fast8x4);
1200 cpi->mb.vp8_short_fdct4x4 = FDCT_INVOKE(&cpi->rtcd.fdct, fast4x4);
1203 cpi->mb.short_walsh4x4 = FDCT_INVOKE(&cpi->rtcd.fdct, walsh_short4x4);
1205 if (cpi->sf.improved_quant)
1207 cpi->mb.quantize_b = QUANTIZE_INVOKE(&cpi->rtcd.quantize, quantb);
1211 cpi->mb.quantize_b = QUANTIZE_INVOKE(&cpi->rtcd.quantize, fastquantb);
1213 if (cpi->sf.improved_quant != last_improved_quant)
1214 vp8cx_init_quantizer(cpi);
1216 #if CONFIG_RUNTIME_CPU_DETECT
1217 cpi->mb.e_mbd.rtcd = &cpi->common.rtcd;
1220 if (cpi->sf.iterative_sub_pixel == 1)
1222 cpi->find_fractional_mv_step = vp8_find_best_sub_pixel_step_iteratively;
1224 else if (cpi->sf.quarter_pixel_search)
1226 cpi->find_fractional_mv_step = vp8_find_best_sub_pixel_step;
1228 else if (cpi->sf.half_pixel_search)
1230 cpi->find_fractional_mv_step = vp8_find_best_half_pixel_step;
1234 cpi->find_fractional_mv_step = vp8_skip_fractional_mv_step;
1237 if (cpi->sf.optimize_coefficients == 1)
1238 cpi->mb.optimize = 1;
1240 cpi->mb.optimize = 0;
1242 if (cpi->common.full_pixel)
1243 cpi->find_fractional_mv_step = vp8_skip_fractional_mv_step;
1246 frames_at_speed[cpi->Speed]++;
1249 static void alloc_raw_frame_buffers(VP8_COMP *cpi)
1251 int width = (cpi->oxcf.Width + 15) & ~15;
1252 int height = (cpi->oxcf.Height + 15) & ~15;
1254 cpi->lookahead = vp8_lookahead_init(cpi->oxcf.Width, cpi->oxcf.Height,
1255 cpi->oxcf.lag_in_frames);
1257 vpx_internal_error(&cpi->common.error, VPX_CODEC_MEM_ERROR,
1258 "Failed to allocate lag buffers");
1260 #if VP8_TEMPORAL_ALT_REF
1262 if (vp8_yv12_alloc_frame_buffer(&cpi->alt_ref_buffer,
1264 vpx_internal_error(&cpi->common.error, VPX_CODEC_MEM_ERROR,
1265 "Failed to allocate altref buffer");
1270 static int vp8_alloc_partition_data(VP8_COMP *cpi)
1272 vpx_free(cpi->mb.pip);
1274 cpi->mb.pip = vpx_calloc((cpi->common.mb_cols + 1) *
1275 (cpi->common.mb_rows + 1),
1276 sizeof(PARTITION_INFO));
1280 cpi->mb.pi = cpi->mb.pip + cpi->common.mode_info_stride + 1;
1285 void vp8_alloc_compressor_data(VP8_COMP *cpi)
1287 VP8_COMMON *cm = & cpi->common;
1289 int width = cm->Width;
1290 int height = cm->Height;
1292 if (vp8_alloc_frame_buffers(cm, width, height))
1293 vpx_internal_error(&cpi->common.error, VPX_CODEC_MEM_ERROR,
1294 "Failed to allocate frame buffers");
1296 if (vp8_alloc_partition_data(cpi))
1297 vpx_internal_error(&cpi->common.error, VPX_CODEC_MEM_ERROR,
1298 "Failed to allocate partition data");
1301 if ((width & 0xf) != 0)
1302 width += 16 - (width & 0xf);
1304 if ((height & 0xf) != 0)
1305 height += 16 - (height & 0xf);
1308 if (vp8_yv12_alloc_frame_buffer(&cpi->last_frame_uf,
1309 width, height, VP8BORDERINPIXELS))
1310 vpx_internal_error(&cpi->common.error, VPX_CODEC_MEM_ERROR,
1311 "Failed to allocate last frame buffer");
1313 if (vp8_yv12_alloc_frame_buffer(&cpi->scaled_source, width, height, 16))
1314 vpx_internal_error(&cpi->common.error, VPX_CODEC_MEM_ERROR,
1315 "Failed to allocate scaled source buffer");
1321 unsigned int tokens = cm->mb_rows * cm->mb_cols * 24 * 16;
1323 CHECK_MEM_ERROR(cpi->tok, vpx_calloc(tokens, sizeof(*cpi->tok)));
1326 // Data used for real time vc mode to see if gf needs refreshing
1327 cpi->inter_zz_count = 0;
1328 cpi->gf_bad_count = 0;
1329 cpi->gf_update_recommended = 0;
1332 // Structures used to minitor GF usage
1333 vpx_free(cpi->gf_active_flags);
1334 CHECK_MEM_ERROR(cpi->gf_active_flags,
1335 vpx_calloc(1, cm->mb_rows * cm->mb_cols));
1336 cpi->gf_active_count = cm->mb_rows * cm->mb_cols;
1338 vpx_free(cpi->mb_activity_map);
1339 CHECK_MEM_ERROR(cpi->mb_activity_map,
1340 vpx_calloc(sizeof(unsigned int),
1341 cm->mb_rows * cm->mb_cols));
1343 vpx_free(cpi->mb_norm_activity_map);
1344 CHECK_MEM_ERROR(cpi->mb_norm_activity_map,
1345 vpx_calloc(sizeof(unsigned int),
1346 cm->mb_rows * cm->mb_cols));
1348 #if !(CONFIG_REALTIME_ONLY)
1349 vpx_free(cpi->total_stats);
1351 cpi->total_stats = vpx_calloc(1, sizeof(FIRSTPASS_STATS));
1353 vpx_free(cpi->this_frame_stats);
1355 cpi->this_frame_stats = vpx_calloc(1, sizeof(FIRSTPASS_STATS));
1357 if(!cpi->total_stats || !cpi->this_frame_stats)
1358 vpx_internal_error(&cpi->common.error, VPX_CODEC_MEM_ERROR,
1359 "Failed to allocate firstpass stats");
1362 #if CONFIG_MULTITHREAD
1364 cpi->mt_sync_range = 1;
1365 else if (width <= 1280)
1366 cpi->mt_sync_range = 4;
1367 else if (width <= 2560)
1368 cpi->mt_sync_range = 8;
1370 cpi->mt_sync_range = 16;
1373 vpx_free(cpi->tplist);
1375 CHECK_MEM_ERROR(cpi->tplist, vpx_malloc(sizeof(TOKENLIST) * cpi->common.mb_rows));
1380 static const int q_trans[] =
1382 0, 1, 2, 3, 4, 5, 7, 8,
1383 9, 10, 12, 13, 15, 17, 18, 19,
1384 20, 21, 23, 24, 25, 26, 27, 28,
1385 29, 30, 31, 33, 35, 37, 39, 41,
1386 43, 45, 47, 49, 51, 53, 55, 57,
1387 59, 61, 64, 67, 70, 73, 76, 79,
1388 82, 85, 88, 91, 94, 97, 100, 103,
1389 106, 109, 112, 115, 118, 121, 124, 127,
1392 int vp8_reverse_trans(int x)
1396 for (i = 0; i < 64; i++)
1397 if (q_trans[i] >= x)
1402 void vp8_new_frame_rate(VP8_COMP *cpi, double framerate)
1407 cpi->oxcf.frame_rate = framerate;
1408 cpi->output_frame_rate = cpi->oxcf.frame_rate;
1409 cpi->per_frame_bandwidth = (int)(cpi->oxcf.target_bandwidth / cpi->output_frame_rate);
1410 cpi->av_per_frame_bandwidth = (int)(cpi->oxcf.target_bandwidth / cpi->output_frame_rate);
1411 cpi->min_frame_bandwidth = (int)(cpi->av_per_frame_bandwidth * cpi->oxcf.two_pass_vbrmin_section / 100);
1413 // Set Maximum gf/arf interval
1414 cpi->max_gf_interval = ((int)(cpi->output_frame_rate / 2.0) + 2);
1416 if(cpi->max_gf_interval < 12)
1417 cpi->max_gf_interval = 12;
1419 // Extended interval for genuinely static scenes
1420 cpi->static_scene_max_gf_interval = cpi->key_frame_frequency >> 1;
1422 // Special conditions when altr ref frame enabled in lagged compress mode
1423 if (cpi->oxcf.play_alternate && cpi->oxcf.lag_in_frames)
1425 if (cpi->max_gf_interval > cpi->oxcf.lag_in_frames - 1)
1426 cpi->max_gf_interval = cpi->oxcf.lag_in_frames - 1;
1428 if (cpi->static_scene_max_gf_interval > cpi->oxcf.lag_in_frames - 1)
1429 cpi->static_scene_max_gf_interval = cpi->oxcf.lag_in_frames - 1;
1432 if ( cpi->max_gf_interval > cpi->static_scene_max_gf_interval )
1433 cpi->max_gf_interval = cpi->static_scene_max_gf_interval;
1438 rescale(int val, int num, int denom)
1440 int64_t llnum = num;
1441 int64_t llden = denom;
1442 int64_t llval = val;
1444 return llval * llnum / llden;
1448 static void init_config(VP8_PTR ptr, VP8_CONFIG *oxcf)
1450 VP8_COMP *cpi = (VP8_COMP *)(ptr);
1451 VP8_COMMON *cm = &cpi->common;
1456 cpi->auto_adjust_gold_quantizer = 1;
1459 cm->version = oxcf->Version;
1460 vp8_setup_version(cm);
1462 // change includes all joint functionality
1463 vp8_change_config(ptr, oxcf);
1465 // Initialize active best and worst q and average q values.
1466 cpi->active_worst_quality = cpi->oxcf.worst_allowed_q;
1467 cpi->active_best_quality = cpi->oxcf.best_allowed_q;
1468 cpi->avg_frame_qindex = cpi->oxcf.worst_allowed_q;
1470 // Initialise the starting buffer levels
1471 cpi->buffer_level = cpi->oxcf.starting_buffer_level;
1472 cpi->bits_off_target = cpi->oxcf.starting_buffer_level;
1474 cpi->rolling_target_bits = cpi->av_per_frame_bandwidth;
1475 cpi->rolling_actual_bits = cpi->av_per_frame_bandwidth;
1476 cpi->long_rolling_target_bits = cpi->av_per_frame_bandwidth;
1477 cpi->long_rolling_actual_bits = cpi->av_per_frame_bandwidth;
1479 cpi->total_actual_bits = 0;
1480 cpi->total_target_vs_actual = 0;
1482 #if VP8_TEMPORAL_ALT_REF
1486 cpi->fixed_divide[0] = 0;
1488 for (i = 1; i < 512; i++)
1489 cpi->fixed_divide[i] = 0x80000 / i;
1495 void vp8_change_config(VP8_PTR ptr, VP8_CONFIG *oxcf)
1497 VP8_COMP *cpi = (VP8_COMP *)(ptr);
1498 VP8_COMMON *cm = &cpi->common;
1506 if (cm->version != oxcf->Version)
1508 cm->version = oxcf->Version;
1509 vp8_setup_version(cm);
1514 switch (cpi->oxcf.Mode)
1519 cpi->compressor_speed = 2;
1521 if (cpi->oxcf.cpu_used < -16)
1523 cpi->oxcf.cpu_used = -16;
1526 if (cpi->oxcf.cpu_used > 16)
1527 cpi->oxcf.cpu_used = 16;
1531 case MODE_GOODQUALITY:
1533 cpi->compressor_speed = 1;
1535 if (cpi->oxcf.cpu_used < -5)
1537 cpi->oxcf.cpu_used = -5;
1540 if (cpi->oxcf.cpu_used > 5)
1541 cpi->oxcf.cpu_used = 5;
1545 case MODE_BESTQUALITY:
1547 cpi->compressor_speed = 0;
1550 case MODE_FIRSTPASS:
1552 cpi->compressor_speed = 1;
1554 case MODE_SECONDPASS:
1556 cpi->compressor_speed = 1;
1558 if (cpi->oxcf.cpu_used < -5)
1560 cpi->oxcf.cpu_used = -5;
1563 if (cpi->oxcf.cpu_used > 5)
1564 cpi->oxcf.cpu_used = 5;
1567 case MODE_SECONDPASS_BEST:
1569 cpi->compressor_speed = 0;
1574 cpi->auto_worst_q = 1;
1576 cpi->oxcf.worst_allowed_q = q_trans[oxcf->worst_allowed_q];
1577 cpi->oxcf.best_allowed_q = q_trans[oxcf->best_allowed_q];
1578 cpi->oxcf.cq_level = q_trans[cpi->oxcf.cq_level];
1580 if (oxcf->fixed_q >= 0)
1582 if (oxcf->worst_allowed_q < 0)
1583 cpi->oxcf.fixed_q = q_trans[0];
1585 cpi->oxcf.fixed_q = q_trans[oxcf->worst_allowed_q];
1587 if (oxcf->alt_q < 0)
1588 cpi->oxcf.alt_q = q_trans[0];
1590 cpi->oxcf.alt_q = q_trans[oxcf->alt_q];
1592 if (oxcf->key_q < 0)
1593 cpi->oxcf.key_q = q_trans[0];
1595 cpi->oxcf.key_q = q_trans[oxcf->key_q];
1597 if (oxcf->gold_q < 0)
1598 cpi->oxcf.gold_q = q_trans[0];
1600 cpi->oxcf.gold_q = q_trans[oxcf->gold_q];
1604 cpi->baseline_gf_interval =
1605 cpi->oxcf.alt_freq ? cpi->oxcf.alt_freq : DEFAULT_GF_INTERVAL;
1607 cpi->ref_frame_flags = VP8_ALT_FLAG | VP8_GOLD_FLAG | VP8_LAST_FLAG;
1609 //cpi->use_golden_frame_only = 0;
1610 //cpi->use_last_frame_only = 0;
1611 cm->refresh_golden_frame = 0;
1612 cm->refresh_last_frame = 1;
1613 cm->refresh_entropy_probs = 1;
1615 if (cpi->oxcf.token_partitions >= 0 && cpi->oxcf.token_partitions <= 3)
1616 cm->multi_token_partition =
1617 (TOKEN_PARTITION) cpi->oxcf.token_partitions;
1619 setup_features(cpi);
1624 for (i = 0; i < MAX_MB_SEGMENTS; i++)
1625 cpi->segment_encode_breakout[i] = cpi->oxcf.encode_breakout;
1628 // At the moment the first order values may not be > MAXQ
1629 if (cpi->oxcf.fixed_q > MAXQ)
1630 cpi->oxcf.fixed_q = MAXQ;
1632 // local file playback mode == really big buffer
1633 if (cpi->oxcf.end_usage == USAGE_LOCAL_FILE_PLAYBACK)
1635 cpi->oxcf.starting_buffer_level = 60000;
1636 cpi->oxcf.optimal_buffer_level = 60000;
1637 cpi->oxcf.maximum_buffer_size = 240000;
1640 // Convert target bandwidth from Kbit/s to Bit/s
1641 cpi->oxcf.target_bandwidth *= 1000;
1643 cpi->oxcf.starting_buffer_level =
1644 rescale(cpi->oxcf.starting_buffer_level,
1645 cpi->oxcf.target_bandwidth, 1000);
1647 // Set or reset optimal and maximum buffer levels.
1648 if (cpi->oxcf.optimal_buffer_level == 0)
1649 cpi->oxcf.optimal_buffer_level = cpi->oxcf.target_bandwidth / 8;
1651 cpi->oxcf.optimal_buffer_level =
1652 rescale(cpi->oxcf.optimal_buffer_level,
1653 cpi->oxcf.target_bandwidth, 1000);
1655 if (cpi->oxcf.maximum_buffer_size == 0)
1656 cpi->oxcf.maximum_buffer_size = cpi->oxcf.target_bandwidth / 8;
1658 cpi->oxcf.maximum_buffer_size =
1659 rescale(cpi->oxcf.maximum_buffer_size,
1660 cpi->oxcf.target_bandwidth, 1000);
1662 // Set up frame rate and related parameters rate control values.
1663 vp8_new_frame_rate(cpi, cpi->oxcf.frame_rate);
1665 // Set absolute upper and lower quality limits
1666 cpi->worst_quality = cpi->oxcf.worst_allowed_q;
1667 cpi->best_quality = cpi->oxcf.best_allowed_q;
1669 // active values should only be modified if out of new range
1670 if (cpi->active_worst_quality > cpi->oxcf.worst_allowed_q)
1672 cpi->active_worst_quality = cpi->oxcf.worst_allowed_q;
1675 else if (cpi->active_worst_quality < cpi->oxcf.best_allowed_q)
1677 cpi->active_worst_quality = cpi->oxcf.best_allowed_q;
1679 if (cpi->active_best_quality < cpi->oxcf.best_allowed_q)
1681 cpi->active_best_quality = cpi->oxcf.best_allowed_q;
1684 else if (cpi->active_best_quality > cpi->oxcf.worst_allowed_q)
1686 cpi->active_best_quality = cpi->oxcf.worst_allowed_q;
1689 cpi->buffered_mode = (cpi->oxcf.optimal_buffer_level > 0) ? TRUE : FALSE;
1691 cpi->cq_target_quality = cpi->oxcf.cq_level;
1693 // Only allow dropped frames in buffered mode
1694 cpi->drop_frames_allowed = cpi->oxcf.allow_df && cpi->buffered_mode;
1696 if (!cm->use_bilinear_mc_filter)
1697 cm->mcomp_filter_type = SIXTAP;
1699 cm->mcomp_filter_type = BILINEAR;
1701 cpi->target_bandwidth = cpi->oxcf.target_bandwidth;
1703 cm->Width = cpi->oxcf.Width ;
1704 cm->Height = cpi->oxcf.Height ;
1706 cm->horiz_scale = cpi->horiz_scale;
1707 cm->vert_scale = cpi->vert_scale ;
1709 // VP8 sharpness level mapping 0-7 (vs 0-10 in general VPx dialogs)
1710 if (cpi->oxcf.Sharpness > 7)
1711 cpi->oxcf.Sharpness = 7;
1713 cm->sharpness_level = cpi->oxcf.Sharpness;
1715 if (cm->horiz_scale != NORMAL || cm->vert_scale != NORMAL)
1717 int UNINITIALIZED_IS_SAFE(hr), UNINITIALIZED_IS_SAFE(hs);
1718 int UNINITIALIZED_IS_SAFE(vr), UNINITIALIZED_IS_SAFE(vs);
1720 Scale2Ratio(cm->horiz_scale, &hr, &hs);
1721 Scale2Ratio(cm->vert_scale, &vr, &vs);
1723 // always go to the next whole number
1724 cm->Width = (hs - 1 + cpi->oxcf.Width * hr) / hs;
1725 cm->Height = (vs - 1 + cpi->oxcf.Height * vr) / vs;
1728 if (((cm->Width + 15) & 0xfffffff0) !=
1729 cm->yv12_fb[cm->lst_fb_idx].y_width ||
1730 ((cm->Height + 15) & 0xfffffff0) !=
1731 cm->yv12_fb[cm->lst_fb_idx].y_height ||
1732 cm->yv12_fb[cm->lst_fb_idx].y_width == 0)
1734 alloc_raw_frame_buffers(cpi);
1735 vp8_alloc_compressor_data(cpi);
1738 if (cpi->oxcf.fixed_q >= 0)
1740 cpi->last_q[0] = cpi->oxcf.fixed_q;
1741 cpi->last_q[1] = cpi->oxcf.fixed_q;
1744 cpi->Speed = cpi->oxcf.cpu_used;
1746 // force to allowlag to 0 if lag_in_frames is 0;
1747 if (cpi->oxcf.lag_in_frames == 0)
1749 cpi->oxcf.allow_lag = 0;
1751 // Limit on lag buffers as these are not currently dynamically allocated
1752 else if (cpi->oxcf.lag_in_frames > MAX_LAG_BUFFERS)
1753 cpi->oxcf.lag_in_frames = MAX_LAG_BUFFERS;
1756 cpi->alt_ref_source = NULL;
1757 cpi->is_src_frame_alt_ref = 0;
1761 // Experimental RD Code
1762 cpi->frame_distortion = 0;
1763 cpi->last_frame_distortion = 0;
1768 #define M_LOG2_E 0.693147180559945309417
1769 #define log2f(x) (log (x) / (float) M_LOG2_E)
1770 static void cal_mvsadcosts(int *mvsadcost[2])
1774 mvsadcost [0] [0] = 300;
1775 mvsadcost [1] [0] = 300;
1779 double z = 256 * (2 * (log2f(8 * i) + .6));
1780 mvsadcost [0][i] = (int) z;
1781 mvsadcost [1][i] = (int) z;
1782 mvsadcost [0][-i] = (int) z;
1783 mvsadcost [1][-i] = (int) z;
1785 while (++i <= mvfp_max);
1788 VP8_PTR vp8_create_compressor(VP8_CONFIG *oxcf)
1800 cpi = ctx.cpi = vpx_memalign(32, sizeof(VP8_COMP));
1801 // Check that the CPI instance is valid
1807 vpx_memset(cpi, 0, sizeof(VP8_COMP));
1809 if (setjmp(cm->error.jmp))
1811 VP8_PTR ptr = ctx.ptr;
1813 ctx.cpi->common.error.setjmp = 0;
1814 vp8_remove_compressor(&ptr);
1818 cpi->common.error.setjmp = 1;
1820 CHECK_MEM_ERROR(cpi->mb.ss, vpx_calloc(sizeof(search_site), (MAX_MVSEARCH_STEPS * 8) + 1));
1822 vp8_create_common(&cpi->common);
1823 vp8_cmachine_specific_config(cpi);
1825 init_config((VP8_PTR)cpi, oxcf);
1827 memcpy(cpi->base_skip_false_prob, vp8cx_base_skip_false_prob, sizeof(vp8cx_base_skip_false_prob));
1828 cpi->common.current_video_frame = 0;
1829 cpi->kf_overspend_bits = 0;
1830 cpi->kf_bitrate_adjustment = 0;
1831 cpi->frames_till_gf_update_due = 0;
1832 cpi->gf_overspend_bits = 0;
1833 cpi->non_gf_bitrate_adjustment = 0;
1834 cpi->prob_last_coded = 128;
1835 cpi->prob_gf_coded = 128;
1836 cpi->prob_intra_coded = 63;
1838 // Prime the recent reference frame useage counters.
1839 // Hereafter they will be maintained as a sort of moving average
1840 cpi->recent_ref_frame_usage[INTRA_FRAME] = 1;
1841 cpi->recent_ref_frame_usage[LAST_FRAME] = 1;
1842 cpi->recent_ref_frame_usage[GOLDEN_FRAME] = 1;
1843 cpi->recent_ref_frame_usage[ALTREF_FRAME] = 1;
1845 // Set reference frame sign bias for ALTREF frame to 1 (for now)
1846 cpi->common.ref_frame_sign_bias[ALTREF_FRAME] = 1;
1848 cpi->gf_decay_rate = 0;
1849 cpi->baseline_gf_interval = DEFAULT_GF_INTERVAL;
1851 cpi->gold_is_last = 0 ;
1852 cpi->alt_is_last = 0 ;
1853 cpi->gold_is_alt = 0 ;
1855 // allocate memory for storing last frame's MVs for MV prediction.
1856 CHECK_MEM_ERROR(cpi->lfmv, vpx_calloc((cpi->common.mb_rows+2) * (cpi->common.mb_cols+2), sizeof(int_mv)));
1857 CHECK_MEM_ERROR(cpi->lf_ref_frame_sign_bias, vpx_calloc((cpi->common.mb_rows+2) * (cpi->common.mb_cols+2), sizeof(int)));
1858 CHECK_MEM_ERROR(cpi->lf_ref_frame, vpx_calloc((cpi->common.mb_rows+2) * (cpi->common.mb_cols+2), sizeof(int)));
1860 // Create the encoder segmentation map and set all entries to 0
1861 CHECK_MEM_ERROR(cpi->segmentation_map, vpx_calloc(cpi->common.mb_rows * cpi->common.mb_cols, 1));
1862 CHECK_MEM_ERROR(cpi->active_map, vpx_calloc(cpi->common.mb_rows * cpi->common.mb_cols, 1));
1863 vpx_memset(cpi->active_map , 1, (cpi->common.mb_rows * cpi->common.mb_cols));
1864 cpi->active_map_enabled = 0;
1867 // Experimental code for lagged and one pass
1868 // Initialise one_pass GF frames stats
1869 // Update stats used for GF selection
1872 cpi->one_pass_frame_index = 0;
1874 for (i = 0; i < MAX_LAG_BUFFERS; i++)
1876 cpi->one_pass_frame_stats[i].frames_so_far = 0;
1877 cpi->one_pass_frame_stats[i].frame_intra_error = 0.0;
1878 cpi->one_pass_frame_stats[i].frame_coded_error = 0.0;
1879 cpi->one_pass_frame_stats[i].frame_pcnt_inter = 0.0;
1880 cpi->one_pass_frame_stats[i].frame_pcnt_motion = 0.0;
1881 cpi->one_pass_frame_stats[i].frame_mvr = 0.0;
1882 cpi->one_pass_frame_stats[i].frame_mvr_abs = 0.0;
1883 cpi->one_pass_frame_stats[i].frame_mvc = 0.0;
1884 cpi->one_pass_frame_stats[i].frame_mvc_abs = 0.0;
1889 // Should we use the cyclic refresh method.
1890 // Currently this is tied to error resilliant mode
1891 cpi->cyclic_refresh_mode_enabled = cpi->oxcf.error_resilient_mode;
1892 cpi->cyclic_refresh_mode_max_mbs_perframe = (cpi->common.mb_rows * cpi->common.mb_cols) / 40;
1893 cpi->cyclic_refresh_mode_index = 0;
1894 cpi->cyclic_refresh_q = 32;
1896 if (cpi->cyclic_refresh_mode_enabled)
1898 CHECK_MEM_ERROR(cpi->cyclic_refresh_map, vpx_calloc((cpi->common.mb_rows * cpi->common.mb_cols), 1));
1901 cpi->cyclic_refresh_map = (signed char *) NULL;
1903 // Test function for segmentation
1904 //segmentation_test_function((VP8_PTR) cpi);
1906 #ifdef ENTROPY_STATS
1907 init_context_counters();
1910 /*Initialize the feed-forward activity masking.*/
1911 cpi->activity_avg = 90<<12;
1913 cpi->frames_since_key = 8; // Give a sensible default for the first frame.
1914 cpi->key_frame_frequency = cpi->oxcf.key_freq;
1915 cpi->this_key_frame_forced = FALSE;
1916 cpi->next_key_frame_forced = FALSE;
1918 cpi->source_alt_ref_pending = FALSE;
1919 cpi->source_alt_ref_active = FALSE;
1920 cpi->common.refresh_alt_ref_frame = 0;
1922 cpi->b_calculate_psnr = CONFIG_PSNR;
1924 cpi->b_calculate_ssimg = 0;
1929 if (cpi->b_calculate_psnr)
1931 cpi->total_sq_error = 0.0;
1932 cpi->total_sq_error2 = 0.0;
1937 cpi->totalp_y = 0.0;
1938 cpi->totalp_u = 0.0;
1939 cpi->totalp_v = 0.0;
1941 cpi->tot_recode_hits = 0;
1942 cpi->summed_quality = 0;
1943 cpi->summed_weights = 0;
1946 if (cpi->b_calculate_ssimg)
1948 cpi->total_ssimg_y = 0;
1949 cpi->total_ssimg_u = 0;
1950 cpi->total_ssimg_v = 0;
1951 cpi->total_ssimg_all = 0;
1955 #define LLONG_MAX 9223372036854775807LL
1957 cpi->first_time_stamp_ever = LLONG_MAX;
1961 cpi->frames_till_gf_update_due = 0;
1962 cpi->key_frame_count = 1;
1964 cpi->ni_av_qi = cpi->oxcf.worst_allowed_q;
1967 cpi->total_byte_count = 0;
1969 cpi->drop_frame = 0;
1970 cpi->drop_count = 0;
1971 cpi->max_drop_count = 0;
1972 cpi->max_consec_dropped_frames = 4;
1974 cpi->rate_correction_factor = 1.0;
1975 cpi->key_frame_rate_correction_factor = 1.0;
1976 cpi->gf_rate_correction_factor = 1.0;
1977 cpi->est_max_qcorrection_factor = 1.0;
1979 cpi->mb.mvcost[0] = &cpi->mb.mvcosts[0][mv_max+1];
1980 cpi->mb.mvcost[1] = &cpi->mb.mvcosts[1][mv_max+1];
1981 cpi->mb.mvsadcost[0] = &cpi->mb.mvsadcosts[0][mvfp_max+1];
1982 cpi->mb.mvsadcost[1] = &cpi->mb.mvsadcosts[1][mvfp_max+1];
1984 cal_mvsadcosts(cpi->mb.mvsadcost);
1986 for (i = 0; i < KEY_FRAME_CONTEXT; i++)
1988 cpi->prior_key_frame_distance[i] = (int)cpi->output_frame_rate;
1991 #ifdef OUTPUT_YUV_SRC
1992 yuv_file = fopen("bd.yuv", "ab");
1996 framepsnr = fopen("framepsnr.stt", "a");
1997 kf_list = fopen("kf_list.stt", "w");
2000 cpi->output_pkt_list = oxcf->output_pkt_list;
2002 #if !(CONFIG_REALTIME_ONLY)
2006 vp8_init_first_pass(cpi);
2008 else if (cpi->pass == 2)
2010 size_t packet_sz = sizeof(FIRSTPASS_STATS);
2011 int packets = oxcf->two_pass_stats_in.sz / packet_sz;
2013 cpi->stats_in = oxcf->two_pass_stats_in.buf;
2014 cpi->stats_in_end = (void*)((char *)cpi->stats_in
2015 + (packets - 1) * packet_sz);
2016 vp8_init_second_pass(cpi);
2021 if (cpi->compressor_speed == 2)
2023 cpi->cpu_freq = 0; //vp8_get_processor_freq();
2024 cpi->avg_encode_time = 0;
2025 cpi->avg_pick_mode_time = 0;
2028 vp8_set_speed_features(cpi);
2030 // Set starting values of RD threshold multipliers (128 = *1)
2031 for (i = 0; i < MAX_MODES; i++)
2033 cpi->rd_thresh_mult[i] = 128;
2036 #ifdef ENTROPY_STATS
2037 init_mv_ref_counts();
2040 #if CONFIG_MULTITHREAD
2041 vp8cx_create_encoder_threads(cpi);
2044 cpi->fn_ptr[BLOCK_16X16].sdf = VARIANCE_INVOKE(&cpi->rtcd.variance, sad16x16);
2045 cpi->fn_ptr[BLOCK_16X16].vf = VARIANCE_INVOKE(&cpi->rtcd.variance, var16x16);
2046 cpi->fn_ptr[BLOCK_16X16].svf = VARIANCE_INVOKE(&cpi->rtcd.variance, subpixvar16x16);
2047 cpi->fn_ptr[BLOCK_16X16].svf_halfpix_h = VARIANCE_INVOKE(&cpi->rtcd.variance, halfpixvar16x16_h);
2048 cpi->fn_ptr[BLOCK_16X16].svf_halfpix_v = VARIANCE_INVOKE(&cpi->rtcd.variance, halfpixvar16x16_v);
2049 cpi->fn_ptr[BLOCK_16X16].svf_halfpix_hv = VARIANCE_INVOKE(&cpi->rtcd.variance, halfpixvar16x16_hv);
2050 cpi->fn_ptr[BLOCK_16X16].sdx3f = VARIANCE_INVOKE(&cpi->rtcd.variance, sad16x16x3);
2051 cpi->fn_ptr[BLOCK_16X16].sdx8f = VARIANCE_INVOKE(&cpi->rtcd.variance, sad16x16x8);
2052 cpi->fn_ptr[BLOCK_16X16].sdx4df = VARIANCE_INVOKE(&cpi->rtcd.variance, sad16x16x4d);
2054 cpi->fn_ptr[BLOCK_16X8].sdf = VARIANCE_INVOKE(&cpi->rtcd.variance, sad16x8);
2055 cpi->fn_ptr[BLOCK_16X8].vf = VARIANCE_INVOKE(&cpi->rtcd.variance, var16x8);
2056 cpi->fn_ptr[BLOCK_16X8].svf = VARIANCE_INVOKE(&cpi->rtcd.variance, subpixvar16x8);
2057 cpi->fn_ptr[BLOCK_16X8].svf_halfpix_h = NULL;
2058 cpi->fn_ptr[BLOCK_16X8].svf_halfpix_v = NULL;
2059 cpi->fn_ptr[BLOCK_16X8].svf_halfpix_hv = NULL;
2060 cpi->fn_ptr[BLOCK_16X8].sdx3f = VARIANCE_INVOKE(&cpi->rtcd.variance, sad16x8x3);
2061 cpi->fn_ptr[BLOCK_16X8].sdx8f = VARIANCE_INVOKE(&cpi->rtcd.variance, sad16x8x8);
2062 cpi->fn_ptr[BLOCK_16X8].sdx4df = VARIANCE_INVOKE(&cpi->rtcd.variance, sad16x8x4d);
2064 cpi->fn_ptr[BLOCK_8X16].sdf = VARIANCE_INVOKE(&cpi->rtcd.variance, sad8x16);
2065 cpi->fn_ptr[BLOCK_8X16].vf = VARIANCE_INVOKE(&cpi->rtcd.variance, var8x16);
2066 cpi->fn_ptr[BLOCK_8X16].svf = VARIANCE_INVOKE(&cpi->rtcd.variance, subpixvar8x16);
2067 cpi->fn_ptr[BLOCK_8X16].svf_halfpix_h = NULL;
2068 cpi->fn_ptr[BLOCK_8X16].svf_halfpix_v = NULL;
2069 cpi->fn_ptr[BLOCK_8X16].svf_halfpix_hv = NULL;
2070 cpi->fn_ptr[BLOCK_8X16].sdx3f = VARIANCE_INVOKE(&cpi->rtcd.variance, sad8x16x3);
2071 cpi->fn_ptr[BLOCK_8X16].sdx8f = VARIANCE_INVOKE(&cpi->rtcd.variance, sad8x16x8);
2072 cpi->fn_ptr[BLOCK_8X16].sdx4df = VARIANCE_INVOKE(&cpi->rtcd.variance, sad8x16x4d);
2074 cpi->fn_ptr[BLOCK_8X8].sdf = VARIANCE_INVOKE(&cpi->rtcd.variance, sad8x8);
2075 cpi->fn_ptr[BLOCK_8X8].vf = VARIANCE_INVOKE(&cpi->rtcd.variance, var8x8);
2076 cpi->fn_ptr[BLOCK_8X8].svf = VARIANCE_INVOKE(&cpi->rtcd.variance, subpixvar8x8);
2077 cpi->fn_ptr[BLOCK_8X8].svf_halfpix_h = NULL;
2078 cpi->fn_ptr[BLOCK_8X8].svf_halfpix_v = NULL;
2079 cpi->fn_ptr[BLOCK_8X8].svf_halfpix_hv = NULL;
2080 cpi->fn_ptr[BLOCK_8X8].sdx3f = VARIANCE_INVOKE(&cpi->rtcd.variance, sad8x8x3);
2081 cpi->fn_ptr[BLOCK_8X8].sdx8f = VARIANCE_INVOKE(&cpi->rtcd.variance, sad8x8x8);
2082 cpi->fn_ptr[BLOCK_8X8].sdx4df = VARIANCE_INVOKE(&cpi->rtcd.variance, sad8x8x4d);
2084 cpi->fn_ptr[BLOCK_4X4].sdf = VARIANCE_INVOKE(&cpi->rtcd.variance, sad4x4);
2085 cpi->fn_ptr[BLOCK_4X4].vf = VARIANCE_INVOKE(&cpi->rtcd.variance, var4x4);
2086 cpi->fn_ptr[BLOCK_4X4].svf = VARIANCE_INVOKE(&cpi->rtcd.variance, subpixvar4x4);
2087 cpi->fn_ptr[BLOCK_4X4].svf_halfpix_h = NULL;
2088 cpi->fn_ptr[BLOCK_4X4].svf_halfpix_v = NULL;
2089 cpi->fn_ptr[BLOCK_4X4].svf_halfpix_hv = NULL;
2090 cpi->fn_ptr[BLOCK_4X4].sdx3f = VARIANCE_INVOKE(&cpi->rtcd.variance, sad4x4x3);
2091 cpi->fn_ptr[BLOCK_4X4].sdx8f = VARIANCE_INVOKE(&cpi->rtcd.variance, sad4x4x8);
2092 cpi->fn_ptr[BLOCK_4X4].sdx4df = VARIANCE_INVOKE(&cpi->rtcd.variance, sad4x4x4d);
2094 cpi->full_search_sad = SEARCH_INVOKE(&cpi->rtcd.search, full_search);
2095 cpi->diamond_search_sad = SEARCH_INVOKE(&cpi->rtcd.search, diamond_search);
2096 cpi->refining_search_sad = SEARCH_INVOKE(&cpi->rtcd.search, refining_search);
2098 cpi->ready_for_new_frame = 1;
2100 // make sure frame 1 is okay
2101 cpi->error_bins[0] = cpi->common.MBs;
2103 //vp8cx_init_quantizer() is first called here. Add check in vp8cx_frame_init_quantizer() so that vp8cx_init_quantizer is only called later
2104 //when needed. This will avoid unnecessary calls of vp8cx_init_quantizer() for every frame.
2105 vp8cx_init_quantizer(cpi);
2107 vp8_init_loop_filter(cm);
2108 cm->last_frame_type = KEY_FRAME;
2109 cm->last_filter_type = cm->filter_type;
2110 cm->last_sharpness_level = cm->sharpness_level;
2112 cpi->common.error.setjmp = 0;
2113 return (VP8_PTR) cpi;
2118 void vp8_remove_compressor(VP8_PTR *ptr)
2120 VP8_COMP *cpi = (VP8_COMP *)(*ptr);
2125 if (cpi && (cpi->common.current_video_frame > 0))
2127 #if !(CONFIG_REALTIME_ONLY)
2131 vp8_end_second_pass(cpi);
2136 #ifdef ENTROPY_STATS
2137 print_context_counters();
2138 print_tree_update_probs();
2139 print_mode_context();
2146 FILE *f = fopen("opsnr.stt", "a");
2147 double time_encoded = (cpi->last_end_time_stamp_seen
2148 - cpi->first_time_stamp_ever) / 10000000.000;
2149 double total_encode_time = (cpi->time_receive_data + cpi->time_compress_data) / 1000.000;
2150 double dr = (double)cpi->bytes * (double) 8 / (double)1000 / time_encoded;
2152 if (cpi->b_calculate_psnr)
2154 YV12_BUFFER_CONFIG *lst_yv12 = &cpi->common.yv12_fb[cpi->common.lst_fb_idx];
2155 double samples = 3.0 / 2 * cpi->count * lst_yv12->y_width * lst_yv12->y_height;
2156 double total_psnr = vp8_mse2psnr(samples, 255.0, cpi->total_sq_error);
2157 double total_psnr2 = vp8_mse2psnr(samples, 255.0, cpi->total_sq_error2);
2158 double total_ssim = 100 * pow(cpi->summed_quality / cpi->summed_weights, 8.0);
2160 fprintf(f, "Bitrate\tAVGPsnr\tGLBPsnr\tAVPsnrP\tGLPsnrP\tVPXSSIM\t Time(us)\n");
2161 fprintf(f, "%7.3f\t%7.3f\t%7.3f\t%7.3f\t%7.3f\t%7.3f\t%8.0f\n",
2162 dr, cpi->total / cpi->count, total_psnr, cpi->totalp / cpi->count, total_psnr2, total_ssim,
2166 if (cpi->b_calculate_ssimg)
2168 fprintf(f, "BitRate\tSSIM_Y\tSSIM_U\tSSIM_V\tSSIM_A\t Time(us)\n");
2169 fprintf(f, "%7.3f\t%6.4f\t%6.4f\t%6.4f\t%6.4f\t%8.0f\n", dr,
2170 cpi->total_ssimg_y / cpi->count, cpi->total_ssimg_u / cpi->count,
2171 cpi->total_ssimg_v / cpi->count, cpi->total_ssimg_all / cpi->count, total_encode_time);
2176 f = fopen("qskip.stt", "a");
2177 fprintf(f, "minq:%d -maxq:%d skipture:skipfalse = %d:%d\n", cpi->oxcf.best_allowed_q, cpi->oxcf.worst_allowed_q, skiptruecount, skipfalsecount);
2188 if (cpi->compressor_speed == 2)
2191 FILE *f = fopen("cxspeed.stt", "a");
2192 cnt_pm /= cpi->common.MBs;
2194 for (i = 0; i < 16; i++)
2195 fprintf(f, "%5d", frames_at_speed[i]);
2198 //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);
2207 extern int count_mb_seg[4];
2208 FILE *f = fopen("modes.stt", "a");
2209 double dr = (double)cpi->oxcf.frame_rate * (double)bytes * (double)8 / (double)count / (double)1000 ;
2210 fprintf(f, "intra_mode in Intra Frames:\n");
2211 fprintf(f, "Y: %8d, %8d, %8d, %8d, %8d\n", y_modes[0], y_modes[1], y_modes[2], y_modes[3], y_modes[4]);
2212 fprintf(f, "UV:%8d, %8d, %8d, %8d\n", uv_modes[0], uv_modes[1], uv_modes[2], uv_modes[3]);
2217 for (i = 0; i < 10; i++)
2218 fprintf(f, "%8d, ", b_modes[i]);
2224 fprintf(f, "Modes in Inter Frames:\n");
2225 fprintf(f, "Y: %8d, %8d, %8d, %8d, %8d, %8d, %8d, %8d, %8d, %8d\n",
2226 inter_y_modes[0], inter_y_modes[1], inter_y_modes[2], inter_y_modes[3], inter_y_modes[4],
2227 inter_y_modes[5], inter_y_modes[6], inter_y_modes[7], inter_y_modes[8], inter_y_modes[9]);
2228 fprintf(f, "UV:%8d, %8d, %8d, %8d\n", inter_uv_modes[0], inter_uv_modes[1], inter_uv_modes[2], inter_uv_modes[3]);
2233 for (i = 0; i < 15; i++)
2234 fprintf(f, "%8d, ", inter_b_modes[i]);
2239 fprintf(f, "P:%8d, %8d, %8d, %8d\n", count_mb_seg[0], count_mb_seg[1], count_mb_seg[2], count_mb_seg[3]);
2240 fprintf(f, "PB:%8d, %8d, %8d, %8d\n", inter_b_modes[LEFT4X4], inter_b_modes[ABOVE4X4], inter_b_modes[ZERO4X4], inter_b_modes[NEW4X4]);
2248 #ifdef ENTROPY_STATS
2251 FILE *fmode = fopen("modecontext.c", "w");
2253 fprintf(fmode, "\n#include \"entropymode.h\"\n\n");
2254 fprintf(fmode, "const unsigned int vp8_kf_default_bmode_counts ");
2255 fprintf(fmode, "[VP8_BINTRAMODES] [VP8_BINTRAMODES] [VP8_BINTRAMODES] =\n{\n");
2257 for (i = 0; i < 10; i++)
2260 fprintf(fmode, " { //Above Mode : %d\n", i);
2262 for (j = 0; j < 10; j++)
2265 fprintf(fmode, " {");
2267 for (k = 0; k < 10; k++)
2269 if (!intra_mode_stats[i][j][k])
2270 fprintf(fmode, " %5d, ", 1);
2272 fprintf(fmode, " %5d, ", intra_mode_stats[i][j][k]);
2275 fprintf(fmode, "}, // left_mode %d\n", j);
2279 fprintf(fmode, " },\n");
2283 fprintf(fmode, "};\n");
2289 #if defined(SECTIONBITS_OUTPUT)
2294 FILE *f = fopen("tokenbits.stt", "a");
2296 for (i = 0; i < 28; i++)
2297 fprintf(f, "%8d", (int)(Sectionbits[i] / 256));
2307 printf("\n_pick_loop_filter_level:%d\n", cpi->time_pick_lpf / 1000);
2308 printf("\n_frames recive_data encod_mb_row compress_frame Total\n");
2309 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);
2315 #if CONFIG_MULTITHREAD
2316 vp8cx_remove_encoder_threads(cpi);
2319 dealloc_compressor_data(cpi);
2320 vpx_free(cpi->mb.ss);
2322 vpx_free(cpi->cyclic_refresh_map);
2324 vp8_remove_common(&cpi->common);
2328 #ifdef OUTPUT_YUV_SRC
2348 static uint64_t calc_plane_error(unsigned char *orig, int orig_stride,
2349 unsigned char *recon, int recon_stride,
2350 unsigned int cols, unsigned int rows,
2351 vp8_variance_rtcd_vtable_t *rtcd)
2353 unsigned int row, col;
2354 uint64_t total_sse = 0;
2357 for (row = 0; row + 16 <= rows; row += 16)
2359 for (col = 0; col + 16 <= cols; col += 16)
2363 VARIANCE_INVOKE(rtcd, mse16x16)(orig + col, orig_stride,
2364 recon + col, recon_stride,
2369 /* Handle odd-sized width */
2372 unsigned int border_row, border_col;
2373 unsigned char *border_orig = orig;
2374 unsigned char *border_recon = recon;
2376 for (border_row = 0; border_row < 16; border_row++)
2378 for (border_col = col; border_col < cols; border_col++)
2380 diff = border_orig[border_col] - border_recon[border_col];
2381 total_sse += diff * diff;
2384 border_orig += orig_stride;
2385 border_recon += recon_stride;
2389 orig += orig_stride * 16;
2390 recon += recon_stride * 16;
2393 /* Handle odd-sized height */
2394 for (; row < rows; row++)
2396 for (col = 0; col < cols; col++)
2398 diff = orig[col] - recon[col];
2399 total_sse += diff * diff;
2402 orig += orig_stride;
2403 recon += recon_stride;
2410 static void generate_psnr_packet(VP8_COMP *cpi)
2412 YV12_BUFFER_CONFIG *orig = cpi->Source;
2413 YV12_BUFFER_CONFIG *recon = cpi->common.frame_to_show;
2414 struct vpx_codec_cx_pkt pkt;
2417 unsigned int width = cpi->common.Width;
2418 unsigned int height = cpi->common.Height;
2420 pkt.kind = VPX_CODEC_PSNR_PKT;
2421 sse = calc_plane_error(orig->y_buffer, orig->y_stride,
2422 recon->y_buffer, recon->y_stride,
2424 IF_RTCD(&cpi->rtcd.variance));
2425 pkt.data.psnr.sse[0] = sse;
2426 pkt.data.psnr.sse[1] = sse;
2427 pkt.data.psnr.samples[0] = width * height;
2428 pkt.data.psnr.samples[1] = width * height;
2430 width = (width + 1) / 2;
2431 height = (height + 1) / 2;
2433 sse = calc_plane_error(orig->u_buffer, orig->uv_stride,
2434 recon->u_buffer, recon->uv_stride,
2436 IF_RTCD(&cpi->rtcd.variance));
2437 pkt.data.psnr.sse[0] += sse;
2438 pkt.data.psnr.sse[2] = sse;
2439 pkt.data.psnr.samples[0] += width * height;
2440 pkt.data.psnr.samples[2] = width * height;
2442 sse = calc_plane_error(orig->v_buffer, orig->uv_stride,
2443 recon->v_buffer, recon->uv_stride,
2445 IF_RTCD(&cpi->rtcd.variance));
2446 pkt.data.psnr.sse[0] += sse;
2447 pkt.data.psnr.sse[3] = sse;
2448 pkt.data.psnr.samples[0] += width * height;
2449 pkt.data.psnr.samples[3] = width * height;
2451 for (i = 0; i < 4; i++)
2452 pkt.data.psnr.psnr[i] = vp8_mse2psnr(pkt.data.psnr.samples[i], 255.0,
2453 pkt.data.psnr.sse[i]);
2455 vpx_codec_pkt_list_add(cpi->output_pkt_list, &pkt);
2459 int vp8_use_as_reference(VP8_PTR ptr, int ref_frame_flags)
2461 VP8_COMP *cpi = (VP8_COMP *)(ptr);
2463 if (ref_frame_flags > 7)
2466 cpi->ref_frame_flags = ref_frame_flags;
2469 int vp8_update_reference(VP8_PTR ptr, int ref_frame_flags)
2471 VP8_COMP *cpi = (VP8_COMP *)(ptr);
2473 if (ref_frame_flags > 7)
2476 cpi->common.refresh_golden_frame = 0;
2477 cpi->common.refresh_alt_ref_frame = 0;
2478 cpi->common.refresh_last_frame = 0;
2480 if (ref_frame_flags & VP8_LAST_FLAG)
2481 cpi->common.refresh_last_frame = 1;
2483 if (ref_frame_flags & VP8_GOLD_FLAG)
2484 cpi->common.refresh_golden_frame = 1;
2486 if (ref_frame_flags & VP8_ALT_FLAG)
2487 cpi->common.refresh_alt_ref_frame = 1;
2492 int vp8_get_reference(VP8_PTR ptr, VP8_REFFRAME ref_frame_flag, YV12_BUFFER_CONFIG *sd)
2494 VP8_COMP *cpi = (VP8_COMP *)(ptr);
2495 VP8_COMMON *cm = &cpi->common;
2498 if (ref_frame_flag == VP8_LAST_FLAG)
2499 ref_fb_idx = cm->lst_fb_idx;
2500 else if (ref_frame_flag == VP8_GOLD_FLAG)
2501 ref_fb_idx = cm->gld_fb_idx;
2502 else if (ref_frame_flag == VP8_ALT_FLAG)
2503 ref_fb_idx = cm->alt_fb_idx;
2507 vp8_yv12_copy_frame_ptr(&cm->yv12_fb[ref_fb_idx], sd);
2511 int vp8_set_reference(VP8_PTR ptr, VP8_REFFRAME ref_frame_flag, YV12_BUFFER_CONFIG *sd)
2513 VP8_COMP *cpi = (VP8_COMP *)(ptr);
2514 VP8_COMMON *cm = &cpi->common;
2518 if (ref_frame_flag == VP8_LAST_FLAG)
2519 ref_fb_idx = cm->lst_fb_idx;
2520 else if (ref_frame_flag == VP8_GOLD_FLAG)
2521 ref_fb_idx = cm->gld_fb_idx;
2522 else if (ref_frame_flag == VP8_ALT_FLAG)
2523 ref_fb_idx = cm->alt_fb_idx;
2527 vp8_yv12_copy_frame_ptr(sd, &cm->yv12_fb[ref_fb_idx]);
2531 int vp8_update_entropy(VP8_PTR comp, int update)
2533 VP8_COMP *cpi = (VP8_COMP *) comp;
2534 VP8_COMMON *cm = &cpi->common;
2535 cm->refresh_entropy_probs = update;
2542 void vp8_write_yuv_frame(const char *name, YV12_BUFFER_CONFIG *s)
2544 FILE *yuv_file = fopen(name, "ab");
2545 unsigned char *src = s->y_buffer;
2546 int h = s->y_height;
2550 fwrite(src, s->y_width, 1, yuv_file);
2560 fwrite(src, s->uv_width, 1, yuv_file);
2561 src += s->uv_stride;
2570 fwrite(src, s->uv_width, 1, yuv_file);
2571 src += s->uv_stride;
2580 static void scale_and_extend_source(YV12_BUFFER_CONFIG *sd, VP8_COMP *cpi)
2582 VP8_COMMON *cm = &cpi->common;
2584 // are we resizing the image
2585 if (cm->horiz_scale != 0 || cm->vert_scale != 0)
2587 #if CONFIG_SPATIAL_RESAMPLING
2588 int UNINITIALIZED_IS_SAFE(hr), UNINITIALIZED_IS_SAFE(hs);
2589 int UNINITIALIZED_IS_SAFE(vr), UNINITIALIZED_IS_SAFE(vs);
2592 if (cm->vert_scale == 3)
2597 Scale2Ratio(cm->horiz_scale, &hr, &hs);
2598 Scale2Ratio(cm->vert_scale, &vr, &vs);
2600 vp8_scale_frame(sd, &cpi->scaled_source, cm->temp_scale_frame.y_buffer,
2601 tmp_height, hs, hr, vs, vr, 0);
2603 vp8_yv12_extend_frame_borders(&cpi->scaled_source);
2604 cpi->Source = &cpi->scaled_source;
2610 static void resize_key_frame(VP8_COMP *cpi)
2612 #if CONFIG_SPATIAL_RESAMPLING
2613 VP8_COMMON *cm = &cpi->common;
2615 // Do we need to apply resampling for one pass cbr.
2616 // In one pass this is more limited than in two pass cbr
2617 // The test and any change is only made one per key frame sequence
2618 if (cpi->oxcf.allow_spatial_resampling && (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER))
2620 int UNINITIALIZED_IS_SAFE(hr), UNINITIALIZED_IS_SAFE(hs);
2621 int UNINITIALIZED_IS_SAFE(vr), UNINITIALIZED_IS_SAFE(vs);
2622 int new_width, new_height;
2624 // If we are below the resample DOWN watermark then scale down a notch.
2625 if (cpi->buffer_level < (cpi->oxcf.resample_down_water_mark * cpi->oxcf.optimal_buffer_level / 100))
2627 cm->horiz_scale = (cm->horiz_scale < ONETWO) ? cm->horiz_scale + 1 : ONETWO;
2628 cm->vert_scale = (cm->vert_scale < ONETWO) ? cm->vert_scale + 1 : ONETWO;
2630 // Should we now start scaling back up
2631 else if (cpi->buffer_level > (cpi->oxcf.resample_up_water_mark * cpi->oxcf.optimal_buffer_level / 100))
2633 cm->horiz_scale = (cm->horiz_scale > NORMAL) ? cm->horiz_scale - 1 : NORMAL;
2634 cm->vert_scale = (cm->vert_scale > NORMAL) ? cm->vert_scale - 1 : NORMAL;
2637 // Get the new hieght and width
2638 Scale2Ratio(cm->horiz_scale, &hr, &hs);
2639 Scale2Ratio(cm->vert_scale, &vr, &vs);
2640 new_width = ((hs - 1) + (cpi->oxcf.Width * hr)) / hs;
2641 new_height = ((vs - 1) + (cpi->oxcf.Height * vr)) / vs;
2643 // If the image size has changed we need to reallocate the buffers
2644 // and resample the source image
2645 if ((cm->Width != new_width) || (cm->Height != new_height))
2647 cm->Width = new_width;
2648 cm->Height = new_height;
2649 vp8_alloc_compressor_data(cpi);
2650 scale_and_extend_source(cpi->un_scaled_source, cpi);
2658 static void set_quantizer(VP8_COMP *cpi, int Q)
2660 VP8_COMMON *cm = &cpi->common;
2661 MACROBLOCKD *mbd = &cpi->mb.e_mbd;
2664 cm->base_qindex = Q;
2666 /* if any of the delta_q values are changing update flag has to be set */
2667 /* currently only y2dc_delta_q may change */
2669 cm->y1dc_delta_q = 0;
2670 cm->y2ac_delta_q = 0;
2671 cm->uvdc_delta_q = 0;
2672 cm->uvac_delta_q = 0;
2681 update |= cm->y2dc_delta_q != new_delta_q;
2682 cm->y2dc_delta_q = new_delta_q;
2685 // Set Segment specific quatizers
2686 mbd->segment_feature_data[MB_LVL_ALT_Q][0] = cpi->segment_feature_data[MB_LVL_ALT_Q][0];
2687 mbd->segment_feature_data[MB_LVL_ALT_Q][1] = cpi->segment_feature_data[MB_LVL_ALT_Q][1];
2688 mbd->segment_feature_data[MB_LVL_ALT_Q][2] = cpi->segment_feature_data[MB_LVL_ALT_Q][2];
2689 mbd->segment_feature_data[MB_LVL_ALT_Q][3] = cpi->segment_feature_data[MB_LVL_ALT_Q][3];
2691 /* quantizer has to be reinitialized for any delta_q changes */
2693 vp8cx_init_quantizer(cpi);
2697 static void update_alt_ref_frame_and_stats(VP8_COMP *cpi)
2699 VP8_COMMON *cm = &cpi->common;
2701 // Update the golden frame buffer
2702 vp8_yv12_copy_frame_ptr(cm->frame_to_show, &cm->yv12_fb[cm->alt_fb_idx]);
2704 // Select an interval before next GF or altref
2705 if (!cpi->auto_gold)
2706 cpi->frames_till_gf_update_due = cpi->goldfreq;
2708 if ((cpi->pass != 2) && cpi->frames_till_gf_update_due)
2710 cpi->current_gf_interval = cpi->frames_till_gf_update_due;
2712 // Set the bits per frame that we should try and recover in subsequent inter frames
2713 // to account for the extra GF spend... note that his does not apply for GF updates
2714 // that occur coincident with a key frame as the extra cost of key frames is dealt
2717 cpi->gf_overspend_bits += cpi->projected_frame_size;
2718 cpi->non_gf_bitrate_adjustment = cpi->gf_overspend_bits / cpi->frames_till_gf_update_due;
2721 // Update data structure that monitors level of reference to last GF
2722 vpx_memset(cpi->gf_active_flags, 1, (cm->mb_rows * cm->mb_cols));
2723 cpi->gf_active_count = cm->mb_rows * cm->mb_cols;
2725 // this frame refreshes means next frames don't unless specified by user
2726 cpi->common.frames_since_golden = 0;
2728 // Clear the alternate reference update pending flag.
2729 cpi->source_alt_ref_pending = FALSE;
2731 // Set the alternate refernce frame active flag
2732 cpi->source_alt_ref_active = TRUE;
2736 static void update_golden_frame_and_stats(VP8_COMP *cpi)
2738 VP8_COMMON *cm = &cpi->common;
2740 // Update the Golden frame reconstruction buffer if signalled and the GF usage counts.
2741 if (cm->refresh_golden_frame)
2743 if (cm->frame_type != KEY_FRAME)
2745 // Update the golden frame buffer
2746 vp8_yv12_copy_frame_ptr(cm->frame_to_show, &cm->yv12_fb[cm->gld_fb_idx]);
2749 // Select an interval before next GF
2750 if (!cpi->auto_gold)
2751 cpi->frames_till_gf_update_due = cpi->goldfreq;
2753 if ((cpi->pass != 2) && (cpi->frames_till_gf_update_due > 0))
2755 cpi->current_gf_interval = cpi->frames_till_gf_update_due;
2757 // Set the bits per frame that we should try and recover in subsequent inter frames
2758 // to account for the extra GF spend... note that his does not apply for GF updates
2759 // that occur coincident with a key frame as the extra cost of key frames is dealt
2761 if ((cm->frame_type != KEY_FRAME) && !cpi->source_alt_ref_active)
2763 // Calcluate GF bits to be recovered
2764 // Projected size - av frame bits available for inter frames for clip as a whole
2765 cpi->gf_overspend_bits += (cpi->projected_frame_size - cpi->inter_frame_target);
2768 cpi->non_gf_bitrate_adjustment = cpi->gf_overspend_bits / cpi->frames_till_gf_update_due;
2772 // Update data structure that monitors level of reference to last GF
2773 vpx_memset(cpi->gf_active_flags, 1, (cm->mb_rows * cm->mb_cols));
2774 cpi->gf_active_count = cm->mb_rows * cm->mb_cols;
2776 // this frame refreshes means next frames don't unless specified by user
2777 cm->refresh_golden_frame = 0;
2778 cpi->common.frames_since_golden = 0;
2780 //if ( cm->frame_type == KEY_FRAME )
2782 cpi->recent_ref_frame_usage[INTRA_FRAME] = 1;
2783 cpi->recent_ref_frame_usage[LAST_FRAME] = 1;
2784 cpi->recent_ref_frame_usage[GOLDEN_FRAME] = 1;
2785 cpi->recent_ref_frame_usage[ALTREF_FRAME] = 1;
2789 // // Carry a potrtion of count over to begining of next gf sequence
2790 // cpi->recent_ref_frame_usage[INTRA_FRAME] >>= 5;
2791 // cpi->recent_ref_frame_usage[LAST_FRAME] >>= 5;
2792 // cpi->recent_ref_frame_usage[GOLDEN_FRAME] >>= 5;
2793 // cpi->recent_ref_frame_usage[ALTREF_FRAME] >>= 5;
2796 // ******** Fixed Q test code only ************
2797 // If we are going to use the ALT reference for the next group of frames set a flag to say so.
2798 if (cpi->oxcf.fixed_q >= 0 &&
2799 cpi->oxcf.play_alternate && !cpi->common.refresh_alt_ref_frame)
2801 cpi->source_alt_ref_pending = TRUE;
2802 cpi->frames_till_gf_update_due = cpi->baseline_gf_interval;
2805 if (!cpi->source_alt_ref_pending)
2806 cpi->source_alt_ref_active = FALSE;
2808 // Decrement count down till next gf
2809 if (cpi->frames_till_gf_update_due > 0)
2810 cpi->frames_till_gf_update_due--;
2813 else if (!cpi->common.refresh_alt_ref_frame)
2815 // Decrement count down till next gf
2816 if (cpi->frames_till_gf_update_due > 0)
2817 cpi->frames_till_gf_update_due--;
2819 if (cpi->common.frames_till_alt_ref_frame)
2820 cpi->common.frames_till_alt_ref_frame --;
2822 cpi->common.frames_since_golden ++;
2824 if (cpi->common.frames_since_golden > 1)
2826 cpi->recent_ref_frame_usage[INTRA_FRAME] += cpi->count_mb_ref_frame_usage[INTRA_FRAME];
2827 cpi->recent_ref_frame_usage[LAST_FRAME] += cpi->count_mb_ref_frame_usage[LAST_FRAME];
2828 cpi->recent_ref_frame_usage[GOLDEN_FRAME] += cpi->count_mb_ref_frame_usage[GOLDEN_FRAME];
2829 cpi->recent_ref_frame_usage[ALTREF_FRAME] += cpi->count_mb_ref_frame_usage[ALTREF_FRAME];
2834 // This function updates the reference frame probability estimates that
2835 // will be used during mode selection
2836 static void update_rd_ref_frame_probs(VP8_COMP *cpi)
2838 VP8_COMMON *cm = &cpi->common;
2841 const int *const rfct = cpi->recent_ref_frame_usage;
2842 const int rf_intra = rfct[INTRA_FRAME];
2843 const int rf_inter = rfct[LAST_FRAME] + rfct[GOLDEN_FRAME] + rfct[ALTREF_FRAME];
2845 if (cm->frame_type == KEY_FRAME)
2847 cpi->prob_intra_coded = 255;
2848 cpi->prob_last_coded = 128;
2849 cpi->prob_gf_coded = 128;
2851 else if (!(rf_intra + rf_inter))
2853 // This is a trap in case this function is called with cpi->recent_ref_frame_usage[] blank.
2854 cpi->prob_intra_coded = 63;
2855 cpi->prob_last_coded = 128;
2856 cpi->prob_gf_coded = 128;
2860 cpi->prob_intra_coded = (rf_intra * 255) / (rf_intra + rf_inter);
2862 if (cpi->prob_intra_coded < 1)
2863 cpi->prob_intra_coded = 1;
2865 if ((cm->frames_since_golden > 0) || cpi->source_alt_ref_active)
2867 cpi->prob_last_coded = rf_inter ? (rfct[LAST_FRAME] * 255) / rf_inter : 128;
2869 if (cpi->prob_last_coded < 1)
2870 cpi->prob_last_coded = 1;
2872 cpi->prob_gf_coded = (rfct[GOLDEN_FRAME] + rfct[ALTREF_FRAME])
2873 ? (rfct[GOLDEN_FRAME] * 255) / (rfct[GOLDEN_FRAME] + rfct[ALTREF_FRAME]) : 128;
2875 if (cpi->prob_gf_coded < 1)
2876 cpi->prob_gf_coded = 1;
2881 const int *const rfct = cpi->count_mb_ref_frame_usage;
2882 const int rf_intra = rfct[INTRA_FRAME];
2883 const int rf_inter = rfct[LAST_FRAME] + rfct[GOLDEN_FRAME] + rfct[ALTREF_FRAME];
2885 if (cm->frame_type == KEY_FRAME)
2887 cpi->prob_intra_coded = 255;
2888 cpi->prob_last_coded = 128;
2889 cpi->prob_gf_coded = 128;
2891 else if (!(rf_intra + rf_inter))
2893 // This is a trap in case this function is called with cpi->recent_ref_frame_usage[] blank.
2894 cpi->prob_intra_coded = 63;
2895 cpi->prob_last_coded = 128;
2896 cpi->prob_gf_coded = 128;
2900 cpi->prob_intra_coded = (rf_intra * 255) / (rf_intra + rf_inter);
2902 if (cpi->prob_intra_coded < 1)
2903 cpi->prob_intra_coded = 1;
2905 cpi->prob_last_coded = rf_inter ? (rfct[LAST_FRAME] * 255) / rf_inter : 128;
2907 if (cpi->prob_last_coded < 1)
2908 cpi->prob_last_coded = 1;
2910 cpi->prob_gf_coded = (rfct[GOLDEN_FRAME] + rfct[ALTREF_FRAME])
2911 ? (rfct[GOLDEN_FRAME] * 255) / (rfct[GOLDEN_FRAME] + rfct[ALTREF_FRAME]) : 128;
2913 if (cpi->prob_gf_coded < 1)
2914 cpi->prob_gf_coded = 1;
2917 // update reference frame costs since we can do better than what we got last frame.
2919 if (cpi->common.refresh_alt_ref_frame)
2921 cpi->prob_intra_coded += 40;
2922 cpi->prob_last_coded = 200;
2923 cpi->prob_gf_coded = 1;
2925 else if (cpi->common.frames_since_golden == 0)
2927 cpi->prob_last_coded = 214;
2928 cpi->prob_gf_coded = 1;
2930 else if (cpi->common.frames_since_golden == 1)
2932 cpi->prob_last_coded = 192;
2933 cpi->prob_gf_coded = 220;
2935 else if (cpi->source_alt_ref_active)
2937 //int dist = cpi->common.frames_till_alt_ref_frame + cpi->common.frames_since_golden;
2938 cpi->prob_gf_coded -= 20;
2940 if (cpi->prob_gf_coded < 10)
2941 cpi->prob_gf_coded = 10;
2948 // 1 = key, 0 = inter
2949 static int decide_key_frame(VP8_COMP *cpi)
2951 VP8_COMMON *cm = &cpi->common;
2953 int code_key_frame = FALSE;
2957 if (cpi->Speed > 11)
2960 // Clear down mmx registers
2961 vp8_clear_system_state(); //__asm emms;
2963 if ((cpi->compressor_speed == 2) && (cpi->Speed >= 5) && (cpi->sf.RD == 0))
2965 double change = 1.0 * abs((int)(cpi->intra_error - cpi->last_intra_error)) / (1 + cpi->last_intra_error);
2966 double change2 = 1.0 * abs((int)(cpi->prediction_error - cpi->last_prediction_error)) / (1 + cpi->last_prediction_error);
2967 double minerror = cm->MBs * 256;
2971 if (10 * cpi->intra_error / (1 + cpi->prediction_error) < 15
2972 && cpi->prediction_error > minerror
2973 && (change > .25 || change2 > .25))
2975 FILE *f = fopen("intra_inter.stt", "a");
2977 if (cpi->prediction_error <= 0)
2978 cpi->prediction_error = 1;
2980 fprintf(f, "%d %d %d %d %14.4f\n",
2981 cm->current_video_frame,
2982 (int) cpi->prediction_error,
2983 (int) cpi->intra_error,
2984 (int)((10 * cpi->intra_error) / cpi->prediction_error),
2992 cpi->last_intra_error = cpi->intra_error;
2993 cpi->last_prediction_error = cpi->prediction_error;
2995 if (10 * cpi->intra_error / (1 + cpi->prediction_error) < 15
2996 && cpi->prediction_error > minerror
2997 && (change > .25 || change2 > .25))
2999 /*(change > 1.4 || change < .75)&& cpi->this_frame_percent_intra > cpi->last_frame_percent_intra + 3*/
3007 // If the following are true we might as well code a key frame
3008 if (((cpi->this_frame_percent_intra == 100) &&
3009 (cpi->this_frame_percent_intra > (cpi->last_frame_percent_intra + 2))) ||
3010 ((cpi->this_frame_percent_intra > 95) &&
3011 (cpi->this_frame_percent_intra >= (cpi->last_frame_percent_intra + 5))))
3013 code_key_frame = TRUE;
3015 // in addition if the following are true and this is not a golden frame then code a key frame
3016 // Note that on golden frames there often seems to be a pop in intra useage anyway hence this
3017 // restriction is designed to prevent spurious key frames. The Intra pop needs to be investigated.
3018 else if (((cpi->this_frame_percent_intra > 60) &&
3019 (cpi->this_frame_percent_intra > (cpi->last_frame_percent_intra * 2))) ||
3020 ((cpi->this_frame_percent_intra > 75) &&
3021 (cpi->this_frame_percent_intra > (cpi->last_frame_percent_intra * 3 / 2))) ||
3022 ((cpi->this_frame_percent_intra > 90) &&
3023 (cpi->this_frame_percent_intra > (cpi->last_frame_percent_intra + 10))))
3025 if (!cm->refresh_golden_frame)
3026 code_key_frame = TRUE;
3029 return code_key_frame;
3033 #if !(CONFIG_REALTIME_ONLY)
3034 static void Pass1Encode(VP8_COMP *cpi, unsigned long *size, unsigned char *dest, unsigned int *frame_flags)
3039 set_quantizer(cpi, 26);
3041 scale_and_extend_source(cpi->un_scaled_source, cpi);
3042 vp8_first_pass(cpi);
3047 void write_cx_frame_to_file(YV12_BUFFER_CONFIG *frame, int this_frame)
3055 sprintf(filename, "cx\\y%04d.raw", this_frame);
3056 yframe = fopen(filename, "wb");
3058 for (i = 0; i < frame->y_height; i++)
3059 fwrite(frame->y_buffer + i * frame->y_stride, frame->y_width, 1, yframe);
3062 sprintf(filename, "cx\\u%04d.raw", this_frame);
3063 yframe = fopen(filename, "wb");
3065 for (i = 0; i < frame->uv_height; i++)
3066 fwrite(frame->u_buffer + i * frame->uv_stride, frame->uv_width, 1, yframe);
3069 sprintf(filename, "cx\\v%04d.raw", this_frame);
3070 yframe = fopen(filename, "wb");
3072 for (i = 0; i < frame->uv_height; i++)
3073 fwrite(frame->v_buffer + i * frame->uv_stride, frame->uv_width, 1, yframe);
3078 // return of 0 means drop frame
3080 // Function to test for conditions that indeicate we should loop
3081 // back and recode a frame.
3082 static BOOL recode_loop_test( VP8_COMP *cpi,
3083 int high_limit, int low_limit,
3084 int q, int maxq, int minq )
3086 BOOL force_recode = FALSE;
3087 VP8_COMMON *cm = &cpi->common;
3089 // Is frame recode allowed at all
3090 // Yes if either recode mode 1 is selected or mode two is selcted
3091 // and the frame is a key frame. golden frame or alt_ref_frame
3092 if ( (cpi->sf.recode_loop == 1) ||
3093 ( (cpi->sf.recode_loop == 2) &&
3094 ( (cm->frame_type == KEY_FRAME) ||
3095 cm->refresh_golden_frame ||
3096 cm->refresh_alt_ref_frame ) ) )
3098 // General over and under shoot tests
3099 if ( ((cpi->projected_frame_size > high_limit) && (q < maxq)) ||
3100 ((cpi->projected_frame_size < low_limit) && (q > minq)) )
3102 force_recode = TRUE;
3104 // Special Constrained quality tests
3105 else if (cpi->oxcf.end_usage == USAGE_CONSTRAINED_QUALITY)
3107 // Undershoot and below auto cq level
3108 if ( (q > cpi->cq_target_quality) &&
3109 (cpi->projected_frame_size <
3110 ((cpi->this_frame_target * 7) >> 3)))
3112 force_recode = TRUE;
3114 // Severe undershoot and between auto and user cq level
3115 else if ( (q > cpi->oxcf.cq_level) &&
3116 (cpi->projected_frame_size < cpi->min_frame_bandwidth) &&
3117 (cpi->active_best_quality > cpi->oxcf.cq_level))
3119 force_recode = TRUE;
3120 cpi->active_best_quality = cpi->oxcf.cq_level;
3125 return force_recode;
3128 void loopfilter_frame(VP8_COMP *cpi, VP8_COMMON *cm)
3132 cm->filter_level = 0;
3136 struct vpx_usec_timer timer;
3138 vp8_clear_system_state();
3140 vpx_usec_timer_start(&timer);
3141 if (cpi->sf.auto_filter == 0)
3142 vp8cx_pick_filter_level_fast(cpi->Source, cpi);
3145 vp8cx_pick_filter_level(cpi->Source, cpi);
3147 vpx_usec_timer_mark(&timer);
3148 cpi->time_pick_lpf += vpx_usec_timer_elapsed(&timer);
3151 #if CONFIG_MULTITHREAD
3152 if (cpi->b_multi_threaded)
3153 sem_post(&cpi->h_event_end_lpf); /* signal that we have set filter_level */
3156 if (cm->filter_level > 0)
3158 vp8cx_set_alt_lf_level(cpi, cm->filter_level);
3159 vp8_loop_filter_frame(cm, &cpi->mb.e_mbd, cm->filter_level);
3160 cm->last_filter_type = cm->filter_type;
3161 cm->last_sharpness_level = cm->sharpness_level;
3164 vp8_yv12_extend_frame_borders_ptr(cm->frame_to_show);
3167 YV12_BUFFER_CONFIG *lst_yv12 = &cm->yv12_fb[cm->lst_fb_idx];
3168 YV12_BUFFER_CONFIG *new_yv12 = &cm->yv12_fb[cm->new_fb_idx];
3169 YV12_BUFFER_CONFIG *gld_yv12 = &cm->yv12_fb[cm->gld_fb_idx];
3170 YV12_BUFFER_CONFIG *alt_yv12 = &cm->yv12_fb[cm->alt_fb_idx];
3171 // At this point the new frame has been encoded.
3172 // If any buffer copy / swapping is signaled it should be done here.
3173 if (cm->frame_type == KEY_FRAME)
3175 vp8_yv12_copy_frame_ptr(cm->frame_to_show, gld_yv12);
3176 vp8_yv12_copy_frame_ptr(cm->frame_to_show, alt_yv12);
3178 else // For non key frames
3180 // Code to copy between reference buffers
3181 if (cm->copy_buffer_to_arf)
3183 if (cm->copy_buffer_to_arf == 1)
3185 if (cm->refresh_last_frame)
3186 // We copy new_frame here because last and new buffers will already have been swapped if cm->refresh_last_frame is set.
3187 vp8_yv12_copy_frame_ptr(new_yv12, alt_yv12);
3189 vp8_yv12_copy_frame_ptr(lst_yv12, alt_yv12);
3191 else if (cm->copy_buffer_to_arf == 2)
3192 vp8_yv12_copy_frame_ptr(gld_yv12, alt_yv12);
3195 if (cm->copy_buffer_to_gf)
3197 if (cm->copy_buffer_to_gf == 1)
3199 if (cm->refresh_last_frame)
3200 // We copy new_frame here because last and new buffers will already have been swapped if cm->refresh_last_frame is set.
3201 vp8_yv12_copy_frame_ptr(new_yv12, gld_yv12);
3203 vp8_yv12_copy_frame_ptr(lst_yv12, gld_yv12);
3205 else if (cm->copy_buffer_to_gf == 2)
3206 vp8_yv12_copy_frame_ptr(alt_yv12, gld_yv12);
3212 static void encode_frame_to_data_rate
3215 unsigned long *size,
3216 unsigned char *dest,
3217 unsigned int *frame_flags
3221 int frame_over_shoot_limit;
3222 int frame_under_shoot_limit;
3232 int zbin_oq_low = 0;
3235 VP8_COMMON *cm = &cpi->common;
3236 int active_worst_qchanged = FALSE;
3238 int overshoot_seen = FALSE;
3239 int undershoot_seen = FALSE;
3240 int drop_mark = cpi->oxcf.drop_frames_water_mark * cpi->oxcf.optimal_buffer_level / 100;
3241 int drop_mark75 = drop_mark * 2 / 3;
3242 int drop_mark50 = drop_mark / 4;
3243 int drop_mark25 = drop_mark / 8;
3246 // Clear down mmx registers to allow floating point in what follows
3247 vp8_clear_system_state();
3249 // Test code for segmentation of gf/arf (0,0)
3250 //segmentation_test_function((VP8_PTR) cpi);
3252 #if CONFIG_REALTIME_ONLY
3253 if(cpi->oxcf.auto_key && cm->frame_type != KEY_FRAME)
3255 if(cpi->force_next_frame_intra)
3257 cm->frame_type = KEY_FRAME; /* delayed intra frame */
3260 cpi->force_next_frame_intra = 0;
3263 // For an alt ref frame in 2 pass we skip the call to the second pass function that sets the target bandwidth
3264 #if !(CONFIG_REALTIME_ONLY)
3268 if (cpi->common.refresh_alt_ref_frame)
3270 cpi->per_frame_bandwidth = cpi->gf_bits; // Per frame bit target for the alt ref frame
3271 cpi->target_bandwidth = cpi->gf_bits * cpi->output_frame_rate; // per second target bitrate
3276 cpi->per_frame_bandwidth = (int)(cpi->target_bandwidth / cpi->output_frame_rate);
3278 // Default turn off buffer to buffer copying
3279 cm->copy_buffer_to_gf = 0;
3280 cm->copy_buffer_to_arf = 0;
3282 // Clear zbin over-quant value and mode boost values.
3283 cpi->zbin_over_quant = 0;
3284 cpi->zbin_mode_boost = 0;
3286 // Enable or disable mode based tweaking of the zbin
3287 // For 2 Pass Only used where GF/ARF prediction quality
3288 // is above a threshold
3289 cpi->zbin_mode_boost = 0;
3290 cpi->zbin_mode_boost_enabled = TRUE;
3293 if ( cpi->gfu_boost <= 400 )
3295 cpi->zbin_mode_boost_enabled = FALSE;
3299 // Current default encoder behaviour for the altref sign bias
3300 if (cpi->source_alt_ref_active)
3301 cpi->common.ref_frame_sign_bias[ALTREF_FRAME] = 1;
3303 cpi->common.ref_frame_sign_bias[ALTREF_FRAME] = 0;
3305 // Check to see if a key frame is signalled
3306 // For two pass with auto key frame enabled cm->frame_type may already be set, but not for one pass.
3307 if ((cm->current_video_frame == 0) ||
3308 (cm->frame_flags & FRAMEFLAGS_KEY) ||
3309 (cpi->oxcf.auto_key && (cpi->frames_since_key % cpi->key_frame_frequency == 0)))
3311 // Key frame from VFW/auto-keyframe/first frame
3312 cm->frame_type = KEY_FRAME;
3315 // Set default state for segment and mode based loop filter update flags
3316 cpi->mb.e_mbd.update_mb_segmentation_map = 0;
3317 cpi->mb.e_mbd.update_mb_segmentation_data = 0;
3318 cpi->mb.e_mbd.mode_ref_lf_delta_update = 0;
3320 // Set various flags etc to special state if it is a key frame
3321 if (cm->frame_type == KEY_FRAME)
3325 // Reset the loop filter deltas and segmentation map
3326 setup_features(cpi);
3328 // If segmentation is enabled force a map update for key frames
3329 if (cpi->mb.e_mbd.segmentation_enabled)
3331 cpi->mb.e_mbd.update_mb_segmentation_map = 1;
3332 cpi->mb.e_mbd.update_mb_segmentation_data = 1;
3335 // The alternate reference frame cannot be active for a key frame
3336 cpi->source_alt_ref_active = FALSE;
3338 // Reset the RD threshold multipliers to default of * 1 (128)
3339 for (i = 0; i < MAX_MODES; i++)
3341 cpi->rd_thresh_mult[i] = 128;
3345 // Test code for segmentation
3346 //if ( (cm->frame_type == KEY_FRAME) || ((cm->current_video_frame % 2) == 0))
3347 //if ( (cm->current_video_frame % 2) == 0 )
3348 // enable_segmentation((VP8_PTR)cpi);
3350 // disable_segmentation((VP8_PTR)cpi);
3353 // Experimental code for lagged compress and one pass
3354 // Initialise one_pass GF frames stats
3355 // Update stats used for GF selection
3356 //if ( cpi->pass == 0 )
3358 cpi->one_pass_frame_index = cm->current_video_frame % MAX_LAG_BUFFERS;
3360 cpi->one_pass_frame_stats[cpi->one_pass_frame_index ].frames_so_far = 0;
3361 cpi->one_pass_frame_stats[cpi->one_pass_frame_index ].frame_intra_error = 0.0;
3362 cpi->one_pass_frame_stats[cpi->one_pass_frame_index ].frame_coded_error = 0.0;
3363 cpi->one_pass_frame_stats[cpi->one_pass_frame_index ].frame_pcnt_inter = 0.0;
3364 cpi->one_pass_frame_stats[cpi->one_pass_frame_index ].frame_pcnt_motion = 0.0;
3365 cpi->one_pass_frame_stats[cpi->one_pass_frame_index ].frame_mvr = 0.0;
3366 cpi->one_pass_frame_stats[cpi->one_pass_frame_index ].frame_mvr_abs = 0.0;
3367 cpi->one_pass_frame_stats[cpi->one_pass_frame_index ].frame_mvc = 0.0;
3368 cpi->one_pass_frame_stats[cpi->one_pass_frame_index ].frame_mvc_abs = 0.0;
3372 update_rd_ref_frame_probs(cpi);
3374 if (cpi->drop_frames_allowed)
3376 // The reset to decimation 0 is only done here for one pass.
3377 // Once it is set two pass leaves decimation on till the next kf.
3378 if ((cpi->buffer_level > drop_mark) && (cpi->decimation_factor > 0))
3379 cpi->decimation_factor --;
3381 if (cpi->buffer_level > drop_mark75 && cpi->decimation_factor > 0)
3382 cpi->decimation_factor = 1;
3384 else if (cpi->buffer_level < drop_mark25 && (cpi->decimation_factor == 2 || cpi->decimation_factor == 3))
3386 cpi->decimation_factor = 3;
3388 else if (cpi->buffer_level < drop_mark50 && (cpi->decimation_factor == 1 || cpi->decimation_factor == 2))
3390 cpi->decimation_factor = 2;
3392 else if (cpi->buffer_level < drop_mark75 && (cpi->decimation_factor == 0 || cpi->decimation_factor == 1))
3394 cpi->decimation_factor = 1;
3397 //vpx_log("Encoder: Decimation Factor: %d \n",cpi->decimation_factor);
3400 // The following decimates the frame rate according to a regular pattern (i.e. to 1/2 or 2/3 frame rate)
3401 // This can be used to help prevent buffer under-run in CBR mode. Alternatively it might be desirable in
3402 // some situations to drop frame rate but throw more bits at each frame.
3404 // Note that dropping a key frame can be problematic if spatial resampling is also active
3405 if (cpi->decimation_factor > 0)
3407 switch (cpi->decimation_factor)
3410 cpi->per_frame_bandwidth = cpi->per_frame_bandwidth * 3 / 2;
3413 cpi->per_frame_bandwidth = cpi->per_frame_bandwidth * 5 / 4;
3416 cpi->per_frame_bandwidth = cpi->per_frame_bandwidth * 5 / 4;
3420 // Note that we should not throw out a key frame (especially when spatial resampling is enabled).
3421 if ((cm->frame_type == KEY_FRAME)) // && cpi->oxcf.allow_spatial_resampling )
3423 cpi->decimation_count = cpi->decimation_factor;
3425 else if (cpi->decimation_count > 0)
3427 cpi->decimation_count --;
3428 cpi->bits_off_target += cpi->av_per_frame_bandwidth;
3429 cm->current_video_frame++;
3430 cpi->frames_since_key++;
3436 cpi->buffer_level = cpi->bits_off_target;
3441 cpi->decimation_count = cpi->decimation_factor;
3444 // Decide how big to make the frame
3445 if (!vp8_pick_frame_size(cpi))
3447 cm->current_video_frame++;
3448 cpi->frames_since_key++;
3452 // Reduce active_worst_allowed_q for CBR if our buffer is getting too full.
3453 // This has a knock on effect on active best quality as well.
3454 // For CBR if the buffer reaches its maximum level then we can no longer
3455 // save up bits for later frames so we might as well use them up
3456 // on the current frame.
3457 if ((cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER) &&
3458 (cpi->buffer_level >= cpi->oxcf.optimal_buffer_level) && cpi->buffered_mode)
3460 int Adjustment = cpi->active_worst_quality / 4; // Max adjustment is 1/4
3466 if (cpi->buffer_level < cpi->oxcf.maximum_buffer_size)
3468 buff_lvl_step = (cpi->oxcf.maximum_buffer_size - cpi->oxcf.optimal_buffer_level) / Adjustment;
3472 Adjustment = (cpi->buffer_level - cpi->oxcf.optimal_buffer_level) / buff_lvl_step;
3473 cpi->active_worst_quality -= Adjustment;
3478 cpi->active_worst_quality -= Adjustment;
3483 // Set an active best quality and if necessary active worst quality
3484 // There is some odd behaviour for one pass here that needs attention.
3485 if ( (cpi->pass == 2) || (cpi->ni_frames > 150))
3487 vp8_clear_system_state();
3489 Q = cpi->active_worst_quality;
3491 if ( cm->frame_type == KEY_FRAME )
3493 if ( cpi->pass == 2 )
3495 if (cpi->gfu_boost > 600)
3496 cpi->active_best_quality = kf_low_motion_minq[Q];
3498 cpi->active_best_quality = kf_high_motion_minq[Q];
3500 // Special case for key frames forced because we have reached
3501 // the maximum key frame interval. Here force the Q to a range
3502 // based on the ambient Q to reduce the risk of popping
3503 if ( cpi->this_key_frame_forced )
3505 if ( cpi->active_best_quality > cpi->avg_frame_qindex * 7/8)
3506 cpi->active_best_quality = cpi->avg_frame_qindex * 7/8;
3507 else if ( cpi->active_best_quality < cpi->avg_frame_qindex >> 2 )
3508 cpi->active_best_quality = cpi->avg_frame_qindex >> 2;
3511 // One pass more conservative
3513 cpi->active_best_quality = kf_high_motion_minq[Q];
3516 else if (cm->refresh_golden_frame || cpi->common.refresh_alt_ref_frame)
3518 // Use the lower of cpi->active_worst_quality and recent
3519 // average Q as basis for GF/ARF Q limit unless last frame was
3521 if ( (cpi->frames_since_key > 1) &&
3522 (cpi->avg_frame_qindex < cpi->active_worst_quality) )
3524 Q = cpi->avg_frame_qindex;
3526 if ( (cpi->oxcf.end_usage == USAGE_CONSTRAINED_QUALITY) &&
3527 (Q < cpi->oxcf.cq_level) )
3529 Q = cpi->oxcf.cq_level;
3533 if ( cpi->pass == 2 )
3535 if ( cpi->gfu_boost > 1000 )
3536 cpi->active_best_quality = gf_low_motion_minq[Q];
3537 else if ( cpi->gfu_boost < 400 )
3538 cpi->active_best_quality = gf_high_motion_minq[Q];
3540 cpi->active_best_quality = gf_mid_motion_minq[Q];
3542 // One pass more conservative
3544 cpi->active_best_quality = gf_high_motion_minq[Q];
3548 cpi->active_best_quality = inter_minq[Q];
3550 // For the constant/constrained quality mode we dont want
3551 // the quality to rise above the cq level.
3552 if ((cpi->oxcf.end_usage == USAGE_CONSTRAINED_QUALITY) &&
3553 (cpi->active_best_quality < cpi->cq_target_quality) )
3555 // If we are strongly undershooting the target rate in the last
3556 // frames then use the user passed in cq value not the auto
3558 if ( cpi->rolling_actual_bits < cpi->min_frame_bandwidth )
3559 cpi->active_best_quality = cpi->oxcf.cq_level;
3561 cpi->active_best_quality = cpi->cq_target_quality;
3565 // If CBR and the buffer is as full then it is reasonable to allow
3566 // higher quality on the frames to prevent bits just going to waste.
3567 if (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER)
3569 // Note that the use of >= here elliminates the risk of a devide
3570 // by 0 error in the else if clause
3571 if (cpi->buffer_level >= cpi->oxcf.maximum_buffer_size)
3572 cpi->active_best_quality = cpi->best_quality;
3574 else if (cpi->buffer_level > cpi->oxcf.optimal_buffer_level)
3576 int Fraction = ((cpi->buffer_level - cpi->oxcf.optimal_buffer_level) * 128) / (cpi->oxcf.maximum_buffer_size - cpi->oxcf.optimal_buffer_level);
3577 int min_qadjustment = ((cpi->active_best_quality - cpi->best_quality) * Fraction) / 128;
3579 cpi->active_best_quality -= min_qadjustment;
3583 // Make sure constrained quality mode limits are adhered to for the first
3584 // few frames of one pass encodes
3585 else if (cpi->oxcf.end_usage == USAGE_CONSTRAINED_QUALITY)
3587 if ( (cm->frame_type == KEY_FRAME) ||
3588 cm->refresh_golden_frame || cpi->common.refresh_alt_ref_frame )
3590 cpi->active_best_quality = cpi->best_quality;
3592 else if (cpi->active_best_quality < cpi->cq_target_quality)
3594 cpi->active_best_quality = cpi->cq_target_quality;
3598 // Clip the active best and worst quality values to limits
3599 if (cpi->active_worst_quality > cpi->worst_quality)
3600 cpi->active_worst_quality = cpi->worst_quality;
3602 if (cpi->active_best_quality < cpi->best_quality)
3603 cpi->active_best_quality = cpi->best_quality;
3604 else if (cpi->active_best_quality > cpi->active_worst_quality)
3605 cpi->active_best_quality = cpi->active_worst_quality;
3607 // Determine initial Q to try
3608 Q = vp8_regulate_q(cpi, cpi->this_frame_target);
3609 last_zbin_oq = cpi->zbin_over_quant;
3611 // Set highest allowed value for Zbin over quant
3612 if (cm->frame_type == KEY_FRAME)
3613 zbin_oq_high = 0; //ZBIN_OQ_MAX/16
3614 else if (cm->refresh_alt_ref_frame || (cm->refresh_golden_frame && !cpi->source_alt_ref_active))
3617 zbin_oq_high = ZBIN_OQ_MAX;
3619 // Setup background Q adjustment for error resilliant mode
3620 if (cpi->cyclic_refresh_mode_enabled)
3621 cyclic_background_refresh(cpi, Q, 0);
3623 vp8_compute_frame_size_bounds(cpi, &frame_under_shoot_limit, &frame_over_shoot_limit);
3625 // Limit Q range for the adaptive loop.
3626 bottom_index = cpi->active_best_quality;
3627 top_index = cpi->active_worst_quality;
3628 q_low = cpi->active_best_quality;
3629 q_high = cpi->active_worst_quality;
3631 vp8_save_coding_context(cpi);
3636 scale_and_extend_source(cpi->un_scaled_source, cpi);
3637 #if !(CONFIG_REALTIME_ONLY) && CONFIG_POSTPROC
3639 if (cpi->oxcf.noise_sensitivity > 0)
3644 switch (cpi->oxcf.noise_sensitivity)
3667 if (cm->frame_type == KEY_FRAME)
3669 vp8_de_noise(cpi->Source, cpi->Source, l , 1, 0, RTCD(postproc));
3673 vp8_de_noise(cpi->Source, cpi->Source, l , 1, 0, RTCD(postproc));
3675 src = cpi->Source->y_buffer;
3677 if (cpi->Source->y_stride < 0)
3679 src += cpi->Source->y_stride * (cpi->Source->y_height - 1);
3686 #ifdef OUTPUT_YUV_SRC
3687 vp8_write_yuv_frame(cpi->Source);
3692 vp8_clear_system_state(); //__asm emms;
3695 if(cpi->is_src_frame_alt_ref)
3699 set_quantizer(cpi, Q);
3702 // setup skip prob for costing in mode/mv decision
3703 if (cpi->common.mb_no_coeff_skip)
3705 cpi->prob_skip_false = cpi->base_skip_false_prob[Q];
3707 if (cm->frame_type != KEY_FRAME)
3709 if (cpi->common.refresh_alt_ref_frame)
3711 if (cpi->last_skip_false_probs[2] != 0)
3712 cpi->prob_skip_false = cpi->last_skip_false_probs[2];
3715 if(cpi->last_skip_false_probs[2]!=0 && abs(Q- cpi->last_skip_probs_q[2])<=16 )
3716 cpi->prob_skip_false = cpi->last_skip_false_probs[2];
3717 else if (cpi->last_skip_false_probs[2]!=0)
3718 cpi->prob_skip_false = (cpi->last_skip_false_probs[2] + cpi->prob_skip_false ) / 2;
3721 else if (cpi->common.refresh_golden_frame)
3723 if (cpi->last_skip_false_probs[1] != 0)
3724 cpi->prob_skip_false = cpi->last_skip_false_probs[1];
3727 if(cpi->last_skip_false_probs[1]!=0 && abs(Q- cpi->last_skip_probs_q[1])<=16 )
3728 cpi->prob_skip_false = cpi->last_skip_false_probs[1];
3729 else if (cpi->last_skip_false_probs[1]!=0)
3730 cpi->prob_skip_false = (cpi->last_skip_false_probs[1] + cpi->prob_skip_false ) / 2;
3735 if (cpi->last_skip_false_probs[0] != 0)
3736 cpi->prob_skip_false = cpi->last_skip_false_probs[0];
3739 if(cpi->last_skip_false_probs[0]!=0 && abs(Q- cpi->last_skip_probs_q[0])<=16 )
3740 cpi->prob_skip_false = cpi->last_skip_false_probs[0];
3741 else if(cpi->last_skip_false_probs[0]!=0)
3742 cpi->prob_skip_false = (cpi->last_skip_false_probs[0] + cpi->prob_skip_false ) / 2;
3746 //as this is for cost estimate, let's make sure it does not go extreme eitehr way
3747 if (cpi->prob_skip_false < 5)
3748 cpi->prob_skip_false = 5;
3750 if (cpi->prob_skip_false > 250)
3751 cpi->prob_skip_false = 250;
3753 if (cpi->is_src_frame_alt_ref)
3754 cpi->prob_skip_false = 1;
3763 FILE *f = fopen("skip.stt", "a");
3764 fprintf(f, "%d, %d, %4d ", cpi->common.refresh_golden_frame, cpi->common.refresh_alt_ref_frame, cpi->prob_skip_false);
3772 if (cm->frame_type == KEY_FRAME)
3774 resize_key_frame(cpi);
3775 vp8_setup_key_frame(cpi);
3778 // transform / motion compensation build reconstruction frame
3779 vp8_encode_frame(cpi);
3781 cpi->projected_frame_size -= vp8_estimate_entropy_savings(cpi);
3782 cpi->projected_frame_size = (cpi->projected_frame_size > 0) ? cpi->projected_frame_size : 0;
3784 vp8_clear_system_state(); //__asm emms;
3786 // Test to see if the stats generated for this frame indicate that we should have coded a key frame
3787 // (assuming that we didn't)!
3788 if (cpi->pass != 2 && cpi->oxcf.auto_key && cm->frame_type != KEY_FRAME)
3791 #if CONFIG_REALTIME_ONLY
3793 /* we don't do re-encoding in realtime mode
3794 * if key frame is decided than we force it on next frame */
3795 cpi->force_next_frame_intra = decide_key_frame(cpi);
3798 if (decide_key_frame(cpi))
3800 // Reset all our sizing numbers and recode
3801 cm->frame_type = KEY_FRAME;
3803 vp8_pick_frame_size(cpi);
3805 // Clear the Alt reference frame active flag when we have a key frame
3806 cpi->source_alt_ref_active = FALSE;
3808 // Reset the loop filter deltas and segmentation map
3809 setup_features(cpi);
3811 // If segmentation is enabled force a map update for key frames
3812 if (cpi->mb.e_mbd.segmentation_enabled)
3814 cpi->mb.e_mbd.update_mb_segmentation_map = 1;
3815 cpi->mb.e_mbd.update_mb_segmentation_data = 1;
3818 vp8_restore_coding_context(cpi);
3820 Q = vp8_regulate_q(cpi, cpi->this_frame_target);
3822 vp8_compute_frame_size_bounds(cpi, &frame_under_shoot_limit, &frame_over_shoot_limit);
3824 // Limit Q range for the adaptive loop.
3825 bottom_index = cpi->active_best_quality;
3826 top_index = cpi->active_worst_quality;
3827 q_low = cpi->active_best_quality;
3828 q_high = cpi->active_worst_quality;
3838 vp8_clear_system_state();
3840 if (frame_over_shoot_limit == 0)
3841 frame_over_shoot_limit = 1;
3843 // Are we are overshooting and up against the limit of active max Q.
3844 if (((cpi->pass != 2) || (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER)) &&
3845 (Q == cpi->active_worst_quality) &&
3846 (cpi->active_worst_quality < cpi->worst_quality) &&
3847 (cpi->projected_frame_size > frame_over_shoot_limit))
3849 int over_size_percent = ((cpi->projected_frame_size - frame_over_shoot_limit) * 100) / frame_over_shoot_limit;
3851 // If so is there any scope for relaxing it
3852 while ((cpi->active_worst_quality < cpi->worst_quality) && (over_size_percent > 0))
3854 cpi->active_worst_quality++;
3855 top_index = cpi->active_worst_quality;
3856 over_size_percent = (int)(over_size_percent * 0.96); // Assume 1 qstep = about 4% on frame size.
3859 // If we have updated the active max Q do not call vp8_update_rate_correction_factors() this loop.
3860 active_worst_qchanged = TRUE;
3863 active_worst_qchanged = FALSE;
3865 #if !(CONFIG_REALTIME_ONLY)
3866 // Special case handling for forced key frames
3867 if ( (cm->frame_type == KEY_FRAME) && cpi->this_key_frame_forced )
3870 int kf_err = vp8_calc_ss_err(cpi->Source,
3871 &cm->yv12_fb[cm->new_fb_idx],
3872 IF_RTCD(&cpi->rtcd.variance));
3874 // The key frame is not good enough
3875 if ( kf_err > ((cpi->ambient_err * 7) >> 3) )
3878 q_high = (Q > q_low) ? (Q - 1) : q_low;
3881 Q = (q_high + q_low) >> 1;
3883 // The key frame is much better than the previous frame
3884 else if ( kf_err < (cpi->ambient_err >> 1) )
3887 q_low = (Q < q_high) ? (Q + 1) : q_high;
3890 Q = (q_high + q_low + 1) >> 1;
3893 // Clamp Q to upper and lower limits:
3899 Loop = ((Q != last_q)) ? TRUE : FALSE;
3902 // Is the projected frame size out of range and are we allowed to attempt to recode.
3903 else if ( recode_loop_test( cpi,
3904 frame_over_shoot_limit, frame_under_shoot_limit,
3905 Q, top_index, bottom_index ) )
3910 // Frame size out of permitted range:
3911 // Update correction factor & compute new Q to try...
3913 // Frame is too large
3914 if (cpi->projected_frame_size > cpi->this_frame_target)
3916 //if ( cpi->zbin_over_quant == 0 )
3917 q_low = (Q < q_high) ? (Q + 1) : q_high; // Raise Qlow as to at least the current value
3919 if (cpi->zbin_over_quant > 0) // If we are using over quant do the same for zbin_oq_low
3920 zbin_oq_low = (cpi->zbin_over_quant < zbin_oq_high) ? (cpi->zbin_over_quant + 1) : zbin_oq_high;
3922 //if ( undershoot_seen || (Q == MAXQ) )
3923 if (undershoot_seen)
3925 // Update rate_correction_factor unless cpi->active_worst_quality has changed.
3926 if (!active_worst_qchanged)
3927 vp8_update_rate_correction_factors(cpi, 1);
3929 Q = (q_high + q_low + 1) / 2;
3931 // Adjust cpi->zbin_over_quant (only allowed when Q is max)
3933 cpi->zbin_over_quant = 0;
3936 zbin_oq_low = (cpi->zbin_over_quant < zbin_oq_high) ? (cpi->zbin_over_quant + 1) : zbin_oq_high;
3937 cpi->zbin_over_quant = (zbin_oq_high + zbin_oq_low) / 2;
3942 // Update rate_correction_factor unless cpi->active_worst_quality has changed.
3943 if (!active_worst_qchanged)
3944 vp8_update_rate_correction_factors(cpi, 0);
3946 Q = vp8_regulate_q(cpi, cpi->this_frame_target);
3948 while (((Q < q_low) || (cpi->zbin_over_quant < zbin_oq_low)) && (Retries < 10))
3950 vp8_update_rate_correction_factors(cpi, 0);
3951 Q = vp8_regulate_q(cpi, cpi->this_frame_target);
3956 overshoot_seen = TRUE;
3958 // Frame is too small
3961 if (cpi->zbin_over_quant == 0)
3962 q_high = (Q > q_low) ? (Q - 1) : q_low; // Lower q_high if not using over quant
3963 else // else lower zbin_oq_high
3964 zbin_oq_high = (cpi->zbin_over_quant > zbin_oq_low) ? (cpi->zbin_over_quant - 1) : zbin_oq_low;
3968 // Update rate_correction_factor unless cpi->active_worst_quality has changed.
3969 if (!active_worst_qchanged)
3970 vp8_update_rate_correction_factors(cpi, 1);
3972 Q = (q_high + q_low) / 2;
3974 // Adjust cpi->zbin_over_quant (only allowed when Q is max)
3976 cpi->zbin_over_quant = 0;
3978 cpi->zbin_over_quant = (zbin_oq_high + zbin_oq_low) / 2;
3982 // Update rate_correction_factor unless cpi->active_worst_quality has changed.
3983 if (!active_worst_qchanged)
3984 vp8_update_rate_correction_factors(cpi, 0);
3986 Q = vp8_regulate_q(cpi, cpi->this_frame_target);
3988 // Special case reset for qlow for constrained quality.
3989 // This should only trigger where there is very substantial
3990 // undershoot on a frame and the auto cq level is above
3991 // the user passsed in value.
3992 if ( (cpi->oxcf.end_usage == USAGE_CONSTRAINED_QUALITY) &&
3998 while (((Q > q_high) || (cpi->zbin_over_quant > zbin_oq_high)) && (Retries < 10))
4000 vp8_update_rate_correction_factors(cpi, 0);
4001 Q = vp8_regulate_q(cpi, cpi->this_frame_target);
4006 undershoot_seen = TRUE;
4009 // Clamp Q to upper and lower limits:
4015 // Clamp cpi->zbin_over_quant
4016 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;
4018 //Loop = ((Q != last_q) || (last_zbin_oq != cpi->zbin_over_quant)) ? TRUE : FALSE;
4019 Loop = ((Q != last_q)) ? TRUE : FALSE;
4020 last_zbin_oq = cpi->zbin_over_quant;
4026 if (cpi->is_src_frame_alt_ref)
4031 vp8_restore_coding_context(cpi);
4034 cpi->tot_recode_hits++;
4038 while (Loop == TRUE);
4041 // Experimental code for lagged and one pass
4042 // Update stats used for one pass GF selection
4046 double frame_intra_error;
4047 double frame_coded_error;
4048 double frame_pcnt_inter;
4049 double frame_pcnt_motion;
4051 double frame_mvr_abs;
4053 double frame_mvc_abs;
4056 cpi->one_pass_frame_stats[cpi->one_pass_frame_index].frame_coded_error = (double)cpi->prediction_error;
4057 cpi->one_pass_frame_stats[cpi->one_pass_frame_index].frame_intra_error = (double)cpi->intra_error;
4058 cpi->one_pass_frame_stats[cpi->one_pass_frame_index].frame_pcnt_inter = (double)(100 - cpi->this_frame_percent_intra) / 100.0;
4062 // Special case code to reduce pulsing when key frames are forced at a
4063 // fixed interval. Note the reconstruction error if it is the frame before
4064 // the force key frame
4065 if ( cpi->next_key_frame_forced && (cpi->frames_to_key == 0) )
4067 cpi->ambient_err = vp8_calc_ss_err(cpi->Source,
4068 &cm->yv12_fb[cm->new_fb_idx],
4069 IF_RTCD(&cpi->rtcd.variance));
4072 // This frame's MVs are saved and will be used in next frame's MV prediction.
4073 // 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.
4074 if(cm->show_frame) //do not save for altref frame
4078 MODE_INFO *tmp = cm->mip; //point to beginning of allocated MODE_INFO arrays.
4080 if(cm->frame_type != KEY_FRAME)
4082 for (mb_row = 0; mb_row < cm->mb_rows+1; mb_row ++)
4084 for (mb_col = 0; mb_col < cm->mb_cols+1; mb_col ++)
4086 if(tmp->mbmi.ref_frame != INTRA_FRAME)
4087 cpi->lfmv[mb_col + mb_row*(cm->mode_info_stride+1)].as_int = tmp->mbmi.mv.as_int;
4089 cpi->lf_ref_frame_sign_bias[mb_col + mb_row*(cm->mode_info_stride+1)] = cm->ref_frame_sign_bias[tmp->mbmi.ref_frame];
4090 cpi->lf_ref_frame[mb_col + mb_row*(cm->mode_info_stride+1)] = tmp->mbmi.ref_frame;
4097 // Update the GF useage maps.
4098 // This is done after completing the compression of a frame when all modes etc. are finalized but before loop filter
4099 // This is done after completing the compression of a frame when all modes etc. are finalized but before loop filter
4100 vp8_update_gf_useage_maps(cpi, cm, &cpi->mb);
4102 if (cm->frame_type == KEY_FRAME)
4103 cm->refresh_last_frame = 1;
4107 FILE *f = fopen("gfactive.stt", "a");
4108 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);
4113 // For inter frames the current default behaviour is that when cm->refresh_golden_frame is set we copy the old GF over to the ARF buffer
4114 // This is purely an encoder descision at present.
4115 if (!cpi->oxcf.error_resilient_mode && cm->refresh_golden_frame)
4116 cm->copy_buffer_to_arf = 2;
4118 cm->copy_buffer_to_arf = 0;
4120 if (cm->refresh_last_frame)
4122 vp8_swap_yv12_buffer(&cm->yv12_fb[cm->lst_fb_idx], &cm->yv12_fb[cm->new_fb_idx]);
4123 cm->frame_to_show = &cm->yv12_fb[cm->lst_fb_idx];
4126 cm->frame_to_show = &cm->yv12_fb[cm->new_fb_idx];
4129 #if CONFIG_MULTITHREAD
4130 if (cpi->b_multi_threaded)
4132 sem_post(&cpi->h_event_start_lpf); /* start loopfilter in separate thread */
4137 loopfilter_frame(cpi, cm);
4140 if (cpi->oxcf.error_resilient_mode == 1)
4142 cm->refresh_entropy_probs = 0;
4145 #if CONFIG_MULTITHREAD
4146 /* wait that filter_level is picked so that we can continue with stream packing */
4147 if (cpi->b_multi_threaded)
4148 sem_wait(&cpi->h_event_end_lpf);
4151 // build the bitstream
4152 vp8_pack_bitstream(cpi, dest, size);
4154 #if CONFIG_MULTITHREAD
4155 /* wait for loopfilter thread done */
4156 if (cpi->b_multi_threaded)
4158 sem_wait(&cpi->h_event_end_lpf);
4162 /* Move storing frame_type out of the above loop since it is also
4163 * needed in motion search besides loopfilter */
4164 cm->last_frame_type = cm->frame_type;
4166 // Update rate control heuristics
4167 cpi->total_byte_count += (*size);
4168 cpi->projected_frame_size = (*size) << 3;
4170 if (!active_worst_qchanged)
4171 vp8_update_rate_correction_factors(cpi, 2);
4173 cpi->last_q[cm->frame_type] = cm->base_qindex;
4175 if (cm->frame_type == KEY_FRAME)
4177 vp8_adjust_key_frame_context(cpi);
4180 // Keep a record of ambient average Q.
4181 if (cm->frame_type != KEY_FRAME)
4182 cpi->avg_frame_qindex = (2 + 3 * cpi->avg_frame_qindex + cm->base_qindex) >> 2;
4184 // Keep a record from which we can calculate the average Q excluding GF updates and key frames
4185 if ((cm->frame_type != KEY_FRAME) && !cm->refresh_golden_frame && !cm->refresh_alt_ref_frame)
4189 // Calculate the average Q for normal inter frames (not key or GFU
4191 if ( cpi->pass == 2 )
4193 cpi->ni_tot_qi += Q;
4194 cpi->ni_av_qi = (cpi->ni_tot_qi / cpi->ni_frames);
4198 // Damp value for first few frames
4199 if (cpi->ni_frames > 150 )
4201 cpi->ni_tot_qi += Q;
4202 cpi->ni_av_qi = (cpi->ni_tot_qi / cpi->ni_frames);
4204 // For one pass, early in the clip ... average the current frame Q
4205 // value with the worstq entered by the user as a dampening measure
4208 cpi->ni_tot_qi += Q;
4209 cpi->ni_av_qi = ((cpi->ni_tot_qi / cpi->ni_frames) + cpi->worst_quality + 1) / 2;
4212 // If the average Q is higher than what was used in the last frame
4213 // (after going through the recode loop to keep the frame size within range)
4214 // then use the last frame value - 1.
4215 // The -1 is designed to stop Q and hence the data rate, from progressively
4216 // falling away during difficult sections, but at the same time reduce the number of
4217 // itterations around the recode loop.
4218 if (Q > cpi->ni_av_qi)
4219 cpi->ni_av_qi = Q - 1;
4225 // If the frame was massively oversize and we are below optimal buffer level drop next frame
4226 if ((cpi->drop_frames_allowed) &&
4227 (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER) &&
4228 (cpi->buffer_level < cpi->oxcf.drop_frames_water_mark * cpi->oxcf.optimal_buffer_level / 100) &&
4229 (cpi->projected_frame_size > (4 * cpi->this_frame_target)))
4231 cpi->drop_frame = TRUE;
4236 // Set the count for maximum consequative dropped frames based upon the ratio of
4237 // this frame size to the target average per frame bandwidth.
4238 // (cpi->av_per_frame_bandwidth > 0) is just a sanity check to prevent / 0.
4239 if (cpi->drop_frames_allowed && (cpi->av_per_frame_bandwidth > 0))
4241 cpi->max_drop_count = cpi->projected_frame_size / cpi->av_per_frame_bandwidth;
4243 if (cpi->max_drop_count > cpi->max_consec_dropped_frames)
4244 cpi->max_drop_count = cpi->max_consec_dropped_frames;
4247 // Update the buffer level variable.
4248 // Non-viewable frames are a special case and are treated as pure overhead.
4249 if ( !cm->show_frame )
4250 cpi->bits_off_target -= cpi->projected_frame_size;
4252 cpi->bits_off_target += cpi->av_per_frame_bandwidth - cpi->projected_frame_size;
4254 // Rolling monitors of whether we are over or underspending used to help regulate min and Max Q in two pass.
4255 cpi->rolling_target_bits = ((cpi->rolling_target_bits * 3) + cpi->this_frame_target + 2) / 4;
4256 cpi->rolling_actual_bits = ((cpi->rolling_actual_bits * 3) + cpi->projected_frame_size + 2) / 4;
4257 cpi->long_rolling_target_bits = ((cpi->long_rolling_target_bits * 31) + cpi->this_frame_target + 16) / 32;
4258 cpi->long_rolling_actual_bits = ((cpi->long_rolling_actual_bits * 31) + cpi->projected_frame_size + 16) / 32;
4260 // Actual bits spent
4261 cpi->total_actual_bits += cpi->projected_frame_size;
4264 cpi->total_target_vs_actual += (cpi->this_frame_target - cpi->projected_frame_size);
4266 cpi->buffer_level = cpi->bits_off_target;
4268 // Update bits left to the kf and gf groups to account for overshoot or undershoot on these frames
4269 if (cm->frame_type == KEY_FRAME)
4271 cpi->kf_group_bits += cpi->this_frame_target - cpi->projected_frame_size;
4273 if (cpi->kf_group_bits < 0)
4274 cpi->kf_group_bits = 0 ;
4276 else if (cm->refresh_golden_frame || cm->refresh_alt_ref_frame)
4278 cpi->gf_group_bits += cpi->this_frame_target - cpi->projected_frame_size;
4280 if (cpi->gf_group_bits < 0)
4281 cpi->gf_group_bits = 0 ;
4284 if (cm->frame_type != KEY_FRAME)
4286 if (cpi->common.refresh_alt_ref_frame)
4288 cpi->last_skip_false_probs[2] = cpi->prob_skip_false;
4289 cpi->last_skip_probs_q[2] = cm->base_qindex;
4291 else if (cpi->common.refresh_golden_frame)
4293 cpi->last_skip_false_probs[1] = cpi->prob_skip_false;
4294 cpi->last_skip_probs_q[1] = cm->base_qindex;
4298 cpi->last_skip_false_probs[0] = cpi->prob_skip_false;
4299 cpi->last_skip_probs_q[0] = cm->base_qindex;
4301 //update the baseline
4302 cpi->base_skip_false_prob[cm->base_qindex] = cpi->prob_skip_false;
4307 #if 0 && CONFIG_PSNR
4309 FILE *f = fopen("tmp.stt", "a");
4311 vp8_clear_system_state(); //__asm emms;
4313 if (cpi->total_coded_error_left != 0.0)
4314 fprintf(f, "%10d %10d %10d %10d %10d %10d %10d %10d %6d %6d"
4315 "%6d %6d %6d %5d %5d %5d %8d %8.2f %10d %10.3f"
4317 cpi->common.current_video_frame, cpi->this_frame_target,
4318 cpi->projected_frame_size,
4319 (cpi->projected_frame_size - cpi->this_frame_target),
4320 (int)cpi->total_target_vs_actual,
4321 (cpi->oxcf.starting_buffer_level-cpi->bits_off_target),
4322 (int)cpi->total_actual_bits, cm->base_qindex,
4323 cpi->active_best_quality, cpi->active_worst_quality,
4324 cpi->ni_av_qi, cpi->cq_target_quality, cpi->zbin_over_quant,
4325 //cpi->avg_frame_qindex, cpi->zbin_over_quant,
4326 cm->refresh_golden_frame, cm->refresh_alt_ref_frame,
4327 cm->frame_type, cpi->gfu_boost,
4328 cpi->est_max_qcorrection_factor, (int)cpi->bits_left,
4329 cpi->total_coded_error_left,
4330 (double)cpi->bits_left / cpi->total_coded_error_left,
4331 cpi->tot_recode_hits);
4333 fprintf(f, "%10d %10d %10d %10d %10d %10d %10d %10d %6d %6d"
4334 "%6d %6d %6d %5d %5d %5d %8d %8.2f %10d %10.3f"
4336 cpi->common.current_video_frame,
4337 cpi->this_frame_target, cpi->projected_frame_size,
4338 (cpi->projected_frame_size - cpi->this_frame_target),
4339 (int)cpi->total_target_vs_actual,
4340 (cpi->oxcf.starting_buffer_level-cpi->bits_off_target),
4341 (int)cpi->total_actual_bits, cm->base_qindex,
4342 cpi->active_best_quality, cpi->active_worst_quality,
4343 cpi->ni_av_qi, cpi->cq_target_quality, cpi->zbin_over_quant,
4344 //cpi->avg_frame_qindex, cpi->zbin_over_quant,
4345 cm->refresh_golden_frame, cm->refresh_alt_ref_frame,
4346 cm->frame_type, cpi->gfu_boost,
4347 cpi->est_max_qcorrection_factor, (int)cpi->bits_left,
4348 cpi->total_coded_error_left, cpi->tot_recode_hits);
4353 FILE *fmodes = fopen("Modes.stt", "a");
4356 fprintf(fmodes, "%6d:%1d:%1d:%1d ",
4357 cpi->common.current_video_frame,
4358 cm->frame_type, cm->refresh_golden_frame,
4359 cm->refresh_alt_ref_frame);
4361 for (i = 0; i < MAX_MODES; i++)
4362 fprintf(fmodes, "%5d ", cpi->mode_chosen_counts[i]);
4364 fprintf(fmodes, "\n");
4372 // If this was a kf or Gf note the Q
4373 if ((cm->frame_type == KEY_FRAME) || cm->refresh_golden_frame || cm->refresh_alt_ref_frame)
4374 cm->last_kf_gf_q = cm->base_qindex;
4376 if (cm->refresh_golden_frame == 1)
4377 cm->frame_flags = cm->frame_flags | FRAMEFLAGS_GOLDEN;
4379 cm->frame_flags = cm->frame_flags&~FRAMEFLAGS_GOLDEN;
4381 if (cm->refresh_alt_ref_frame == 1)
4382 cm->frame_flags = cm->frame_flags | FRAMEFLAGS_ALTREF;
4384 cm->frame_flags = cm->frame_flags&~FRAMEFLAGS_ALTREF;
4387 if (cm->refresh_last_frame & cm->refresh_golden_frame) // both refreshed
4388 cpi->gold_is_last = 1;
4389 else if (cm->refresh_last_frame ^ cm->refresh_golden_frame) // 1 refreshed but not the other
4390 cpi->gold_is_last = 0;
4392 if (cm->refresh_last_frame & cm->refresh_alt_ref_frame) // both refreshed
4393 cpi->alt_is_last = 1;
4394 else if (cm->refresh_last_frame ^ cm->refresh_alt_ref_frame) // 1 refreshed but not the other
4395 cpi->alt_is_last = 0;
4397 if (cm->refresh_alt_ref_frame & cm->refresh_golden_frame) // both refreshed
4398 cpi->gold_is_alt = 1;
4399 else if (cm->refresh_alt_ref_frame ^ cm->refresh_golden_frame) // 1 refreshed but not the other
4400 cpi->gold_is_alt = 0;
4402 cpi->ref_frame_flags = VP8_ALT_FLAG | VP8_GOLD_FLAG | VP8_LAST_FLAG;
4404 if (cpi->gold_is_last)
4405 cpi->ref_frame_flags &= ~VP8_GOLD_FLAG;
4407 if (cpi->alt_is_last)
4408 cpi->ref_frame_flags &= ~VP8_ALT_FLAG;
4410 if (cpi->gold_is_alt)
4411 cpi->ref_frame_flags &= ~VP8_ALT_FLAG;
4414 if (cpi->oxcf.error_resilient_mode)
4416 if (cm->frame_type != KEY_FRAME)
4418 // Is this an alternate reference update
4419 if (cm->refresh_alt_ref_frame)
4420 vp8_yv12_copy_frame_ptr(cm->frame_to_show, &cm->yv12_fb[cm->alt_fb_idx]);
4422 if (cm->refresh_golden_frame)
4423 vp8_yv12_copy_frame_ptr(cm->frame_to_show, &cm->yv12_fb[cm->gld_fb_idx]);
4428 if (cpi->oxcf.play_alternate && cm->refresh_alt_ref_frame && (cm->frame_type != KEY_FRAME))
4429 // Update the alternate reference frame and stats as appropriate.
4430 update_alt_ref_frame_and_stats(cpi);
4432 // Update the Golden frame and golden frame and stats as appropriate.
4433 update_golden_frame_and_stats(cpi);
4436 if (cm->frame_type == KEY_FRAME)
4438 // Tell the caller that the frame was coded as a key frame
4439 *frame_flags = cm->frame_flags | FRAMEFLAGS_KEY;
4441 // As this frame is a key frame the next defaults to an inter frame.
4442 cm->frame_type = INTER_FRAME;
4444 cpi->last_frame_percent_intra = 100;
4448 *frame_flags = cm->frame_flags&~FRAMEFLAGS_KEY;
4450 cpi->last_frame_percent_intra = cpi->this_frame_percent_intra;
4453 // Clear the one shot update flags for segmentation map and mode/ref loop filter deltas.
4454 cpi->mb.e_mbd.update_mb_segmentation_map = 0;
4455 cpi->mb.e_mbd.update_mb_segmentation_data = 0;
4456 cpi->mb.e_mbd.mode_ref_lf_delta_update = 0;
4459 // Dont increment frame counters if this was an altref buffer update not a real frame
4462 cm->current_video_frame++;
4463 cpi->frames_since_key++;
4466 // reset to normal state now that we are done.
4474 sprintf(filename, "enc%04d.yuv", (int) cm->current_video_frame);
4475 recon_file = fopen(filename, "wb");
4476 fwrite(cm->yv12_fb[cm->lst_fb_idx].buffer_alloc,
4477 cm->yv12_fb[cm->lst_fb_idx].frame_size, 1, recon_file);
4483 //vp8_write_yuv_frame("encoder_recon.yuv", cm->frame_to_show);
4489 static void check_gf_quality(VP8_COMP *cpi)
4491 VP8_COMMON *cm = &cpi->common;
4492 int gf_active_pct = (100 * cpi->gf_active_count) / (cm->mb_rows * cm->mb_cols);
4493 int gf_ref_usage_pct = (cpi->count_mb_ref_frame_usage[GOLDEN_FRAME] * 100) / (cm->mb_rows * cm->mb_cols);
4494 int last_ref_zz_useage = (cpi->inter_zz_count * 100) / (cm->mb_rows * cm->mb_cols);
4496 // Gf refresh is not currently being signalled
4497 if (cpi->gf_update_recommended == 0)
4499 if (cpi->common.frames_since_golden > 7)
4502 if ((gf_active_pct < 10) || ((gf_active_pct + gf_ref_usage_pct) < 15))
4504 // ...but last frame zero zero usage is reasonbable so a new gf might be appropriate
4505 if (last_ref_zz_useage >= 25)
4507 cpi->gf_bad_count ++;
4509 if (cpi->gf_bad_count >= 8) // Check that the condition is stable
4511 cpi->gf_update_recommended = 1;
4512 cpi->gf_bad_count = 0;
4516 cpi->gf_bad_count = 0; // Restart count as the background is not stable enough
4519 cpi->gf_bad_count = 0; // Gf useage has picked up so reset count
4522 // If the signal is set but has not been read should we cancel it.
4523 else if (last_ref_zz_useage < 15)
4525 cpi->gf_update_recommended = 0;
4526 cpi->gf_bad_count = 0;
4531 FILE *f = fopen("gfneeded.stt", "a");
4532 fprintf(f, "%10d %10d %10d %10d %10ld \n",
4533 cm->current_video_frame,
4534 cpi->common.frames_since_golden,
4535 gf_active_pct, gf_ref_usage_pct,
4536 cpi->gf_update_recommended);
4543 #if !(CONFIG_REALTIME_ONLY)
4544 static void Pass2Encode(VP8_COMP *cpi, unsigned long *size, unsigned char *dest, unsigned int *frame_flags)
4547 if (!cpi->common.refresh_alt_ref_frame)
4548 vp8_second_pass(cpi);
4550 encode_frame_to_data_rate(cpi, size, dest, frame_flags);
4551 cpi->bits_left -= 8 * *size;
4553 if (!cpi->common.refresh_alt_ref_frame)
4555 double two_pass_min_rate = (double)(cpi->oxcf.target_bandwidth
4556 *cpi->oxcf.two_pass_vbrmin_section / 100);
4557 cpi->bits_left += (long long)(two_pass_min_rate / cpi->oxcf.frame_rate);
4562 //For ARM NEON, d8-d15 are callee-saved registers, and need to be saved by us.
4564 extern void vp8_push_neon(INT64 *store);
4565 extern void vp8_pop_neon(INT64 *store);
4569 int vp8_receive_raw_frame(VP8_PTR ptr, unsigned int frame_flags, YV12_BUFFER_CONFIG *sd, INT64 time_stamp, INT64 end_time)
4574 VP8_COMP *cpi = (VP8_COMP *) ptr;
4575 VP8_COMMON *cm = &cpi->common;
4576 struct vpx_usec_timer timer;
4580 #if CONFIG_RUNTIME_CPU_DETECT
4581 if (cm->rtcd.flags & HAS_NEON)
4584 vp8_push_neon(store_reg);
4588 vpx_usec_timer_start(&timer);
4589 if(vp8_lookahead_push(cpi->lookahead, sd, time_stamp, end_time,
4592 cm->clr_type = sd->clrtype;
4593 vpx_usec_timer_mark(&timer);
4594 cpi->time_receive_data += vpx_usec_timer_elapsed(&timer);
4597 #if CONFIG_RUNTIME_CPU_DETECT
4598 if (cm->rtcd.flags & HAS_NEON)
4601 vp8_pop_neon(store_reg);
4609 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)
4614 VP8_COMP *cpi = (VP8_COMP *) ptr;
4615 VP8_COMMON *cm = &cpi->common;
4616 struct vpx_usec_timer tsctimer;
4617 struct vpx_usec_timer ticktimer;
4618 struct vpx_usec_timer cmptimer;
4619 YV12_BUFFER_CONFIG *force_src_buffer = NULL;
4625 #if CONFIG_RUNTIME_CPU_DETECT
4626 if (cm->rtcd.flags & HAS_NEON)
4629 vp8_push_neon(store_reg);
4633 vpx_usec_timer_start(&cmptimer);
4637 #if !(CONFIG_REALTIME_ONLY)
4638 // Should we code an alternate reference frame
4639 if (cpi->oxcf.error_resilient_mode == 0 &&
4640 cpi->oxcf.play_alternate &&
4641 cpi->source_alt_ref_pending)
4643 if ((cpi->source = vp8_lookahead_peek(cpi->lookahead,
4644 cpi->frames_till_gf_update_due)))
4646 cpi->alt_ref_source = cpi->source;
4647 if (cpi->oxcf.arnr_max_frames > 0)
4649 vp8_temporal_filter_prepare_c(cpi,
4650 cpi->frames_till_gf_update_due);
4651 force_src_buffer = &cpi->alt_ref_buffer;
4653 cm->frames_till_alt_ref_frame = cpi->frames_till_gf_update_due;
4654 cm->refresh_alt_ref_frame = 1;
4655 cm->refresh_golden_frame = 0;
4656 cm->refresh_last_frame = 0;
4658 cpi->source_alt_ref_pending = FALSE; // Clear Pending altf Ref flag.
4659 cpi->is_src_frame_alt_ref = 0;
4666 if ((cpi->source = vp8_lookahead_pop(cpi->lookahead, flush)))
4670 cpi->is_src_frame_alt_ref = cpi->alt_ref_source
4671 && (cpi->source == cpi->alt_ref_source);
4673 if(cpi->is_src_frame_alt_ref)
4674 cpi->alt_ref_source = NULL;
4680 cpi->un_scaled_source =
4681 cpi->Source = force_src_buffer ? force_src_buffer : &cpi->source->img;
4682 *time_stamp = cpi->source->ts_start;
4683 *time_end = cpi->source->ts_end;
4684 *frame_flags = cpi->source->flags;
4689 #if !(CONFIG_REALTIME_ONLY)
4691 if (flush && cpi->pass == 1 && !cpi->first_pass_done)
4693 vp8_end_first_pass(cpi); /* get last stats packet */
4694 cpi->first_pass_done = 1;
4700 #if CONFIG_RUNTIME_CPU_DETECT
4701 if (cm->rtcd.flags & HAS_NEON)
4704 vp8_pop_neon(store_reg);
4710 if (cpi->source->ts_start < cpi->first_time_stamp_ever)
4712 cpi->first_time_stamp_ever = cpi->source->ts_start;
4713 cpi->last_end_time_stamp_seen = cpi->source->ts_start;
4716 // adjust frame rates based on timestamps given
4717 if (!cm->refresh_alt_ref_frame)
4719 if (cpi->source->ts_start == cpi->first_time_stamp_ever)
4721 double this_fps = 10000000.000 / (cpi->source->ts_end - cpi->source->ts_start);
4723 vp8_new_frame_rate(cpi, this_fps);
4727 long long nanosecs = cpi->source->ts_end
4728 - cpi->last_end_time_stamp_seen;
4732 double this_fps = 10000000.000 / nanosecs;
4733 vp8_new_frame_rate(cpi, (7 * cpi->oxcf.frame_rate + this_fps) / 8);
4738 cpi->last_time_stamp_seen = cpi->source->ts_start;
4739 cpi->last_end_time_stamp_seen = cpi->source->ts_end;
4742 if (cpi->compressor_speed == 2)
4744 check_gf_quality(cpi);
4745 vpx_usec_timer_start(&tsctimer);
4746 vpx_usec_timer_start(&ticktimer);
4749 // start with a 0 size frame
4752 // Clear down mmx registers
4753 vp8_clear_system_state(); //__asm emms;
4755 cm->frame_type = INTER_FRAME;
4756 cm->frame_flags = *frame_flags;
4760 if (cm->refresh_alt_ref_frame)
4762 //cm->refresh_golden_frame = 1;
4763 cm->refresh_golden_frame = 0;
4764 cm->refresh_last_frame = 0;
4768 cm->refresh_golden_frame = 0;
4769 cm->refresh_last_frame = 1;
4774 #if !(CONFIG_REALTIME_ONLY)
4778 Pass1Encode(cpi, size, dest, frame_flags);
4780 else if (cpi->pass == 2)
4782 Pass2Encode(cpi, size, dest, frame_flags);
4786 encode_frame_to_data_rate(cpi, size, dest, frame_flags);
4788 if (cpi->compressor_speed == 2)
4790 unsigned int duration, duration2;
4791 vpx_usec_timer_mark(&tsctimer);
4792 vpx_usec_timer_mark(&ticktimer);
4794 duration = vpx_usec_timer_elapsed(&ticktimer);
4795 duration2 = (unsigned int)((double)duration / 2);
4797 if (cm->frame_type != KEY_FRAME)
4799 if (cpi->avg_encode_time == 0)
4800 cpi->avg_encode_time = duration;
4802 cpi->avg_encode_time = (7 * cpi->avg_encode_time + duration) >> 3;
4807 //if(*frame_flags!=1)
4810 if (cpi->avg_pick_mode_time == 0)
4811 cpi->avg_pick_mode_time = duration2;
4813 cpi->avg_pick_mode_time = (7 * cpi->avg_pick_mode_time + duration2) >> 3;
4819 if (cm->refresh_entropy_probs == 0)
4821 vpx_memcpy(&cm->fc, &cm->lfc, sizeof(cm->fc));
4824 // if its a dropped frame honor the requests on subsequent frames
4828 // return to normal state
4829 cm->refresh_entropy_probs = 1;
4830 cm->refresh_alt_ref_frame = 0;
4831 cm->refresh_golden_frame = 0;
4832 cm->refresh_last_frame = 1;
4833 cm->frame_type = INTER_FRAME;
4837 cpi->ready_for_new_frame = 1;
4839 vpx_usec_timer_mark(&cmptimer);
4840 cpi->time_compress_data += vpx_usec_timer_elapsed(&cmptimer);
4842 if (cpi->b_calculate_psnr && cpi->pass != 1 && cm->show_frame)
4844 generate_psnr_packet(cpi);
4851 cpi->bytes += *size;
4858 if (cpi->b_calculate_psnr)
4862 YV12_BUFFER_CONFIG *orig = cpi->Source;
4863 YV12_BUFFER_CONFIG *recon = cpi->common.frame_to_show;
4864 YV12_BUFFER_CONFIG *pp = &cm->post_proc_buffer;
4865 int y_samples = orig->y_height * orig->y_width ;
4866 int uv_samples = orig->uv_height * orig->uv_width ;
4867 int t_samples = y_samples + 2 * uv_samples;
4870 ye = calc_plane_error(orig->y_buffer, orig->y_stride,
4871 recon->y_buffer, recon->y_stride, orig->y_width, orig->y_height,
4872 IF_RTCD(&cpi->rtcd.variance));
4874 ue = calc_plane_error(orig->u_buffer, orig->uv_stride,
4875 recon->u_buffer, recon->uv_stride, orig->uv_width, orig->uv_height,
4876 IF_RTCD(&cpi->rtcd.variance));
4878 ve = calc_plane_error(orig->v_buffer, orig->uv_stride,
4879 recon->v_buffer, recon->uv_stride, orig->uv_width, orig->uv_height,
4880 IF_RTCD(&cpi->rtcd.variance));
4882 sq_error = ye + ue + ve;
4884 frame_psnr = vp8_mse2psnr(t_samples, 255.0, sq_error);
4886 cpi->total_y += vp8_mse2psnr(y_samples, 255.0, ye);
4887 cpi->total_u += vp8_mse2psnr(uv_samples, 255.0, ue);
4888 cpi->total_v += vp8_mse2psnr(uv_samples, 255.0, ve);
4889 cpi->total_sq_error += sq_error;
4890 cpi->total += frame_psnr;
4892 double frame_psnr2, frame_ssim2 = 0;
4895 vp8_deblock(cm->frame_to_show, &cm->post_proc_buffer, cm->filter_level * 10 / 6, 1, 0, IF_RTCD(&cm->rtcd.postproc));
4896 vp8_clear_system_state();
4898 ye = calc_plane_error(orig->y_buffer, orig->y_stride,
4899 pp->y_buffer, pp->y_stride, orig->y_width, orig->y_height,
4900 IF_RTCD(&cpi->rtcd.variance));
4902 ue = calc_plane_error(orig->u_buffer, orig->uv_stride,
4903 pp->u_buffer, pp->uv_stride, orig->uv_width, orig->uv_height,
4904 IF_RTCD(&cpi->rtcd.variance));
4906 ve = calc_plane_error(orig->v_buffer, orig->uv_stride,
4907 pp->v_buffer, pp->uv_stride, orig->uv_width, orig->uv_height,
4908 IF_RTCD(&cpi->rtcd.variance));
4910 sq_error = ye + ue + ve;
4912 frame_psnr2 = vp8_mse2psnr(t_samples, 255.0, sq_error);
4914 cpi->totalp_y += vp8_mse2psnr(y_samples, 255.0, ye);
4915 cpi->totalp_u += vp8_mse2psnr(uv_samples, 255.0, ue);
4916 cpi->totalp_v += vp8_mse2psnr(uv_samples, 255.0, ve);
4917 cpi->total_sq_error2 += sq_error;
4918 cpi->totalp += frame_psnr2;
4920 frame_ssim2 = vp8_calc_ssim(cpi->Source,
4921 &cm->post_proc_buffer, 1, &weight,
4922 IF_RTCD(&cpi->rtcd.variance));
4924 cpi->summed_quality += frame_ssim2 * weight;
4925 cpi->summed_weights += weight;
4930 if (cpi->b_calculate_ssimg)
4932 double y, u, v, frame_all;
4933 frame_all = vp8_calc_ssimg(cpi->Source, cm->frame_to_show,
4934 &y, &u, &v, IF_RTCD(&cpi->rtcd.variance));
4935 cpi->total_ssimg_y += y;
4936 cpi->total_ssimg_u += u;
4937 cpi->total_ssimg_v += v;
4938 cpi->total_ssimg_all += frame_all;
4946 if (cpi->common.frame_type != 0 && cpi->common.base_qindex == cpi->oxcf.worst_allowed_q)
4948 skiptruecount += cpi->skip_true_count;
4949 skipfalsecount += cpi->skip_false_count;
4957 FILE *f = fopen("skip.stt", "a");
4958 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);
4960 if (cpi->is_src_frame_alt_ref == 1)
4961 fprintf(f, "skipcount: %4d framesize: %d\n", cpi->skip_true_count , *size);
4970 #if CONFIG_RUNTIME_CPU_DETECT
4971 if (cm->rtcd.flags & HAS_NEON)
4974 vp8_pop_neon(store_reg);
4981 int vp8_get_preview_raw_frame(VP8_PTR comp, YV12_BUFFER_CONFIG *dest, vp8_ppflags_t *flags)
4983 VP8_COMP *cpi = (VP8_COMP *) comp;
4985 if (cpi->common.refresh_alt_ref_frame)
4991 ret = vp8_post_proc_frame(&cpi->common, dest, flags);
4994 if (cpi->common.frame_to_show)
4996 *dest = *cpi->common.frame_to_show;
4997 dest->y_width = cpi->common.Width;
4998 dest->y_height = cpi->common.Height;
4999 dest->uv_height = cpi->common.Height / 2;
5007 #endif //!CONFIG_POSTPROC
5008 vp8_clear_system_state();
5013 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])
5015 VP8_COMP *cpi = (VP8_COMP *) comp;
5016 signed char feature_data[MB_LVL_MAX][MAX_MB_SEGMENTS];
5018 if (cpi->common.mb_rows != rows || cpi->common.mb_cols != cols)
5023 disable_segmentation((VP8_PTR)cpi);
5027 // Set the segmentation Map
5028 set_segmentation_map((VP8_PTR)cpi, map);
5030 // Activate segmentation.
5031 enable_segmentation((VP8_PTR)cpi);
5033 // Set up the quant segment data
5034 feature_data[MB_LVL_ALT_Q][0] = delta_q[0];
5035 feature_data[MB_LVL_ALT_Q][1] = delta_q[1];
5036 feature_data[MB_LVL_ALT_Q][2] = delta_q[2];
5037 feature_data[MB_LVL_ALT_Q][3] = delta_q[3];
5039 // Set up the loop segment data s
5040 feature_data[MB_LVL_ALT_LF][0] = delta_lf[0];
5041 feature_data[MB_LVL_ALT_LF][1] = delta_lf[1];
5042 feature_data[MB_LVL_ALT_LF][2] = delta_lf[2];
5043 feature_data[MB_LVL_ALT_LF][3] = delta_lf[3];
5045 cpi->segment_encode_breakout[0] = threshold[0];
5046 cpi->segment_encode_breakout[1] = threshold[1];
5047 cpi->segment_encode_breakout[2] = threshold[2];
5048 cpi->segment_encode_breakout[3] = threshold[3];
5050 // Initialise the feature data structure
5051 // SEGMENT_DELTADATA 0, SEGMENT_ABSDATA 1
5052 set_segment_data((VP8_PTR)cpi, &feature_data[0][0], SEGMENT_DELTADATA);
5057 int vp8_set_active_map(VP8_PTR comp, unsigned char *map, unsigned int rows, unsigned int cols)
5059 VP8_COMP *cpi = (VP8_COMP *) comp;
5061 if (rows == cpi->common.mb_rows && cols == cpi->common.mb_cols)
5065 vpx_memcpy(cpi->active_map, map, rows * cols);
5066 cpi->active_map_enabled = 1;
5069 cpi->active_map_enabled = 0;
5075 //cpi->active_map_enabled = 0;
5080 int vp8_set_internal_size(VP8_PTR comp, VPX_SCALING horiz_mode, VPX_SCALING vert_mode)
5082 VP8_COMP *cpi = (VP8_COMP *) comp;
5084 if (horiz_mode <= ONETWO)
5085 cpi->common.horiz_scale = horiz_mode;
5089 if (vert_mode <= ONETWO)
5090 cpi->common.vert_scale = vert_mode;
5099 int vp8_calc_ss_err(YV12_BUFFER_CONFIG *source, YV12_BUFFER_CONFIG *dest, const vp8_variance_rtcd_vtable_t *rtcd)
5104 unsigned char *src = source->y_buffer;
5105 unsigned char *dst = dest->y_buffer;
5108 // Loop through the Y plane raw and reconstruction data summing (square differences)
5109 for (i = 0; i < source->y_height; i += 16)
5111 for (j = 0; j < source->y_width; j += 16)
5114 Total += VARIANCE_INVOKE(rtcd, mse16x16)(src + j, source->y_stride, dst + j, dest->y_stride, &sse);
5117 src += 16 * source->y_stride;
5118 dst += 16 * dest->y_stride;
5125 int vp8_get_quantizer(VP8_PTR c)
5127 VP8_COMP *cpi = (VP8_COMP *) c;
5128 return cpi->common.base_qindex;