1 /*
2 * Copyright (c) 2010 The WebM project authors. All Rights Reserved.
3 *
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.
9 */
10
11
12 #include "onyxc_int.h"
13 #include "onyx_int.h"
14 #include "systemdependent.h"
15 #include "quantize.h"
16 #include "alloccommon.h"
17 #include "mcomp.h"
18 #include "firstpass.h"
19 #include "psnr.h"
20 #include "vpx_scale/vpxscale.h"
21 #include "extend.h"
22 #include "ratectrl.h"
23 #include "quant_common.h"
24 #include "segmentation.h"
25 #include "g_common.h"
26 #include "vpx_scale/yv12extend.h"
27 #include "postproc.h"
28 #include "vpx_mem/vpx_mem.h"
29 #include "swapyv12buffer.h"
30 #include "threading.h"
31 #include "vpx_ports/vpx_timer.h"
32 #include "vpxerrors.h"
33 #include "temporal_filter.h"
34 #if ARCH_ARM
35 #include "vpx_ports/arm.h"
36 #endif
37
38 #include <math.h>
39 #include <stdio.h>
40 #include <limits.h>
41
42 #if CONFIG_RUNTIME_CPU_DETECT
43 #define IF_RTCD(x) (x)
44 #define RTCD(x) &cpi->common.rtcd.x
45 #else
46 #define IF_RTCD(x) NULL
47 #define RTCD(x) NULL
48 #endif
49
50 extern void vp8cx_init_mv_bits_sadcost();
51 extern void vp8cx_pick_filter_level_fast(YV12_BUFFER_CONFIG *sd, VP8_COMP *cpi);
52 extern void vp8cx_set_alt_lf_level(VP8_COMP *cpi, int filt_val);
53 extern void vp8cx_pick_filter_level(YV12_BUFFER_CONFIG *sd, VP8_COMP *cpi);
54
55 extern void vp8_init_loop_filter(VP8_COMMON *cm);
56 extern void vp8_loop_filter_frame(VP8_COMMON *cm, MACROBLOCKD *mbd, int filt_val);
57 extern void vp8_loop_filter_frame_yonly(VP8_COMMON *cm, MACROBLOCKD *mbd, int filt_val, int sharpness_lvl);
58 extern void vp8_dmachine_specific_config(VP8_COMP *cpi);
59 extern void vp8_cmachine_specific_config(VP8_COMP *cpi);
60 extern void vp8_calc_auto_iframe_target_size(VP8_COMP *cpi);
61 extern void vp8_deblock_frame(YV12_BUFFER_CONFIG *source, YV12_BUFFER_CONFIG *post, int filt_lvl, int low_var_thresh, int flag);
62 extern void print_parms(VP8_CONFIG *ocf, char *filenam);
63 extern unsigned int vp8_get_processor_freq();
64 extern void print_tree_update_probs();
65 extern void vp8cx_create_encoder_threads(VP8_COMP *cpi);
66 extern void vp8cx_remove_encoder_threads(VP8_COMP *cpi);
67 #if HAVE_ARMV7
68 extern void vp8_yv12_copy_frame_func_neon(YV12_BUFFER_CONFIG *src_ybc, YV12_BUFFER_CONFIG *dst_ybc);
69 extern void vp8_yv12_copy_src_frame_func_neon(YV12_BUFFER_CONFIG *src_ybc, YV12_BUFFER_CONFIG *dst_ybc);
70 #endif
71
72 int vp8_estimate_entropy_savings(VP8_COMP *cpi);
73 int vp8_calc_ss_err(YV12_BUFFER_CONFIG *source, YV12_BUFFER_CONFIG *dest, const vp8_variance_rtcd_vtable_t *rtcd);
74 int vp8_calc_low_ss_err(YV12_BUFFER_CONFIG *source, YV12_BUFFER_CONFIG *dest, const vp8_variance_rtcd_vtable_t *rtcd);
75
76
77 static void set_default_lf_deltas(VP8_COMP *cpi);
78
79 extern const int vp8_gf_interval_table[101];
80
81 #if CONFIG_PSNR
82 #include "math.h"
83
84 extern double vp8_calc_ssim
85 (
86 YV12_BUFFER_CONFIG *source,
87 YV12_BUFFER_CONFIG *dest,
88 int lumamask,
89 double *weight
90 );
91
92 extern double vp8_calc_ssimg
93 (
94 YV12_BUFFER_CONFIG *source,
95 YV12_BUFFER_CONFIG *dest,
96 double *ssim_y,
97 double *ssim_u,
98 double *ssim_v
99 );
100
101
102 #endif
103
104
105 #ifdef OUTPUT_YUV_SRC
106 FILE *yuv_file;
107 #endif
108
109 #if 0
110 FILE *framepsnr;
111 FILE *kf_list;
112 FILE *keyfile;
113 #endif
114
115 #if 0
116 extern int skip_true_count;
117 extern int skip_false_count;
118 #endif
119
120
121 #ifdef ENTROPY_STATS
122 extern int intra_mode_stats[10][10][10];
123 #endif
124
125 #ifdef SPEEDSTATS
126 unsigned int frames_at_speed[16] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
127 unsigned int tot_pm = 0;
128 unsigned int cnt_pm = 0;
129 unsigned int tot_ef = 0;
130 unsigned int cnt_ef = 0;
131 #endif
132
133 #ifdef MODE_STATS
134 extern unsigned __int64 Sectionbits[50];
135 extern int y_modes[5] ;
136 extern int uv_modes[4] ;
137 extern int b_modes[10] ;
138
139 extern int inter_y_modes[10] ;
140 extern int inter_uv_modes[4] ;
141 extern unsigned int inter_b_modes[15];
142 #endif
143
144 extern void (*vp8_short_fdct4x4)(short *input, short *output, int pitch);
145 extern void (*vp8_short_fdct8x4)(short *input, short *output, int pitch);
146
147 extern const int vp8_bits_per_mb[2][QINDEX_RANGE];
148
149 extern const int qrounding_factors[129];
150 extern const int qzbin_factors[129];
151 extern void vp8cx_init_quantizer(VP8_COMP *cpi);
152 extern const int vp8cx_base_skip_false_prob[128];
153
154 // Tables relating active max Q to active min Q
155 static const int kf_low_motion_minq[QINDEX_RANGE] =
156 {
157 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
158 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
159 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
160 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4,
161 5, 5, 5, 6, 6, 6, 7, 7, 7, 8, 8, 8, 9, 9, 10,10,
162 11,11,12,12,13,13,14,14,15,15,16,16,17,17,18,18,
163 19,19,20,20,21,21,22,22,23,23,24,24,25,25,26,26,
164 27,27,28,28,29,29,30,30,31,32,33,34,35,36,37,38,
165 };
166 static const int kf_high_motion_minq[QINDEX_RANGE] =
167 {
168 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
169 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1,
170 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5,
171 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8, 9, 9, 9, 10,10,
172 11,11,12,12,13,13,14,14,15,15,16,16,17,17,18,18,
173 19,19,20,20,21,21,22,22,23,23,24,24,25,25,26,26,
174 27,27,28,28,29,29,30,30,31,31,32,32,33,33,34,34,
175 35,35,36,36,37,38,39,40,41,42,43,44,45,46,47,48,
176 };
177 /*static const int kf_minq[QINDEX_RANGE] =
178 {
179 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
180 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1,
181 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
182 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 6, 6,
183 7, 7, 8, 8, 9, 9, 10,10,11,11,12,12,13,13,14,14,
184 15,15,16,16,17,17,18,18,19,19,20,20,21,21,22,22,
185 23,23,24,24,25,25,26,26,27,27,28,28,29,29,30,30,
186 31,31,32,32,33,33,34,34,35,35,36,36,37,37,38,38
187 };*/
188 static const int gf_low_motion_minq[QINDEX_RANGE] =
189 {
190 0,0,0,0,1,1,1,1,1,1,1,1,2,2,2,2,
191 3,3,3,3,4,4,4,4,5,5,5,5,6,6,6,6,
192 7,7,7,7,8,8,8,8,9,9,9,9,10,10,10,10,
193 11,11,12,12,13,13,14,14,15,15,16,16,17,17,18,18,
194 19,19,20,20,21,21,22,22,23,23,24,24,25,25,26,26,
195 27,27,28,28,29,29,30,30,31,31,32,32,33,33,34,34,
196 35,35,36,36,37,37,38,38,39,39,40,40,41,41,42,42,
197 43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58
198 };
199 static const int gf_mid_motion_minq[QINDEX_RANGE] =
200 {
201 0,0,0,0,1,1,1,1,1,1,2,2,3,3,3,4,
202 4,4,5,5,5,6,6,6,7,7,7,8,8,8,9,9,
203 9,10,10,10,10,11,11,11,12,12,12,12,13,13,13,14,
204 14,14,15,15,16,16,17,17,18,18,19,19,20,20,21,21,
205 22,22,23,23,24,24,25,25,26,26,27,27,28,28,29,29,
206 30,30,31,31,32,32,33,33,34,34,35,35,36,36,37,37,
207 38,39,39,40,40,41,41,42,42,43,43,44,45,46,47,48,
208 49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,
209 };
210 static const int gf_high_motion_minq[QINDEX_RANGE] =
211 {
212 0,0,0,0,1,1,1,1,1,2,2,2,3,3,3,4,
213 4,4,5,5,5,6,6,6,7,7,7,8,8,8,9,9,
214 9,10,10,10,11,11,12,12,13,13,14,14,15,15,16,16,
215 17,17,18,18,19,19,20,20,21,21,22,22,23,23,24,24,
216 25,25,26,26,27,27,28,28,29,29,30,30,31,31,32,32,
217 33,33,34,34,35,35,36,36,37,37,38,38,39,39,40,40,
218 41,41,42,42,43,44,45,46,47,48,49,50,51,52,53,54,
219 55,56,57,58,59,60,62,64,66,68,70,72,74,76,78,80,
220 };
221 /*static const int gf_arf_minq[QINDEX_RANGE] =
222 {
223 0,0,0,0,1,1,1,1,1,1,2,2,3,3,3,4,
224 4,4,5,5,5,6,6,6,7,7,7,8,8,8,9,9,
225 9,10,10,10,11,11,11,12,12,12,13,13,13,14,14,14,
226 15,15,16,16,17,17,18,18,19,19,20,20,21,21,22,22,
227 23,23,24,24,25,25,26,26,27,27,28,28,29,29,30,30,
228 31,31,32,32,33,33,34,34,35,35,36,36,37,37,38,39,
229 39,40,40,41,41,42,42,43,43,44,45,46,47,48,49,50,
230 51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66
231 };*/
232 static const int inter_minq[QINDEX_RANGE] =
233 {
234 0,0,0,0,1,1,2,3,3,4,4,5,6,6,7,7,
235 8,8,9,9,10,11,11,12,12,13,13,14,14,15,15,16,
236 16,17,17,17,18,18,19,19,20,20,21,21,22,22,22,23,
237 23,24,24,24,25,25,26,27,28,28,29,30,31,32,33,34,
238 35,35,36,37,38,39,39,40,41,42,43,43,44,45,46,47,
239 47,48,49,49,51,52,53,54,54,55,56,56,57,57,58,58,
240 59,59,60,61,61,62,62,63,64,64,65,66,67,67,68,69,
241 69,70,71,71,72,73,74,75,76,76,77,78,79,80,81,81,
242 };
243
vp8_initialize()244 void vp8_initialize()
245 {
246 static int init_done = 0;
247
248 if (!init_done)
249 {
250 vp8_scale_machine_specific_config();
251 vp8_initialize_common();
252 //vp8_dmachine_specific_config();
253 vp8_tokenize_initialize();
254
255 vp8cx_init_mv_bits_sadcost();
256 init_done = 1;
257 }
258 }
259 #ifdef PACKET_TESTING
260 extern FILE *vpxlogc;
261 #endif
262
setup_features(VP8_COMP * cpi)263 static void setup_features(VP8_COMP *cpi)
264 {
265 // Set up default state for MB feature flags
266 cpi->mb.e_mbd.segmentation_enabled = 0;
267 cpi->mb.e_mbd.update_mb_segmentation_map = 0;
268 cpi->mb.e_mbd.update_mb_segmentation_data = 0;
269 vpx_memset(cpi->mb.e_mbd.mb_segment_tree_probs, 255, sizeof(cpi->mb.e_mbd.mb_segment_tree_probs));
270 vpx_memset(cpi->mb.e_mbd.segment_feature_data, 0, sizeof(cpi->mb.e_mbd.segment_feature_data));
271
272 cpi->mb.e_mbd.mode_ref_lf_delta_enabled = 0;
273 cpi->mb.e_mbd.mode_ref_lf_delta_update = 0;
274 vpx_memset(cpi->mb.e_mbd.ref_lf_deltas, 0, sizeof(cpi->mb.e_mbd.ref_lf_deltas));
275 vpx_memset(cpi->mb.e_mbd.mode_lf_deltas, 0, sizeof(cpi->mb.e_mbd.mode_lf_deltas));
276 vpx_memset(cpi->mb.e_mbd.last_ref_lf_deltas, 0, sizeof(cpi->mb.e_mbd.ref_lf_deltas));
277 vpx_memset(cpi->mb.e_mbd.last_mode_lf_deltas, 0, sizeof(cpi->mb.e_mbd.mode_lf_deltas));
278
279 set_default_lf_deltas(cpi);
280
281 }
282
283
vp8_dealloc_compressor_data(VP8_COMP * cpi)284 void vp8_dealloc_compressor_data(VP8_COMP *cpi)
285 {
286
287 // Delete sementation map
288 if (cpi->segmentation_map != 0)
289 vpx_free(cpi->segmentation_map);
290
291 cpi->segmentation_map = 0;
292
293 if (cpi->active_map != 0)
294 vpx_free(cpi->active_map);
295
296 cpi->active_map = 0;
297
298 // Delete first pass motion map
299 if (cpi->fp_motion_map != 0)
300 vpx_free(cpi->fp_motion_map);
301
302 cpi->fp_motion_map = 0;
303
304 vp8_de_alloc_frame_buffers(&cpi->common);
305
306 vp8_yv12_de_alloc_frame_buffer(&cpi->last_frame_uf);
307 vp8_yv12_de_alloc_frame_buffer(&cpi->scaled_source);
308 #if VP8_TEMPORAL_ALT_REF
309 vp8_yv12_de_alloc_frame_buffer(&cpi->alt_ref_buffer.source_buffer);
310 #endif
311 {
312 int i;
313
314 for (i = 0; i < MAX_LAG_BUFFERS; i++)
315 vp8_yv12_de_alloc_frame_buffer(&cpi->src_buffer[i].source_buffer);
316
317 cpi->source_buffer_count = 0;
318 }
319
320 vpx_free(cpi->tok);
321 cpi->tok = 0;
322
323 // Structure used to minitor GF useage
324 if (cpi->gf_active_flags != 0)
325 vpx_free(cpi->gf_active_flags);
326
327 cpi->gf_active_flags = 0;
328
329 if(cpi->mb.pip)
330 vpx_free(cpi->mb.pip);
331
332 cpi->mb.pip = 0;
333
334 vpx_free(cpi->total_stats);
335 vpx_free(cpi->this_frame_stats);
336 }
337
enable_segmentation(VP8_PTR ptr)338 static void enable_segmentation(VP8_PTR ptr)
339 {
340 VP8_COMP *cpi = (VP8_COMP *)(ptr);
341
342 // Set the appropriate feature bit
343 cpi->mb.e_mbd.segmentation_enabled = 1;
344 cpi->mb.e_mbd.update_mb_segmentation_map = 1;
345 cpi->mb.e_mbd.update_mb_segmentation_data = 1;
346 }
disable_segmentation(VP8_PTR ptr)347 static void disable_segmentation(VP8_PTR ptr)
348 {
349 VP8_COMP *cpi = (VP8_COMP *)(ptr);
350
351 // Clear the appropriate feature bit
352 cpi->mb.e_mbd.segmentation_enabled = 0;
353 }
354
355 // Valid values for a segment are 0 to 3
356 // Segmentation map is arrange as [Rows][Columns]
set_segmentation_map(VP8_PTR ptr,unsigned char * segmentation_map)357 static void set_segmentation_map(VP8_PTR ptr, unsigned char *segmentation_map)
358 {
359 VP8_COMP *cpi = (VP8_COMP *)(ptr);
360
361 // Copy in the new segmentation map
362 vpx_memcpy(cpi->segmentation_map, segmentation_map, (cpi->common.mb_rows * cpi->common.mb_cols));
363
364 // Signal that the map should be updated.
365 cpi->mb.e_mbd.update_mb_segmentation_map = 1;
366 cpi->mb.e_mbd.update_mb_segmentation_data = 1;
367 }
368
369 // The values given for each segment can be either deltas (from the default value chosen for the frame) or absolute values.
370 //
371 // Valid range for abs values is (0-127 for MB_LVL_ALT_Q) , (0-63 for SEGMENT_ALT_LF)
372 // Valid range for delta values are (+/-127 for MB_LVL_ALT_Q) , (+/-63 for SEGMENT_ALT_LF)
373 //
374 // abs_delta = SEGMENT_DELTADATA (deltas) abs_delta = SEGMENT_ABSDATA (use the absolute values given).
375 //
376 //
set_segment_data(VP8_PTR ptr,signed char * feature_data,unsigned char abs_delta)377 static void set_segment_data(VP8_PTR ptr, signed char *feature_data, unsigned char abs_delta)
378 {
379 VP8_COMP *cpi = (VP8_COMP *)(ptr);
380
381 cpi->mb.e_mbd.mb_segement_abs_delta = abs_delta;
382 vpx_memcpy(cpi->segment_feature_data, feature_data, sizeof(cpi->segment_feature_data));
383 }
384
385
segmentation_test_function(VP8_PTR ptr)386 static void segmentation_test_function(VP8_PTR ptr)
387 {
388 VP8_COMP *cpi = (VP8_COMP *)(ptr);
389
390 unsigned char *seg_map;
391 signed char feature_data[MB_LVL_MAX][MAX_MB_SEGMENTS];
392
393 // Create a temporary map for segmentation data.
394 CHECK_MEM_ERROR(seg_map, vpx_calloc(cpi->common.mb_rows * cpi->common.mb_cols, 1));
395
396 // MB loop to set local segmentation map
397 /*for ( i = 0; i < cpi->common.mb_rows; i++ )
398 {
399 for ( j = 0; j < cpi->common.mb_cols; j++ )
400 {
401 //seg_map[(i*cpi->common.mb_cols) + j] = (j % 2) + ((i%2)* 2);
402 //if ( j < cpi->common.mb_cols/2 )
403
404 // Segment 1 around the edge else 0
405 if ( (i == 0) || (j == 0) || (i == (cpi->common.mb_rows-1)) || (j == (cpi->common.mb_cols-1)) )
406 seg_map[(i*cpi->common.mb_cols) + j] = 1;
407 //else if ( (i < 2) || (j < 2) || (i > (cpi->common.mb_rows-3)) || (j > (cpi->common.mb_cols-3)) )
408 // seg_map[(i*cpi->common.mb_cols) + j] = 2;
409 //else if ( (i < 5) || (j < 5) || (i > (cpi->common.mb_rows-6)) || (j > (cpi->common.mb_cols-6)) )
410 // seg_map[(i*cpi->common.mb_cols) + j] = 3;
411 else
412 seg_map[(i*cpi->common.mb_cols) + j] = 0;
413 }
414 }*/
415
416 // Set the segmentation Map
417 set_segmentation_map(ptr, seg_map);
418
419 // Activate segmentation.
420 enable_segmentation(ptr);
421
422 // Set up the quant segment data
423 feature_data[MB_LVL_ALT_Q][0] = 0;
424 feature_data[MB_LVL_ALT_Q][1] = 4;
425 feature_data[MB_LVL_ALT_Q][2] = 0;
426 feature_data[MB_LVL_ALT_Q][3] = 0;
427 // Set up the loop segment data
428 feature_data[MB_LVL_ALT_LF][0] = 0;
429 feature_data[MB_LVL_ALT_LF][1] = 0;
430 feature_data[MB_LVL_ALT_LF][2] = 0;
431 feature_data[MB_LVL_ALT_LF][3] = 0;
432
433 // Initialise the feature data structure
434 // SEGMENT_DELTADATA 0, SEGMENT_ABSDATA 1
435 set_segment_data(ptr, &feature_data[0][0], SEGMENT_DELTADATA);
436
437 // Delete sementation map
438 if (seg_map != 0)
439 vpx_free(seg_map);
440
441 seg_map = 0;
442
443 }
444
445 // A simple function to cyclically refresh the background at a lower Q
cyclic_background_refresh(VP8_COMP * cpi,int Q,int lf_adjustment)446 static void cyclic_background_refresh(VP8_COMP *cpi, int Q, int lf_adjustment)
447 {
448 unsigned char *seg_map;
449 signed char feature_data[MB_LVL_MAX][MAX_MB_SEGMENTS];
450 int i;
451 int block_count = cpi->cyclic_refresh_mode_max_mbs_perframe;
452 int mbs_in_frame = cpi->common.mb_rows * cpi->common.mb_cols;
453
454 // Create a temporary map for segmentation data.
455 CHECK_MEM_ERROR(seg_map, vpx_calloc(cpi->common.mb_rows * cpi->common.mb_cols, 1));
456
457 cpi->cyclic_refresh_q = Q;
458
459 for (i = Q; i > 0; i--)
460 {
461 if (vp8_bits_per_mb[cpi->common.frame_type][i] >= ((vp8_bits_per_mb[cpi->common.frame_type][Q]*(Q + 128)) / 64))
462 //if ( vp8_bits_per_mb[cpi->common.frame_type][i] >= ((vp8_bits_per_mb[cpi->common.frame_type][Q]*((2*Q)+96))/64) )
463 {
464 break;
465 }
466 }
467
468 cpi->cyclic_refresh_q = i;
469
470 // Only update for inter frames
471 if (cpi->common.frame_type != KEY_FRAME)
472 {
473 // Cycle through the macro_block rows
474 // MB loop to set local segmentation map
475 for (i = cpi->cyclic_refresh_mode_index; i < mbs_in_frame; i++)
476 {
477 // If the MB is as a candidate for clean up then mark it for possible boost/refresh (segment 1)
478 // The segment id may get reset to 0 later if the MB gets coded anything other than last frame 0,0
479 // as only (last frame 0,0) MBs are eligable for refresh : that is to say Mbs likely to be background blocks.
480 if (cpi->cyclic_refresh_map[i] == 0)
481 {
482 seg_map[i] = 1;
483 }
484 else
485 {
486 seg_map[i] = 0;
487
488 // Skip blocks that have been refreshed recently anyway.
489 if (cpi->cyclic_refresh_map[i] < 0)
490 //cpi->cyclic_refresh_map[i] = cpi->cyclic_refresh_map[i] / 16;
491 cpi->cyclic_refresh_map[i]++;
492 }
493
494
495 if (block_count > 0)
496 block_count--;
497 else
498 break;
499
500 }
501
502 // If we have gone through the frame reset to the start
503 cpi->cyclic_refresh_mode_index = i;
504
505 if (cpi->cyclic_refresh_mode_index >= mbs_in_frame)
506 cpi->cyclic_refresh_mode_index = 0;
507 }
508
509 // Set the segmentation Map
510 set_segmentation_map((VP8_PTR)cpi, seg_map);
511
512 // Activate segmentation.
513 enable_segmentation((VP8_PTR)cpi);
514
515 // Set up the quant segment data
516 feature_data[MB_LVL_ALT_Q][0] = 0;
517 feature_data[MB_LVL_ALT_Q][1] = (cpi->cyclic_refresh_q - Q);
518 feature_data[MB_LVL_ALT_Q][2] = 0;
519 feature_data[MB_LVL_ALT_Q][3] = 0;
520
521 // Set up the loop segment data
522 feature_data[MB_LVL_ALT_LF][0] = 0;
523 feature_data[MB_LVL_ALT_LF][1] = lf_adjustment;
524 feature_data[MB_LVL_ALT_LF][2] = 0;
525 feature_data[MB_LVL_ALT_LF][3] = 0;
526
527 // Initialise the feature data structure
528 // SEGMENT_DELTADATA 0, SEGMENT_ABSDATA 1
529 set_segment_data((VP8_PTR)cpi, &feature_data[0][0], SEGMENT_DELTADATA);
530
531 // Delete sementation map
532 if (seg_map != 0)
533 vpx_free(seg_map);
534
535 seg_map = 0;
536
537 }
538
set_default_lf_deltas(VP8_COMP * cpi)539 static void set_default_lf_deltas(VP8_COMP *cpi)
540 {
541 cpi->mb.e_mbd.mode_ref_lf_delta_enabled = 1;
542 cpi->mb.e_mbd.mode_ref_lf_delta_update = 1;
543
544 vpx_memset(cpi->mb.e_mbd.ref_lf_deltas, 0, sizeof(cpi->mb.e_mbd.ref_lf_deltas));
545 vpx_memset(cpi->mb.e_mbd.mode_lf_deltas, 0, sizeof(cpi->mb.e_mbd.mode_lf_deltas));
546
547 // Test of ref frame deltas
548 cpi->mb.e_mbd.ref_lf_deltas[INTRA_FRAME] = 2;
549 cpi->mb.e_mbd.ref_lf_deltas[LAST_FRAME] = 0;
550 cpi->mb.e_mbd.ref_lf_deltas[GOLDEN_FRAME] = -2;
551 cpi->mb.e_mbd.ref_lf_deltas[ALTREF_FRAME] = -2;
552
553 cpi->mb.e_mbd.mode_lf_deltas[0] = 4; // BPRED
554 cpi->mb.e_mbd.mode_lf_deltas[1] = -2; // Zero
555 cpi->mb.e_mbd.mode_lf_deltas[2] = 2; // New mv
556 cpi->mb.e_mbd.mode_lf_deltas[3] = 4; // Split mv
557 }
558
vp8_set_speed_features(VP8_COMP * cpi)559 void vp8_set_speed_features(VP8_COMP *cpi)
560 {
561 SPEED_FEATURES *sf = &cpi->sf;
562 int Mode = cpi->compressor_speed;
563 int Speed = cpi->Speed;
564 int i;
565 VP8_COMMON *cm = &cpi->common;
566
567 // Initialise default mode frequency sampling variables
568 for (i = 0; i < MAX_MODES; i ++)
569 {
570 cpi->mode_check_freq[i] = 0;
571 cpi->mode_test_hit_counts[i] = 0;
572 cpi->mode_chosen_counts[i] = 0;
573 }
574
575 cpi->mbs_tested_so_far = 0;
576
577 // best quality
578 sf->RD = 1;
579 sf->search_method = NSTEP;
580 sf->improved_quant = 1;
581 sf->improved_dct = 1;
582 sf->auto_filter = 1;
583 sf->recode_loop = 1;
584 sf->quarter_pixel_search = 1;
585 sf->half_pixel_search = 1;
586 sf->full_freq[0] = 7;
587 sf->full_freq[1] = 7;
588 sf->min_fs_radius = 8;
589 sf->max_fs_radius = 32;
590 sf->iterative_sub_pixel = 1;
591 sf->optimize_coefficients = 1;
592
593 sf->first_step = 0;
594 sf->max_step_search_steps = MAX_MVSEARCH_STEPS;
595
596 cpi->do_full[0] = 0;
597 cpi->do_full[1] = 0;
598
599 // default thresholds to 0
600 for (i = 0; i < MAX_MODES; i++)
601 sf->thresh_mult[i] = 0;
602
603 switch (Mode)
604 {
605 #if !(CONFIG_REALTIME_ONLY)
606 case 0: // best quality mode
607 sf->thresh_mult[THR_ZEROMV ] = 0;
608 sf->thresh_mult[THR_ZEROG ] = 0;
609 sf->thresh_mult[THR_ZEROA ] = 0;
610 sf->thresh_mult[THR_NEARESTMV] = 0;
611 sf->thresh_mult[THR_NEARESTG ] = 0;
612 sf->thresh_mult[THR_NEARESTA ] = 0;
613 sf->thresh_mult[THR_NEARMV ] = 0;
614 sf->thresh_mult[THR_NEARG ] = 0;
615 sf->thresh_mult[THR_NEARA ] = 0;
616
617 sf->thresh_mult[THR_DC ] = 0;
618
619 sf->thresh_mult[THR_V_PRED ] = 1000;
620 sf->thresh_mult[THR_H_PRED ] = 1000;
621 sf->thresh_mult[THR_B_PRED ] = 2000;
622 sf->thresh_mult[THR_TM ] = 1000;
623
624 sf->thresh_mult[THR_NEWMV ] = 1000;
625 sf->thresh_mult[THR_NEWG ] = 1000;
626 sf->thresh_mult[THR_NEWA ] = 1000;
627
628 sf->thresh_mult[THR_SPLITMV ] = 2500;
629 sf->thresh_mult[THR_SPLITG ] = 5000;
630 sf->thresh_mult[THR_SPLITA ] = 5000;
631
632 sf->full_freq[0] = 7;
633 sf->full_freq[1] = 15;
634
635 sf->first_step = 0;
636 sf->max_step_search_steps = MAX_MVSEARCH_STEPS;
637
638 if (!(cpi->ref_frame_flags & VP8_LAST_FLAG))
639 {
640 sf->thresh_mult[THR_NEWMV ] = INT_MAX;
641 sf->thresh_mult[THR_NEARESTMV] = INT_MAX;
642 sf->thresh_mult[THR_ZEROMV ] = INT_MAX;
643 sf->thresh_mult[THR_NEARMV ] = INT_MAX;
644 sf->thresh_mult[THR_SPLITMV ] = INT_MAX;
645 }
646
647 if (!(cpi->ref_frame_flags & VP8_GOLD_FLAG))
648 {
649 sf->thresh_mult[THR_NEARESTG ] = INT_MAX;
650 sf->thresh_mult[THR_ZEROG ] = INT_MAX;
651 sf->thresh_mult[THR_NEARG ] = INT_MAX;
652 sf->thresh_mult[THR_NEWG ] = INT_MAX;
653 sf->thresh_mult[THR_SPLITG ] = INT_MAX;
654 }
655
656 if (!(cpi->ref_frame_flags & VP8_ALT_FLAG))
657 {
658 sf->thresh_mult[THR_NEARESTA ] = INT_MAX;
659 sf->thresh_mult[THR_ZEROA ] = INT_MAX;
660 sf->thresh_mult[THR_NEARA ] = INT_MAX;
661 sf->thresh_mult[THR_NEWA ] = INT_MAX;
662 sf->thresh_mult[THR_SPLITA ] = INT_MAX;
663 }
664
665 break;
666 case 1:
667 case 3:
668 sf->thresh_mult[THR_NEARESTMV] = 0;
669 sf->thresh_mult[THR_ZEROMV ] = 0;
670 sf->thresh_mult[THR_DC ] = 0;
671 sf->thresh_mult[THR_NEARMV ] = 0;
672 sf->thresh_mult[THR_V_PRED ] = 1000;
673 sf->thresh_mult[THR_H_PRED ] = 1000;
674 sf->thresh_mult[THR_B_PRED ] = 2500;
675 sf->thresh_mult[THR_TM ] = 1000;
676
677 sf->thresh_mult[THR_NEARESTG ] = 1000;
678 sf->thresh_mult[THR_NEARESTA ] = 1000;
679
680 sf->thresh_mult[THR_ZEROG ] = 1000;
681 sf->thresh_mult[THR_ZEROA ] = 1000;
682 sf->thresh_mult[THR_NEARG ] = 1000;
683 sf->thresh_mult[THR_NEARA ] = 1000;
684
685 sf->thresh_mult[THR_NEWMV ] = 1500;
686 sf->thresh_mult[THR_NEWG ] = 1500;
687 sf->thresh_mult[THR_NEWA ] = 1500;
688
689 sf->thresh_mult[THR_SPLITMV ] = 5000;
690 sf->thresh_mult[THR_SPLITG ] = 10000;
691 sf->thresh_mult[THR_SPLITA ] = 10000;
692
693 sf->full_freq[0] = 15;
694 sf->full_freq[1] = 31;
695
696 sf->first_step = 0;
697 sf->max_step_search_steps = MAX_MVSEARCH_STEPS;
698
699 if (!(cpi->ref_frame_flags & VP8_LAST_FLAG))
700 {
701 sf->thresh_mult[THR_NEWMV ] = INT_MAX;
702 sf->thresh_mult[THR_NEARESTMV] = INT_MAX;
703 sf->thresh_mult[THR_ZEROMV ] = INT_MAX;
704 sf->thresh_mult[THR_NEARMV ] = INT_MAX;
705 sf->thresh_mult[THR_SPLITMV ] = INT_MAX;
706 }
707
708 if (!(cpi->ref_frame_flags & VP8_GOLD_FLAG))
709 {
710 sf->thresh_mult[THR_NEARESTG ] = INT_MAX;
711 sf->thresh_mult[THR_ZEROG ] = INT_MAX;
712 sf->thresh_mult[THR_NEARG ] = INT_MAX;
713 sf->thresh_mult[THR_NEWG ] = INT_MAX;
714 sf->thresh_mult[THR_SPLITG ] = INT_MAX;
715 }
716
717 if (!(cpi->ref_frame_flags & VP8_ALT_FLAG))
718 {
719 sf->thresh_mult[THR_NEARESTA ] = INT_MAX;
720 sf->thresh_mult[THR_ZEROA ] = INT_MAX;
721 sf->thresh_mult[THR_NEARA ] = INT_MAX;
722 sf->thresh_mult[THR_NEWA ] = INT_MAX;
723 sf->thresh_mult[THR_SPLITA ] = INT_MAX;
724 }
725
726 if (Speed > 0)
727 {
728 // Disable coefficient optimization above speed 0
729 sf->optimize_coefficients = 0;
730
731 cpi->mode_check_freq[THR_SPLITG] = 4;
732 cpi->mode_check_freq[THR_SPLITA] = 4;
733 cpi->mode_check_freq[THR_SPLITMV] = 2;
734
735 sf->thresh_mult[THR_TM ] = 1500;
736 sf->thresh_mult[THR_V_PRED ] = 1500;
737 sf->thresh_mult[THR_H_PRED ] = 1500;
738 sf->thresh_mult[THR_B_PRED ] = 5000;
739
740 if (cpi->ref_frame_flags & VP8_LAST_FLAG)
741 {
742 sf->thresh_mult[THR_NEWMV ] = 2000;
743 sf->thresh_mult[THR_SPLITMV ] = 10000;
744 }
745
746 if (cpi->ref_frame_flags & VP8_GOLD_FLAG)
747 {
748 sf->thresh_mult[THR_NEARESTG ] = 1500;
749 sf->thresh_mult[THR_ZEROG ] = 1500;
750 sf->thresh_mult[THR_NEARG ] = 1500;
751 sf->thresh_mult[THR_NEWG ] = 2000;
752 sf->thresh_mult[THR_SPLITG ] = 20000;
753 }
754
755 if (cpi->ref_frame_flags & VP8_ALT_FLAG)
756 {
757 sf->thresh_mult[THR_NEARESTA ] = 1500;
758 sf->thresh_mult[THR_ZEROA ] = 1500;
759 sf->thresh_mult[THR_NEARA ] = 1500;
760 sf->thresh_mult[THR_NEWA ] = 2000;
761 sf->thresh_mult[THR_SPLITA ] = 20000;
762 }
763
764 sf->improved_quant = 0;
765 sf->improved_dct = 0;
766
767 sf->first_step = 1;
768 sf->max_step_search_steps = MAX_MVSEARCH_STEPS;
769 }
770
771 if (Speed > 1)
772 {
773 cpi->mode_check_freq[THR_SPLITG] = 15;
774 cpi->mode_check_freq[THR_SPLITA] = 15;
775 cpi->mode_check_freq[THR_SPLITMV] = 7;
776
777 sf->thresh_mult[THR_TM ] = 2000;
778 sf->thresh_mult[THR_V_PRED ] = 2000;
779 sf->thresh_mult[THR_H_PRED ] = 2000;
780 sf->thresh_mult[THR_B_PRED ] = 7500;
781
782 if (cpi->ref_frame_flags & VP8_LAST_FLAG)
783 {
784 sf->thresh_mult[THR_NEWMV ] = 2000;
785 sf->thresh_mult[THR_SPLITMV ] = 25000;
786 }
787
788 if (cpi->ref_frame_flags & VP8_GOLD_FLAG)
789 {
790 sf->thresh_mult[THR_NEARESTG ] = 2000;
791 sf->thresh_mult[THR_ZEROG ] = 2000;
792 sf->thresh_mult[THR_NEARG ] = 2000;
793 sf->thresh_mult[THR_NEWG ] = 2500;
794 sf->thresh_mult[THR_SPLITG ] = 50000;
795 }
796
797 if (cpi->ref_frame_flags & VP8_ALT_FLAG)
798 {
799 sf->thresh_mult[THR_NEARESTA ] = 2000;
800 sf->thresh_mult[THR_ZEROA ] = 2000;
801 sf->thresh_mult[THR_NEARA ] = 2000;
802 sf->thresh_mult[THR_NEWA ] = 2500;
803 sf->thresh_mult[THR_SPLITA ] = 50000;
804 }
805
806 // Only do recode loop on key frames and golden frames
807 sf->recode_loop = 2;
808
809 sf->full_freq[0] = 31;
810 sf->full_freq[1] = 63;
811
812 }
813
814 if (Speed > 2)
815 {
816 sf->auto_filter = 0; // Faster selection of loop filter
817 cpi->mode_check_freq[THR_V_PRED] = 2;
818 cpi->mode_check_freq[THR_H_PRED] = 2;
819 cpi->mode_check_freq[THR_B_PRED] = 2;
820
821 if (cpi->ref_frame_flags & VP8_GOLD_FLAG)
822 {
823 cpi->mode_check_freq[THR_NEARG] = 2;
824 cpi->mode_check_freq[THR_NEWG] = 4;
825 }
826
827 if (cpi->ref_frame_flags & VP8_ALT_FLAG)
828 {
829 cpi->mode_check_freq[THR_NEARA] = 2;
830 cpi->mode_check_freq[THR_NEWA] = 4;
831 }
832
833 sf->thresh_mult[THR_SPLITA ] = INT_MAX;
834 sf->thresh_mult[THR_SPLITG ] = INT_MAX;
835 sf->thresh_mult[THR_SPLITMV ] = INT_MAX;
836
837 sf->full_freq[0] = 63;
838 sf->full_freq[1] = 127;
839 }
840
841 if (Speed > 3)
842 {
843 cpi->mode_check_freq[THR_V_PRED] = 0;
844 cpi->mode_check_freq[THR_H_PRED] = 0;
845 cpi->mode_check_freq[THR_B_PRED] = 0;
846 cpi->mode_check_freq[THR_NEARG] = 0;
847 cpi->mode_check_freq[THR_NEWG] = 0;
848 cpi->mode_check_freq[THR_NEARA] = 0;
849 cpi->mode_check_freq[THR_NEWA] = 0;
850
851 sf->auto_filter = 1;
852 sf->recode_loop = 0; // recode loop off
853 sf->RD = 0; // Turn rd off
854 sf->full_freq[0] = INT_MAX;
855 sf->full_freq[1] = INT_MAX;
856 }
857
858 if (Speed > 4)
859 {
860 sf->auto_filter = 0; // Faster selection of loop filter
861
862 cpi->mode_check_freq[THR_V_PRED] = 2;
863 cpi->mode_check_freq[THR_H_PRED] = 2;
864 cpi->mode_check_freq[THR_B_PRED] = 2;
865
866 if (cpi->ref_frame_flags & VP8_GOLD_FLAG)
867 {
868 cpi->mode_check_freq[THR_NEARG] = 2;
869 cpi->mode_check_freq[THR_NEWG] = 4;
870 }
871
872 if (cpi->ref_frame_flags & VP8_ALT_FLAG)
873 {
874 cpi->mode_check_freq[THR_NEARA] = 2;
875 cpi->mode_check_freq[THR_NEWA] = 4;
876 }
877
878 if (cpi->ref_frame_flags & VP8_GOLD_FLAG)
879 {
880 sf->thresh_mult[THR_NEARESTG ] = 2000;
881 sf->thresh_mult[THR_ZEROG ] = 2000;
882 sf->thresh_mult[THR_NEARG ] = 2000;
883 sf->thresh_mult[THR_NEWG ] = 4000;
884 }
885
886 if (cpi->ref_frame_flags & VP8_ALT_FLAG)
887 {
888 sf->thresh_mult[THR_NEARESTA ] = 2000;
889 sf->thresh_mult[THR_ZEROA ] = 2000;
890 sf->thresh_mult[THR_NEARA ] = 2000;
891 sf->thresh_mult[THR_NEWA ] = 4000;
892 }
893 }
894
895 break;
896 #endif
897 case 2:
898 sf->optimize_coefficients = 0;
899 sf->recode_loop = 0;
900 sf->auto_filter = 1;
901 sf->iterative_sub_pixel = 1;
902 sf->thresh_mult[THR_NEARESTMV] = 0;
903 sf->thresh_mult[THR_ZEROMV ] = 0;
904 sf->thresh_mult[THR_DC ] = 0;
905 sf->thresh_mult[THR_TM ] = 0;
906 sf->thresh_mult[THR_NEARMV ] = 0;
907 sf->thresh_mult[THR_V_PRED ] = 1000;
908 sf->thresh_mult[THR_H_PRED ] = 1000;
909 sf->thresh_mult[THR_B_PRED ] = 2500;
910 sf->thresh_mult[THR_NEARESTG ] = 1000;
911 sf->thresh_mult[THR_ZEROG ] = 1000;
912 sf->thresh_mult[THR_NEARG ] = 1000;
913 sf->thresh_mult[THR_NEARESTA ] = 1000;
914 sf->thresh_mult[THR_ZEROA ] = 1000;
915 sf->thresh_mult[THR_NEARA ] = 1000;
916 sf->thresh_mult[THR_NEWMV ] = 2000;
917 sf->thresh_mult[THR_NEWG ] = 2000;
918 sf->thresh_mult[THR_NEWA ] = 2000;
919 sf->thresh_mult[THR_SPLITMV ] = 5000;
920 sf->thresh_mult[THR_SPLITG ] = 10000;
921 sf->thresh_mult[THR_SPLITA ] = 10000;
922 sf->full_freq[0] = 15;
923 sf->full_freq[1] = 31;
924 sf->search_method = NSTEP;
925
926 if (!(cpi->ref_frame_flags & VP8_LAST_FLAG))
927 {
928 sf->thresh_mult[THR_NEWMV ] = INT_MAX;
929 sf->thresh_mult[THR_NEARESTMV] = INT_MAX;
930 sf->thresh_mult[THR_ZEROMV ] = INT_MAX;
931 sf->thresh_mult[THR_NEARMV ] = INT_MAX;
932 sf->thresh_mult[THR_SPLITMV ] = INT_MAX;
933 }
934
935 if (!(cpi->ref_frame_flags & VP8_GOLD_FLAG))
936 {
937 sf->thresh_mult[THR_NEARESTG ] = INT_MAX;
938 sf->thresh_mult[THR_ZEROG ] = INT_MAX;
939 sf->thresh_mult[THR_NEARG ] = INT_MAX;
940 sf->thresh_mult[THR_NEWG ] = INT_MAX;
941 sf->thresh_mult[THR_SPLITG ] = INT_MAX;
942 }
943
944 if (!(cpi->ref_frame_flags & VP8_ALT_FLAG))
945 {
946 sf->thresh_mult[THR_NEARESTA ] = INT_MAX;
947 sf->thresh_mult[THR_ZEROA ] = INT_MAX;
948 sf->thresh_mult[THR_NEARA ] = INT_MAX;
949 sf->thresh_mult[THR_NEWA ] = INT_MAX;
950 sf->thresh_mult[THR_SPLITA ] = INT_MAX;
951 }
952
953 if (Speed > 0)
954 {
955 cpi->mode_check_freq[THR_SPLITG] = 4;
956 cpi->mode_check_freq[THR_SPLITA] = 4;
957 cpi->mode_check_freq[THR_SPLITMV] = 2;
958
959 sf->thresh_mult[THR_DC ] = 0;
960 sf->thresh_mult[THR_TM ] = 1000;
961 sf->thresh_mult[THR_V_PRED ] = 2000;
962 sf->thresh_mult[THR_H_PRED ] = 2000;
963 sf->thresh_mult[THR_B_PRED ] = 5000;
964
965 if (cpi->ref_frame_flags & VP8_LAST_FLAG)
966 {
967 sf->thresh_mult[THR_NEARESTMV] = 0;
968 sf->thresh_mult[THR_ZEROMV ] = 0;
969 sf->thresh_mult[THR_NEARMV ] = 0;
970 sf->thresh_mult[THR_NEWMV ] = 2000;
971 sf->thresh_mult[THR_SPLITMV ] = 10000;
972 }
973
974 if (cpi->ref_frame_flags & VP8_GOLD_FLAG)
975 {
976 sf->thresh_mult[THR_NEARESTG ] = 1000;
977 sf->thresh_mult[THR_ZEROG ] = 1000;
978 sf->thresh_mult[THR_NEARG ] = 1000;
979 sf->thresh_mult[THR_NEWG ] = 2000;
980 sf->thresh_mult[THR_SPLITG ] = 20000;
981 }
982
983 if (cpi->ref_frame_flags & VP8_ALT_FLAG)
984 {
985 sf->thresh_mult[THR_NEARESTA ] = 1000;
986 sf->thresh_mult[THR_ZEROA ] = 1000;
987 sf->thresh_mult[THR_NEARA ] = 1000;
988 sf->thresh_mult[THR_NEWA ] = 2000;
989 sf->thresh_mult[THR_SPLITA ] = 20000;
990 }
991
992 sf->improved_quant = 0;
993 sf->improved_dct = 0;
994 }
995
996 if (Speed > 1)
997 {
998 cpi->mode_check_freq[THR_SPLITMV] = 7;
999 cpi->mode_check_freq[THR_SPLITG] = 15;
1000 cpi->mode_check_freq[THR_SPLITA] = 15;
1001
1002 sf->thresh_mult[THR_TM ] = 2000;
1003 sf->thresh_mult[THR_V_PRED ] = 2000;
1004 sf->thresh_mult[THR_H_PRED ] = 2000;
1005 sf->thresh_mult[THR_B_PRED ] = 5000;
1006
1007 if (cpi->ref_frame_flags & VP8_LAST_FLAG)
1008 {
1009 sf->thresh_mult[THR_NEWMV ] = 2000;
1010 sf->thresh_mult[THR_SPLITMV ] = 25000;
1011 }
1012
1013 if (cpi->ref_frame_flags & VP8_GOLD_FLAG)
1014 {
1015 sf->thresh_mult[THR_NEARESTG ] = 2000;
1016 sf->thresh_mult[THR_ZEROG ] = 2000;
1017 sf->thresh_mult[THR_NEARG ] = 2000;
1018 sf->thresh_mult[THR_NEWG ] = 2500;
1019 sf->thresh_mult[THR_SPLITG ] = 50000;
1020 }
1021
1022 if (cpi->ref_frame_flags & VP8_ALT_FLAG)
1023 {
1024 sf->thresh_mult[THR_NEARESTA ] = 2000;
1025 sf->thresh_mult[THR_ZEROA ] = 2000;
1026 sf->thresh_mult[THR_NEARA ] = 2000;
1027 sf->thresh_mult[THR_NEWA ] = 2500;
1028 sf->thresh_mult[THR_SPLITA ] = 50000;
1029 }
1030
1031 sf->full_freq[0] = 31;
1032 sf->full_freq[1] = 63;
1033 }
1034
1035 if (Speed > 2)
1036 {
1037 sf->auto_filter = 0; // Faster selection of loop filter
1038
1039 cpi->mode_check_freq[THR_V_PRED] = 2;
1040 cpi->mode_check_freq[THR_H_PRED] = 2;
1041 cpi->mode_check_freq[THR_B_PRED] = 2;
1042
1043 if (cpi->ref_frame_flags & VP8_GOLD_FLAG)
1044 {
1045 cpi->mode_check_freq[THR_NEARG] = 2;
1046 cpi->mode_check_freq[THR_NEWG] = 4;
1047 }
1048
1049 if (cpi->ref_frame_flags & VP8_ALT_FLAG)
1050 {
1051 cpi->mode_check_freq[THR_NEARA] = 2;
1052 cpi->mode_check_freq[THR_NEWA] = 4;
1053 }
1054
1055 sf->thresh_mult[THR_SPLITMV ] = INT_MAX;
1056 sf->thresh_mult[THR_SPLITG ] = INT_MAX;
1057 sf->thresh_mult[THR_SPLITA ] = INT_MAX;
1058
1059 sf->full_freq[0] = 63;
1060 sf->full_freq[1] = 127;
1061 }
1062
1063 if (Speed > 3)
1064 {
1065 sf->RD = 0;
1066 sf->full_freq[0] = INT_MAX;
1067 sf->full_freq[1] = INT_MAX;
1068
1069 sf->auto_filter = 1;
1070 }
1071
1072 if (Speed > 4)
1073 {
1074 sf->auto_filter = 0; // Faster selection of loop filter
1075
1076 #if CONFIG_REALTIME_ONLY
1077 sf->search_method = HEX;
1078 #else
1079 sf->search_method = DIAMOND;
1080 #endif
1081
1082 cpi->mode_check_freq[THR_V_PRED] = 4;
1083 cpi->mode_check_freq[THR_H_PRED] = 4;
1084 cpi->mode_check_freq[THR_B_PRED] = 4;
1085
1086 if (cpi->ref_frame_flags & VP8_GOLD_FLAG)
1087 {
1088 cpi->mode_check_freq[THR_NEARG] = 2;
1089 cpi->mode_check_freq[THR_NEWG] = 4;
1090 }
1091
1092 if (cpi->ref_frame_flags & VP8_ALT_FLAG)
1093 {
1094 cpi->mode_check_freq[THR_NEARA] = 2;
1095 cpi->mode_check_freq[THR_NEWA] = 4;
1096 }
1097
1098 sf->thresh_mult[THR_TM ] = 2000;
1099 sf->thresh_mult[THR_B_PRED ] = 5000;
1100
1101 if (cpi->ref_frame_flags & VP8_GOLD_FLAG)
1102 {
1103 sf->thresh_mult[THR_NEARESTG ] = 2000;
1104 sf->thresh_mult[THR_ZEROG ] = 2000;
1105 sf->thresh_mult[THR_NEARG ] = 2000;
1106 sf->thresh_mult[THR_NEWG ] = 4000;
1107 }
1108
1109 if (cpi->ref_frame_flags & VP8_ALT_FLAG)
1110 {
1111 sf->thresh_mult[THR_NEARESTA ] = 2000;
1112 sf->thresh_mult[THR_ZEROA ] = 2000;
1113 sf->thresh_mult[THR_NEARA ] = 2000;
1114 sf->thresh_mult[THR_NEWA ] = 4000;
1115 }
1116 }
1117
1118 if (Speed > 5)
1119 {
1120 // Disable split MB intra prediction mode
1121 sf->thresh_mult[THR_B_PRED] = INT_MAX;
1122 }
1123
1124 if (Speed > 6)
1125 {
1126 unsigned int i, sum = 0;
1127 unsigned int total_mbs = cm->MBs;
1128 int thresh;
1129 int total_skip;
1130
1131 int min = 2000;
1132 sf->iterative_sub_pixel = 0;
1133
1134 if (cpi->oxcf.encode_breakout > 2000)
1135 min = cpi->oxcf.encode_breakout;
1136
1137 min >>= 7;
1138
1139 for (i = 0; i < min; i++)
1140 {
1141 sum += cpi->error_bins[i];
1142 }
1143
1144 total_skip = sum;
1145 sum = 0;
1146
1147 // i starts from 2 to make sure thresh started from 2048
1148 for (; i < 1024; i++)
1149 {
1150 sum += cpi->error_bins[i];
1151
1152 if (10 * sum >= (unsigned int)(cpi->Speed - 6)*(total_mbs - total_skip))
1153 break;
1154 }
1155
1156 i--;
1157 thresh = (i << 7);
1158
1159 if (thresh < 2000)
1160 thresh = 2000;
1161
1162 if (cpi->ref_frame_flags & VP8_LAST_FLAG)
1163 {
1164 sf->thresh_mult[THR_NEWMV] = thresh;
1165 sf->thresh_mult[THR_NEARESTMV ] = thresh >> 1;
1166 sf->thresh_mult[THR_NEARMV ] = thresh >> 1;
1167 }
1168
1169 if (cpi->ref_frame_flags & VP8_GOLD_FLAG)
1170 {
1171 sf->thresh_mult[THR_NEWG] = thresh << 1;
1172 sf->thresh_mult[THR_NEARESTG ] = thresh;
1173 sf->thresh_mult[THR_NEARG ] = thresh;
1174 }
1175
1176 if (cpi->ref_frame_flags & VP8_ALT_FLAG)
1177 {
1178 sf->thresh_mult[THR_NEWA] = thresh << 1;
1179 sf->thresh_mult[THR_NEARESTA ] = thresh;
1180 sf->thresh_mult[THR_NEARA ] = thresh;
1181 }
1182
1183 // Disable other intra prediction modes
1184 sf->thresh_mult[THR_TM] = INT_MAX;
1185 sf->thresh_mult[THR_V_PRED] = INT_MAX;
1186 sf->thresh_mult[THR_H_PRED] = INT_MAX;
1187
1188 }
1189
1190 if (Speed > 8)
1191 {
1192 sf->quarter_pixel_search = 0;
1193 }
1194
1195 if (Speed > 9)
1196 {
1197 int Tmp = cpi->Speed - 8;
1198
1199 if (Tmp > 4)
1200 Tmp = 4;
1201
1202 if (cpi->ref_frame_flags & VP8_GOLD_FLAG)
1203 {
1204 cpi->mode_check_freq[THR_ZEROG] = 1 << (Tmp - 1);
1205 cpi->mode_check_freq[THR_NEARESTG] = 1 << (Tmp - 1);
1206 cpi->mode_check_freq[THR_NEARG] = 1 << Tmp;
1207 cpi->mode_check_freq[THR_NEWG] = 1 << (Tmp + 1);
1208 }
1209
1210 if (cpi->ref_frame_flags & VP8_ALT_FLAG)
1211 {
1212 cpi->mode_check_freq[THR_ZEROA] = 1 << (Tmp - 1);
1213 cpi->mode_check_freq[THR_NEARESTA] = 1 << (Tmp - 1);
1214 cpi->mode_check_freq[THR_NEARA] = 1 << Tmp;
1215 cpi->mode_check_freq[THR_NEWA] = 1 << (Tmp + 1);
1216 }
1217
1218 cpi->mode_check_freq[THR_NEWMV] = 1 << (Tmp - 1);
1219 }
1220
1221 cm->filter_type = NORMAL_LOOPFILTER;
1222
1223 if (Speed >= 14)
1224 cm->filter_type = SIMPLE_LOOPFILTER;
1225
1226 if (Speed >= 15)
1227 {
1228 sf->half_pixel_search = 0; // This has a big hit on quality. Last resort
1229 }
1230
1231 vpx_memset(cpi->error_bins, 0, sizeof(cpi->error_bins));
1232
1233 };
1234
1235 if (cpi->sf.search_method == NSTEP)
1236 {
1237 vp8_init3smotion_compensation(&cpi->mb, cm->yv12_fb[cm->lst_fb_idx].y_stride);
1238 }
1239 else if (cpi->sf.search_method == DIAMOND)
1240 {
1241 vp8_init_dsmotion_compensation(&cpi->mb, cm->yv12_fb[cm->lst_fb_idx].y_stride);
1242 }
1243
1244 if (cpi->sf.improved_dct)
1245 {
1246 cpi->mb.vp8_short_fdct8x4 = FDCT_INVOKE(&cpi->rtcd.fdct, short8x4);
1247 cpi->mb.vp8_short_fdct4x4 = FDCT_INVOKE(&cpi->rtcd.fdct, short4x4);
1248 }
1249 else
1250 {
1251 cpi->mb.vp8_short_fdct8x4 = FDCT_INVOKE(&cpi->rtcd.fdct, fast8x4);
1252 cpi->mb.vp8_short_fdct4x4 = FDCT_INVOKE(&cpi->rtcd.fdct, fast4x4);
1253 }
1254
1255 cpi->mb.short_walsh4x4 = FDCT_INVOKE(&cpi->rtcd.fdct, walsh_short4x4);
1256
1257 if (cpi->sf.improved_quant)
1258 {
1259 cpi->mb.quantize_b = QUANTIZE_INVOKE(&cpi->rtcd.quantize, quantb);
1260 }
1261 else
1262 {
1263 cpi->mb.quantize_b = QUANTIZE_INVOKE(&cpi->rtcd.quantize, fastquantb);
1264 }
1265
1266 #if CONFIG_RUNTIME_CPU_DETECT
1267 cpi->mb.e_mbd.rtcd = &cpi->common.rtcd;
1268 #endif
1269
1270 if (cpi->sf.iterative_sub_pixel == 1)
1271 {
1272 cpi->find_fractional_mv_step = vp8_find_best_sub_pixel_step_iteratively;
1273 }
1274 else if (cpi->sf.quarter_pixel_search)
1275 {
1276 cpi->find_fractional_mv_step = vp8_find_best_sub_pixel_step;
1277 }
1278 else if (cpi->sf.half_pixel_search)
1279 {
1280 cpi->find_fractional_mv_step = vp8_find_best_half_pixel_step;
1281 }
1282 else
1283 {
1284 cpi->find_fractional_mv_step = vp8_skip_fractional_mv_step;
1285 }
1286
1287 if (cpi->sf.optimize_coefficients == 1)
1288 cpi->mb.optimize = 1 + cpi->is_next_src_alt_ref;
1289 else
1290 cpi->mb.optimize = 0;
1291
1292 if (cpi->common.full_pixel)
1293 cpi->find_fractional_mv_step = vp8_skip_fractional_mv_step;
1294
1295 #ifdef SPEEDSTATS
1296 frames_at_speed[cpi->Speed]++;
1297 #endif
1298 }
alloc_raw_frame_buffers(VP8_COMP * cpi)1299 static void alloc_raw_frame_buffers(VP8_COMP *cpi)
1300 {
1301 int i, buffers;
1302
1303 buffers = cpi->oxcf.lag_in_frames;
1304
1305 if (buffers > MAX_LAG_BUFFERS)
1306 buffers = MAX_LAG_BUFFERS;
1307
1308 if (buffers < 1)
1309 buffers = 1;
1310
1311 for (i = 0; i < buffers; i++)
1312 if (vp8_yv12_alloc_frame_buffer(&cpi->src_buffer[i].source_buffer,
1313 cpi->oxcf.Width, cpi->oxcf.Height,
1314 16))
1315 vpx_internal_error(&cpi->common.error, VPX_CODEC_MEM_ERROR,
1316 "Failed to allocate lag buffer");
1317
1318 #if VP8_TEMPORAL_ALT_REF
1319
1320 if (vp8_yv12_alloc_frame_buffer(&cpi->alt_ref_buffer.source_buffer,
1321 cpi->oxcf.Width, cpi->oxcf.Height, 16))
1322 vpx_internal_error(&cpi->common.error, VPX_CODEC_MEM_ERROR,
1323 "Failed to allocate altref buffer");
1324
1325 #endif
1326
1327 cpi->source_buffer_count = 0;
1328 }
1329
vp8_alloc_partition_data(VP8_COMP * cpi)1330 static int vp8_alloc_partition_data(VP8_COMP *cpi)
1331 {
1332 cpi->mb.pip = vpx_calloc((cpi->common.mb_cols + 1) *
1333 (cpi->common.mb_rows + 1),
1334 sizeof(PARTITION_INFO));
1335 if(!cpi->mb.pip)
1336 return ALLOC_FAILURE;
1337
1338 cpi->mb.pi = cpi->mb.pip + cpi->common.mode_info_stride + 1;
1339
1340 return 0;
1341 }
1342
vp8_alloc_compressor_data(VP8_COMP * cpi)1343 void vp8_alloc_compressor_data(VP8_COMP *cpi)
1344 {
1345 VP8_COMMON *cm = & cpi->common;
1346
1347 int width = cm->Width;
1348 int height = cm->Height;
1349
1350 if (vp8_alloc_frame_buffers(cm, width, height))
1351 vpx_internal_error(&cpi->common.error, VPX_CODEC_MEM_ERROR,
1352 "Failed to allocate frame buffers");
1353
1354 if (vp8_alloc_partition_data(cpi))
1355 vpx_internal_error(&cpi->common.error, VPX_CODEC_MEM_ERROR,
1356 "Failed to allocate partition data");
1357
1358
1359 if ((width & 0xf) != 0)
1360 width += 16 - (width & 0xf);
1361
1362 if ((height & 0xf) != 0)
1363 height += 16 - (height & 0xf);
1364
1365
1366 if (vp8_yv12_alloc_frame_buffer(&cpi->last_frame_uf,
1367 width, height, VP8BORDERINPIXELS))
1368 vpx_internal_error(&cpi->common.error, VPX_CODEC_MEM_ERROR,
1369 "Failed to allocate last frame buffer");
1370
1371 if (vp8_yv12_alloc_frame_buffer(&cpi->scaled_source, width, height, 16))
1372 vpx_internal_error(&cpi->common.error, VPX_CODEC_MEM_ERROR,
1373 "Failed to allocate scaled source buffer");
1374
1375
1376 if (cpi->tok != 0)
1377 vpx_free(cpi->tok);
1378
1379 {
1380 unsigned int tokens = cm->mb_rows * cm->mb_cols * 24 * 16;
1381
1382 CHECK_MEM_ERROR(cpi->tok, vpx_calloc(tokens, sizeof(*cpi->tok)));
1383 }
1384
1385 // Data used for real time vc mode to see if gf needs refreshing
1386 cpi->inter_zz_count = 0;
1387 cpi->gf_bad_count = 0;
1388 cpi->gf_update_recommended = 0;
1389
1390
1391 // Structures used to minitor GF usage
1392 if (cpi->gf_active_flags != 0)
1393 vpx_free(cpi->gf_active_flags);
1394
1395 CHECK_MEM_ERROR(cpi->gf_active_flags, vpx_calloc(1, cm->mb_rows * cm->mb_cols));
1396
1397 cpi->gf_active_count = cm->mb_rows * cm->mb_cols;
1398
1399 cpi->total_stats = vpx_calloc(1, vp8_firstpass_stats_sz(cpi->common.MBs));
1400 cpi->this_frame_stats = vpx_calloc(1, vp8_firstpass_stats_sz(cpi->common.MBs));
1401 if(!cpi->total_stats || !cpi->this_frame_stats)
1402 vpx_internal_error(&cpi->common.error, VPX_CODEC_MEM_ERROR,
1403 "Failed to allocate firstpass stats");
1404 }
1405
1406
1407 // Quant MOD
1408 static const int q_trans[] =
1409 {
1410 0, 1, 2, 3, 4, 5, 7, 8,
1411 9, 10, 12, 13, 15, 17, 18, 19,
1412 20, 21, 23, 24, 25, 26, 27, 28,
1413 29, 30, 31, 33, 35, 37, 39, 41,
1414 43, 45, 47, 49, 51, 53, 55, 57,
1415 59, 61, 64, 67, 70, 73, 76, 79,
1416 82, 85, 88, 91, 94, 97, 100, 103,
1417 106, 109, 112, 115, 118, 121, 124, 127,
1418 };
1419
vp8_reverse_trans(int x)1420 int vp8_reverse_trans(int x)
1421 {
1422 int i;
1423
1424 for (i = 0; i < 64; i++)
1425 if (q_trans[i] >= x)
1426 return i;
1427
1428 return 63;
1429 };
vp8_new_frame_rate(VP8_COMP * cpi,double framerate)1430 void vp8_new_frame_rate(VP8_COMP *cpi, double framerate)
1431 {
1432 if(framerate < .1)
1433 framerate = 30;
1434
1435 cpi->oxcf.frame_rate = framerate;
1436 cpi->output_frame_rate = cpi->oxcf.frame_rate;
1437 cpi->per_frame_bandwidth = (int)(cpi->oxcf.target_bandwidth / cpi->output_frame_rate);
1438 cpi->av_per_frame_bandwidth = (int)(cpi->oxcf.target_bandwidth / cpi->output_frame_rate);
1439 cpi->min_frame_bandwidth = (int)(cpi->av_per_frame_bandwidth * cpi->oxcf.two_pass_vbrmin_section / 100);
1440 cpi->max_gf_interval = (int)(cpi->output_frame_rate / 2) + 2;
1441
1442 //cpi->max_gf_interval = (int)(cpi->output_frame_rate * 2 / 3) + 1;
1443 //cpi->max_gf_interval = 24;
1444
1445 if (cpi->max_gf_interval < 12)
1446 cpi->max_gf_interval = 12;
1447
1448
1449 // Special conditions when altr ref frame enabled in lagged compress mode
1450 if (cpi->oxcf.play_alternate && cpi->oxcf.lag_in_frames)
1451 {
1452 if (cpi->max_gf_interval > cpi->oxcf.lag_in_frames - 1)
1453 cpi->max_gf_interval = cpi->oxcf.lag_in_frames - 1;
1454 }
1455 }
1456
1457
1458 static int
rescale(int val,int num,int denom)1459 rescale(int val, int num, int denom)
1460 {
1461 int64_t llnum = num;
1462 int64_t llden = denom;
1463 int64_t llval = val;
1464
1465 return llval * llnum / llden;
1466 }
1467
1468
vp8_init_config(VP8_PTR ptr,VP8_CONFIG * oxcf)1469 void vp8_init_config(VP8_PTR ptr, VP8_CONFIG *oxcf)
1470 {
1471 VP8_COMP *cpi = (VP8_COMP *)(ptr);
1472 VP8_COMMON *cm = &cpi->common;
1473
1474 if (!cpi)
1475 return;
1476
1477 cpi->auto_gold = 1;
1478 cpi->auto_adjust_gold_quantizer = 1;
1479 cpi->goldquantizer = 1;
1480 cpi->goldfreq = 7;
1481 cpi->auto_adjust_key_quantizer = 1;
1482 cpi->keyquantizer = 1;
1483
1484 cm->version = oxcf->Version;
1485 vp8_setup_version(cm);
1486
1487 if (oxcf == 0)
1488 {
1489 cpi->pass = 0;
1490
1491 cpi->auto_worst_q = 0;
1492 cpi->oxcf.best_allowed_q = MINQ;
1493 cpi->oxcf.worst_allowed_q = MAXQ;
1494
1495 cpi->oxcf.end_usage = USAGE_STREAM_FROM_SERVER;
1496 cpi->oxcf.starting_buffer_level = 4000;
1497 cpi->oxcf.optimal_buffer_level = 5000;
1498 cpi->oxcf.maximum_buffer_size = 6000;
1499 cpi->oxcf.under_shoot_pct = 90;
1500 cpi->oxcf.allow_df = 0;
1501 cpi->oxcf.drop_frames_water_mark = 20;
1502
1503 cpi->oxcf.allow_spatial_resampling = 0;
1504 cpi->oxcf.resample_down_water_mark = 40;
1505 cpi->oxcf.resample_up_water_mark = 60;
1506
1507 cpi->oxcf.fixed_q = cpi->interquantizer;
1508
1509 cpi->filter_type = NORMAL_LOOPFILTER;
1510
1511 if (cm->simpler_lpf)
1512 cpi->filter_type = SIMPLE_LOOPFILTER;
1513
1514 cpi->compressor_speed = 1;
1515 cpi->horiz_scale = 0;
1516 cpi->vert_scale = 0;
1517 cpi->oxcf.two_pass_vbrbias = 50;
1518 cpi->oxcf.two_pass_vbrmax_section = 400;
1519 cpi->oxcf.two_pass_vbrmin_section = 0;
1520
1521 cpi->oxcf.Sharpness = 0;
1522 cpi->oxcf.noise_sensitivity = 0;
1523 }
1524 else
1525 cpi->oxcf = *oxcf;
1526
1527
1528 switch (cpi->oxcf.Mode)
1529 {
1530
1531 case MODE_REALTIME:
1532 cpi->pass = 0;
1533 cpi->compressor_speed = 2;
1534
1535 if (cpi->oxcf.cpu_used < -16)
1536 {
1537 cpi->oxcf.cpu_used = -16;
1538 }
1539
1540 if (cpi->oxcf.cpu_used > 16)
1541 cpi->oxcf.cpu_used = 16;
1542
1543 break;
1544
1545 #if !(CONFIG_REALTIME_ONLY)
1546 case MODE_GOODQUALITY:
1547 cpi->pass = 0;
1548 cpi->compressor_speed = 1;
1549
1550 if (cpi->oxcf.cpu_used < -5)
1551 {
1552 cpi->oxcf.cpu_used = -5;
1553 }
1554
1555 if (cpi->oxcf.cpu_used > 5)
1556 cpi->oxcf.cpu_used = 5;
1557
1558 break;
1559
1560 case MODE_BESTQUALITY:
1561 cpi->pass = 0;
1562 cpi->compressor_speed = 0;
1563 break;
1564
1565 case MODE_FIRSTPASS:
1566 cpi->pass = 1;
1567 cpi->compressor_speed = 1;
1568 break;
1569 case MODE_SECONDPASS:
1570 cpi->pass = 2;
1571 cpi->compressor_speed = 1;
1572
1573 if (cpi->oxcf.cpu_used < -5)
1574 {
1575 cpi->oxcf.cpu_used = -5;
1576 }
1577
1578 if (cpi->oxcf.cpu_used > 5)
1579 cpi->oxcf.cpu_used = 5;
1580
1581 break;
1582 case MODE_SECONDPASS_BEST:
1583 cpi->pass = 2;
1584 cpi->compressor_speed = 0;
1585 break;
1586 #endif
1587 }
1588
1589 if (cpi->pass == 0)
1590 cpi->auto_worst_q = 1;
1591
1592 cpi->oxcf.worst_allowed_q = q_trans[oxcf->worst_allowed_q];
1593 cpi->oxcf.best_allowed_q = q_trans[oxcf->best_allowed_q];
1594
1595 if (oxcf->fixed_q >= 0)
1596 {
1597 if (oxcf->worst_allowed_q < 0)
1598 cpi->oxcf.fixed_q = q_trans[0];
1599 else
1600 cpi->oxcf.fixed_q = q_trans[oxcf->worst_allowed_q];
1601
1602 if (oxcf->alt_q < 0)
1603 cpi->oxcf.alt_q = q_trans[0];
1604 else
1605 cpi->oxcf.alt_q = q_trans[oxcf->alt_q];
1606
1607 if (oxcf->key_q < 0)
1608 cpi->oxcf.key_q = q_trans[0];
1609 else
1610 cpi->oxcf.key_q = q_trans[oxcf->key_q];
1611
1612 if (oxcf->gold_q < 0)
1613 cpi->oxcf.gold_q = q_trans[0];
1614 else
1615 cpi->oxcf.gold_q = q_trans[oxcf->gold_q];
1616
1617 }
1618
1619 cpi->baseline_gf_interval = cpi->oxcf.alt_freq ? cpi->oxcf.alt_freq : DEFAULT_GF_INTERVAL;
1620 cpi->ref_frame_flags = VP8_ALT_FLAG | VP8_GOLD_FLAG | VP8_LAST_FLAG;
1621
1622 //cpi->use_golden_frame_only = 0;
1623 //cpi->use_last_frame_only = 0;
1624 cm->refresh_golden_frame = 0;
1625 cm->refresh_last_frame = 1;
1626 cm->refresh_entropy_probs = 1;
1627
1628 if (cpi->oxcf.token_partitions >= 0 && cpi->oxcf.token_partitions <= 3)
1629 cm->multi_token_partition = (TOKEN_PARTITION) cpi->oxcf.token_partitions;
1630
1631 setup_features(cpi);
1632
1633 {
1634 int i;
1635
1636 for (i = 0; i < MAX_MB_SEGMENTS; i++)
1637 cpi->segment_encode_breakout[i] = cpi->oxcf.encode_breakout;
1638 }
1639
1640 // At the moment the first order values may not be > MAXQ
1641 if (cpi->oxcf.fixed_q > MAXQ)
1642 cpi->oxcf.fixed_q = MAXQ;
1643
1644 // local file playback mode == really big buffer
1645 if (cpi->oxcf.end_usage == USAGE_LOCAL_FILE_PLAYBACK)
1646 {
1647 cpi->oxcf.starting_buffer_level = 60000;
1648 cpi->oxcf.optimal_buffer_level = 60000;
1649 cpi->oxcf.maximum_buffer_size = 240000;
1650
1651 }
1652
1653
1654 // Convert target bandwidth from Kbit/s to Bit/s
1655 cpi->oxcf.target_bandwidth *= 1000;
1656 cpi->oxcf.starting_buffer_level =
1657 rescale(cpi->oxcf.starting_buffer_level,
1658 cpi->oxcf.target_bandwidth, 1000);
1659
1660 if (cpi->oxcf.optimal_buffer_level == 0)
1661 cpi->oxcf.optimal_buffer_level = cpi->oxcf.target_bandwidth / 8;
1662 else
1663 cpi->oxcf.optimal_buffer_level =
1664 rescale(cpi->oxcf.optimal_buffer_level,
1665 cpi->oxcf.target_bandwidth, 1000);
1666
1667 if (cpi->oxcf.maximum_buffer_size == 0)
1668 cpi->oxcf.maximum_buffer_size = cpi->oxcf.target_bandwidth / 8;
1669 else
1670 cpi->oxcf.maximum_buffer_size =
1671 rescale(cpi->oxcf.maximum_buffer_size,
1672 cpi->oxcf.target_bandwidth, 1000);
1673
1674 cpi->buffer_level = cpi->oxcf.starting_buffer_level;
1675 cpi->bits_off_target = cpi->oxcf.starting_buffer_level;
1676
1677 vp8_new_frame_rate(cpi, cpi->oxcf.frame_rate);
1678 cpi->worst_quality = cpi->oxcf.worst_allowed_q;
1679 cpi->active_worst_quality = cpi->oxcf.worst_allowed_q;
1680 cpi->avg_frame_qindex = cpi->oxcf.worst_allowed_q;
1681 cpi->best_quality = cpi->oxcf.best_allowed_q;
1682 cpi->active_best_quality = cpi->oxcf.best_allowed_q;
1683 cpi->buffered_mode = (cpi->oxcf.optimal_buffer_level > 0) ? TRUE : FALSE;
1684
1685 cpi->rolling_target_bits = cpi->av_per_frame_bandwidth;
1686 cpi->rolling_actual_bits = cpi->av_per_frame_bandwidth;
1687 cpi->long_rolling_target_bits = cpi->av_per_frame_bandwidth;
1688 cpi->long_rolling_actual_bits = cpi->av_per_frame_bandwidth;
1689
1690 cpi->total_actual_bits = 0;
1691 cpi->total_target_vs_actual = 0;
1692
1693 // Only allow dropped frames in buffered mode
1694 cpi->drop_frames_allowed = cpi->oxcf.allow_df && cpi->buffered_mode;
1695
1696 cm->filter_type = (LOOPFILTERTYPE) cpi->filter_type;
1697
1698 if (!cm->use_bilinear_mc_filter)
1699 cm->mcomp_filter_type = SIXTAP;
1700 else
1701 cm->mcomp_filter_type = BILINEAR;
1702
1703 cpi->target_bandwidth = cpi->oxcf.target_bandwidth;
1704
1705 cm->Width = cpi->oxcf.Width ;
1706 cm->Height = cpi->oxcf.Height ;
1707
1708 cpi->intra_frame_target = (4 * (cm->Width + cm->Height) / 15) * 1000; // As per VP8
1709
1710 cm->horiz_scale = cpi->horiz_scale;
1711 cm->vert_scale = cpi->vert_scale ;
1712
1713 // VP8 sharpness level mapping 0-7 (vs 0-10 in general VPx dialogs)
1714 if (cpi->oxcf.Sharpness > 7)
1715 cpi->oxcf.Sharpness = 7;
1716
1717 cm->sharpness_level = cpi->oxcf.Sharpness;
1718
1719 if (cm->horiz_scale != NORMAL || cm->vert_scale != NORMAL)
1720 {
1721 int UNINITIALIZED_IS_SAFE(hr), UNINITIALIZED_IS_SAFE(hs);
1722 int UNINITIALIZED_IS_SAFE(vr), UNINITIALIZED_IS_SAFE(vs);
1723
1724 Scale2Ratio(cm->horiz_scale, &hr, &hs);
1725 Scale2Ratio(cm->vert_scale, &vr, &vs);
1726
1727 // always go to the next whole number
1728 cm->Width = (hs - 1 + cpi->oxcf.Width * hr) / hs;
1729 cm->Height = (vs - 1 + cpi->oxcf.Height * vr) / vs;
1730 }
1731
1732 if (((cm->Width + 15) & 0xfffffff0) != cm->yv12_fb[cm->lst_fb_idx].y_width ||
1733 ((cm->Height + 15) & 0xfffffff0) != cm->yv12_fb[cm->lst_fb_idx].y_height ||
1734 cm->yv12_fb[cm->lst_fb_idx].y_width == 0)
1735 {
1736 alloc_raw_frame_buffers(cpi);
1737 vp8_alloc_compressor_data(cpi);
1738 }
1739
1740 // Clamp KF frame size to quarter of data rate
1741 if (cpi->intra_frame_target > cpi->target_bandwidth >> 2)
1742 cpi->intra_frame_target = cpi->target_bandwidth >> 2;
1743
1744 if (cpi->oxcf.fixed_q >= 0)
1745 {
1746 cpi->last_q[0] = cpi->oxcf.fixed_q;
1747 cpi->last_q[1] = cpi->oxcf.fixed_q;
1748 }
1749
1750 cpi->Speed = cpi->oxcf.cpu_used;
1751
1752 // force to allowlag to 0 if lag_in_frames is 0;
1753 if (cpi->oxcf.lag_in_frames == 0)
1754 {
1755 cpi->oxcf.allow_lag = 0;
1756 }
1757 // Limit on lag buffers as these are not currently dynamically allocated
1758 else if (cpi->oxcf.lag_in_frames > MAX_LAG_BUFFERS)
1759 cpi->oxcf.lag_in_frames = MAX_LAG_BUFFERS;
1760
1761 // YX Temp
1762 cpi->last_alt_ref_sei = -1;
1763 cpi->is_src_frame_alt_ref = 0;
1764 cpi->is_next_src_alt_ref = 0;
1765
1766 #if 0
1767 // Experimental RD Code
1768 cpi->frame_distortion = 0;
1769 cpi->last_frame_distortion = 0;
1770 #endif
1771
1772 #if VP8_TEMPORAL_ALT_REF
1773
1774 cpi->use_weighted_temporal_filter = 0;
1775
1776 {
1777 int i;
1778
1779 cpi->fixed_divide[0] = 0;
1780
1781 for (i = 1; i < 512; i++)
1782 cpi->fixed_divide[i] = 0x80000 / i;
1783 }
1784 #endif
1785 }
1786
1787 /*
1788 * This function needs more clean up, i.e. be more tuned torwards
1789 * change_config rather than init_config !!!!!!!!!!!!!!!!
1790 * YX - 5/28/2009
1791 *
1792 */
1793
vp8_change_config(VP8_PTR ptr,VP8_CONFIG * oxcf)1794 void vp8_change_config(VP8_PTR ptr, VP8_CONFIG *oxcf)
1795 {
1796 VP8_COMP *cpi = (VP8_COMP *)(ptr);
1797 VP8_COMMON *cm = &cpi->common;
1798
1799 if (!cpi)
1800 return;
1801
1802 if (!oxcf)
1803 return;
1804
1805 if (cm->version != oxcf->Version)
1806 {
1807 cm->version = oxcf->Version;
1808 vp8_setup_version(cm);
1809 }
1810
1811 cpi->oxcf = *oxcf;
1812
1813 switch (cpi->oxcf.Mode)
1814 {
1815
1816 case MODE_REALTIME:
1817 cpi->pass = 0;
1818 cpi->compressor_speed = 2;
1819
1820 if (cpi->oxcf.cpu_used < -16)
1821 {
1822 cpi->oxcf.cpu_used = -16;
1823 }
1824
1825 if (cpi->oxcf.cpu_used > 16)
1826 cpi->oxcf.cpu_used = 16;
1827
1828 break;
1829
1830 #if !(CONFIG_REALTIME_ONLY)
1831 case MODE_GOODQUALITY:
1832 cpi->pass = 0;
1833 cpi->compressor_speed = 1;
1834
1835 if (cpi->oxcf.cpu_used < -5)
1836 {
1837 cpi->oxcf.cpu_used = -5;
1838 }
1839
1840 if (cpi->oxcf.cpu_used > 5)
1841 cpi->oxcf.cpu_used = 5;
1842
1843 break;
1844
1845 case MODE_BESTQUALITY:
1846 cpi->pass = 0;
1847 cpi->compressor_speed = 0;
1848 break;
1849
1850 case MODE_FIRSTPASS:
1851 cpi->pass = 1;
1852 cpi->compressor_speed = 1;
1853 break;
1854 case MODE_SECONDPASS:
1855 cpi->pass = 2;
1856 cpi->compressor_speed = 1;
1857
1858 if (cpi->oxcf.cpu_used < -5)
1859 {
1860 cpi->oxcf.cpu_used = -5;
1861 }
1862
1863 if (cpi->oxcf.cpu_used > 5)
1864 cpi->oxcf.cpu_used = 5;
1865
1866 break;
1867 case MODE_SECONDPASS_BEST:
1868 cpi->pass = 2;
1869 cpi->compressor_speed = 0;
1870 break;
1871 #endif
1872 }
1873
1874 if (cpi->pass == 0)
1875 cpi->auto_worst_q = 1;
1876
1877 cpi->oxcf.worst_allowed_q = q_trans[oxcf->worst_allowed_q];
1878 cpi->oxcf.best_allowed_q = q_trans[oxcf->best_allowed_q];
1879
1880 if (oxcf->fixed_q >= 0)
1881 {
1882 if (oxcf->worst_allowed_q < 0)
1883 cpi->oxcf.fixed_q = q_trans[0];
1884 else
1885 cpi->oxcf.fixed_q = q_trans[oxcf->worst_allowed_q];
1886
1887 if (oxcf->alt_q < 0)
1888 cpi->oxcf.alt_q = q_trans[0];
1889 else
1890 cpi->oxcf.alt_q = q_trans[oxcf->alt_q];
1891
1892 if (oxcf->key_q < 0)
1893 cpi->oxcf.key_q = q_trans[0];
1894 else
1895 cpi->oxcf.key_q = q_trans[oxcf->key_q];
1896
1897 if (oxcf->gold_q < 0)
1898 cpi->oxcf.gold_q = q_trans[0];
1899 else
1900 cpi->oxcf.gold_q = q_trans[oxcf->gold_q];
1901
1902 }
1903
1904 cpi->baseline_gf_interval = cpi->oxcf.alt_freq ? cpi->oxcf.alt_freq : DEFAULT_GF_INTERVAL;
1905
1906 cpi->ref_frame_flags = VP8_ALT_FLAG | VP8_GOLD_FLAG | VP8_LAST_FLAG;
1907
1908 //cpi->use_golden_frame_only = 0;
1909 //cpi->use_last_frame_only = 0;
1910 cm->refresh_golden_frame = 0;
1911 cm->refresh_last_frame = 1;
1912 cm->refresh_entropy_probs = 1;
1913
1914 if (cpi->oxcf.token_partitions >= 0 && cpi->oxcf.token_partitions <= 3)
1915 cm->multi_token_partition = (TOKEN_PARTITION) cpi->oxcf.token_partitions;
1916
1917 setup_features(cpi);
1918
1919 {
1920 int i;
1921
1922 for (i = 0; i < MAX_MB_SEGMENTS; i++)
1923 cpi->segment_encode_breakout[i] = cpi->oxcf.encode_breakout;
1924 }
1925
1926 // At the moment the first order values may not be > MAXQ
1927 if (cpi->oxcf.fixed_q > MAXQ)
1928 cpi->oxcf.fixed_q = MAXQ;
1929
1930 // local file playback mode == really big buffer
1931 if (cpi->oxcf.end_usage == USAGE_LOCAL_FILE_PLAYBACK)
1932 {
1933 cpi->oxcf.starting_buffer_level = 60000;
1934 cpi->oxcf.optimal_buffer_level = 60000;
1935 cpi->oxcf.maximum_buffer_size = 240000;
1936
1937 }
1938
1939 // Convert target bandwidth from Kbit/s to Bit/s
1940 cpi->oxcf.target_bandwidth *= 1000;
1941
1942 cpi->oxcf.starting_buffer_level =
1943 rescale(cpi->oxcf.starting_buffer_level,
1944 cpi->oxcf.target_bandwidth, 1000);
1945
1946 if (cpi->oxcf.optimal_buffer_level == 0)
1947 cpi->oxcf.optimal_buffer_level = cpi->oxcf.target_bandwidth / 8;
1948 else
1949 cpi->oxcf.optimal_buffer_level =
1950 rescale(cpi->oxcf.optimal_buffer_level,
1951 cpi->oxcf.target_bandwidth, 1000);
1952
1953 if (cpi->oxcf.maximum_buffer_size == 0)
1954 cpi->oxcf.maximum_buffer_size = cpi->oxcf.target_bandwidth / 8;
1955 else
1956 cpi->oxcf.maximum_buffer_size =
1957 rescale(cpi->oxcf.maximum_buffer_size,
1958 cpi->oxcf.target_bandwidth, 1000);
1959
1960 cpi->buffer_level = cpi->oxcf.starting_buffer_level;
1961 cpi->bits_off_target = cpi->oxcf.starting_buffer_level;
1962
1963 vp8_new_frame_rate(cpi, cpi->oxcf.frame_rate);
1964 cpi->worst_quality = cpi->oxcf.worst_allowed_q;
1965 cpi->active_worst_quality = cpi->oxcf.worst_allowed_q;
1966 cpi->avg_frame_qindex = cpi->oxcf.worst_allowed_q;
1967 cpi->best_quality = cpi->oxcf.best_allowed_q;
1968 cpi->active_best_quality = cpi->oxcf.best_allowed_q;
1969 cpi->buffered_mode = (cpi->oxcf.optimal_buffer_level > 0) ? TRUE : FALSE;
1970
1971 cpi->rolling_target_bits = cpi->av_per_frame_bandwidth;
1972 cpi->rolling_actual_bits = cpi->av_per_frame_bandwidth;
1973 cpi->long_rolling_target_bits = cpi->av_per_frame_bandwidth;
1974 cpi->long_rolling_actual_bits = cpi->av_per_frame_bandwidth;
1975
1976 cpi->total_actual_bits = 0;
1977 cpi->total_target_vs_actual = 0;
1978
1979 // Only allow dropped frames in buffered mode
1980 cpi->drop_frames_allowed = cpi->oxcf.allow_df && cpi->buffered_mode;
1981
1982 cm->filter_type = (LOOPFILTERTYPE) cpi->filter_type;
1983
1984 if (!cm->use_bilinear_mc_filter)
1985 cm->mcomp_filter_type = SIXTAP;
1986 else
1987 cm->mcomp_filter_type = BILINEAR;
1988
1989 cpi->target_bandwidth = cpi->oxcf.target_bandwidth;
1990
1991 cm->Width = cpi->oxcf.Width ;
1992 cm->Height = cpi->oxcf.Height ;
1993
1994 cm->horiz_scale = cpi->horiz_scale;
1995 cm->vert_scale = cpi->vert_scale ;
1996
1997 cpi->intra_frame_target = (4 * (cm->Width + cm->Height) / 15) * 1000; // As per VP8
1998
1999 // VP8 sharpness level mapping 0-7 (vs 0-10 in general VPx dialogs)
2000 if (cpi->oxcf.Sharpness > 7)
2001 cpi->oxcf.Sharpness = 7;
2002
2003 cm->sharpness_level = cpi->oxcf.Sharpness;
2004
2005 if (cm->horiz_scale != NORMAL || cm->vert_scale != NORMAL)
2006 {
2007 int UNINITIALIZED_IS_SAFE(hr), UNINITIALIZED_IS_SAFE(hs);
2008 int UNINITIALIZED_IS_SAFE(vr), UNINITIALIZED_IS_SAFE(vs);
2009
2010 Scale2Ratio(cm->horiz_scale, &hr, &hs);
2011 Scale2Ratio(cm->vert_scale, &vr, &vs);
2012
2013 // always go to the next whole number
2014 cm->Width = (hs - 1 + cpi->oxcf.Width * hr) / hs;
2015 cm->Height = (vs - 1 + cpi->oxcf.Height * vr) / vs;
2016 }
2017
2018 if (((cm->Width + 15) & 0xfffffff0) != cm->yv12_fb[cm->lst_fb_idx].y_width ||
2019 ((cm->Height + 15) & 0xfffffff0) != cm->yv12_fb[cm->lst_fb_idx].y_height ||
2020 cm->yv12_fb[cm->lst_fb_idx].y_width == 0)
2021 {
2022 alloc_raw_frame_buffers(cpi);
2023 vp8_alloc_compressor_data(cpi);
2024 }
2025
2026 // Clamp KF frame size to quarter of data rate
2027 if (cpi->intra_frame_target > cpi->target_bandwidth >> 2)
2028 cpi->intra_frame_target = cpi->target_bandwidth >> 2;
2029
2030 if (cpi->oxcf.fixed_q >= 0)
2031 {
2032 cpi->last_q[0] = cpi->oxcf.fixed_q;
2033 cpi->last_q[1] = cpi->oxcf.fixed_q;
2034 }
2035
2036 cpi->Speed = cpi->oxcf.cpu_used;
2037
2038 // force to allowlag to 0 if lag_in_frames is 0;
2039 if (cpi->oxcf.lag_in_frames == 0)
2040 {
2041 cpi->oxcf.allow_lag = 0;
2042 }
2043 // Limit on lag buffers as these are not currently dynamically allocated
2044 else if (cpi->oxcf.lag_in_frames > MAX_LAG_BUFFERS)
2045 cpi->oxcf.lag_in_frames = MAX_LAG_BUFFERS;
2046
2047 // YX Temp
2048 cpi->last_alt_ref_sei = -1;
2049 cpi->is_src_frame_alt_ref = 0;
2050 cpi->is_next_src_alt_ref = 0;
2051
2052 #if 0
2053 // Experimental RD Code
2054 cpi->frame_distortion = 0;
2055 cpi->last_frame_distortion = 0;
2056 #endif
2057
2058 }
2059
2060 #define M_LOG2_E 0.693147180559945309417
2061 #define log2f(x) (log (x) / (float) M_LOG2_E)
cal_mvsadcosts(int * mvsadcost[2])2062 static void cal_mvsadcosts(int *mvsadcost[2])
2063 {
2064 int i = 1;
2065
2066 mvsadcost [0] [0] = 300;
2067 mvsadcost [1] [0] = 300;
2068
2069 do
2070 {
2071 double z = 256 * (2 * (log2f(2 * i) + .6));
2072 mvsadcost [0][i] = (int) z;
2073 mvsadcost [1][i] = (int) z;
2074 mvsadcost [0][-i] = (int) z;
2075 mvsadcost [1][-i] = (int) z;
2076 }
2077 while (++i <= mv_max);
2078 }
2079
vp8_create_compressor(VP8_CONFIG * oxcf)2080 VP8_PTR vp8_create_compressor(VP8_CONFIG *oxcf)
2081 {
2082 int i;
2083 volatile union
2084 {
2085 VP8_COMP *cpi;
2086 VP8_PTR ptr;
2087 } ctx;
2088
2089 VP8_COMP *cpi;
2090 VP8_COMMON *cm;
2091
2092 cpi = ctx.cpi = vpx_memalign(32, sizeof(VP8_COMP));
2093 // Check that the CPI instance is valid
2094 if (!cpi)
2095 return 0;
2096
2097 cm = &cpi->common;
2098
2099 vpx_memset(cpi, 0, sizeof(VP8_COMP));
2100
2101 if (setjmp(cm->error.jmp))
2102 {
2103 VP8_PTR ptr = ctx.ptr;
2104
2105 ctx.cpi->common.error.setjmp = 0;
2106 vp8_remove_compressor(&ptr);
2107 return 0;
2108 }
2109
2110 cpi->common.error.setjmp = 1;
2111
2112 CHECK_MEM_ERROR(cpi->rdtok, vpx_calloc(256 * 3 / 2, sizeof(TOKENEXTRA)));
2113 CHECK_MEM_ERROR(cpi->mb.ss, vpx_calloc(sizeof(search_site), (MAX_MVSEARCH_STEPS * 8) + 1));
2114
2115 vp8_create_common(&cpi->common);
2116 vp8_cmachine_specific_config(cpi);
2117
2118 vp8_init_config((VP8_PTR)cpi, oxcf);
2119
2120 memcpy(cpi->base_skip_false_prob, vp8cx_base_skip_false_prob, sizeof(vp8cx_base_skip_false_prob));
2121 cpi->common.current_video_frame = 0;
2122 cpi->kf_overspend_bits = 0;
2123 cpi->kf_bitrate_adjustment = 0;
2124 cpi->frames_till_gf_update_due = 0;
2125 cpi->gf_overspend_bits = 0;
2126 cpi->non_gf_bitrate_adjustment = 0;
2127 cpi->prob_last_coded = 128;
2128 cpi->prob_gf_coded = 128;
2129 cpi->prob_intra_coded = 63;
2130
2131 // Prime the recent reference frame useage counters.
2132 // Hereafter they will be maintained as a sort of moving average
2133 cpi->recent_ref_frame_usage[INTRA_FRAME] = 1;
2134 cpi->recent_ref_frame_usage[LAST_FRAME] = 1;
2135 cpi->recent_ref_frame_usage[GOLDEN_FRAME] = 1;
2136 cpi->recent_ref_frame_usage[ALTREF_FRAME] = 1;
2137
2138 // Set reference frame sign bias for ALTREF frame to 1 (for now)
2139 cpi->common.ref_frame_sign_bias[ALTREF_FRAME] = 1;
2140
2141 cpi->gf_decay_rate = 0;
2142 cpi->baseline_gf_interval = DEFAULT_GF_INTERVAL;
2143
2144 cpi->gold_is_last = 0 ;
2145 cpi->alt_is_last = 0 ;
2146 cpi->gold_is_alt = 0 ;
2147
2148
2149
2150 // Create the encoder segmentation map and set all entries to 0
2151 CHECK_MEM_ERROR(cpi->segmentation_map, vpx_calloc(cpi->common.mb_rows * cpi->common.mb_cols, 1));
2152 CHECK_MEM_ERROR(cpi->active_map, vpx_calloc(cpi->common.mb_rows * cpi->common.mb_cols, 1));
2153 vpx_memset(cpi->active_map , 1, (cpi->common.mb_rows * cpi->common.mb_cols));
2154 cpi->active_map_enabled = 0;
2155
2156 // Create the first pass motion map structure and set to 0
2157 // Allocate space for maximum of 15 buffers
2158 CHECK_MEM_ERROR(cpi->fp_motion_map, vpx_calloc(15*cpi->common.MBs, 1));
2159
2160 #if 0
2161 // Experimental code for lagged and one pass
2162 // Initialise one_pass GF frames stats
2163 // Update stats used for GF selection
2164 if (cpi->pass == 0)
2165 {
2166 cpi->one_pass_frame_index = 0;
2167
2168 for (i = 0; i < MAX_LAG_BUFFERS; i++)
2169 {
2170 cpi->one_pass_frame_stats[i].frames_so_far = 0;
2171 cpi->one_pass_frame_stats[i].frame_intra_error = 0.0;
2172 cpi->one_pass_frame_stats[i].frame_coded_error = 0.0;
2173 cpi->one_pass_frame_stats[i].frame_pcnt_inter = 0.0;
2174 cpi->one_pass_frame_stats[i].frame_pcnt_motion = 0.0;
2175 cpi->one_pass_frame_stats[i].frame_mvr = 0.0;
2176 cpi->one_pass_frame_stats[i].frame_mvr_abs = 0.0;
2177 cpi->one_pass_frame_stats[i].frame_mvc = 0.0;
2178 cpi->one_pass_frame_stats[i].frame_mvc_abs = 0.0;
2179 }
2180 }
2181 #endif
2182
2183 // Should we use the cyclic refresh method.
2184 // Currently this is tied to error resilliant mode
2185 cpi->cyclic_refresh_mode_enabled = cpi->oxcf.error_resilient_mode;
2186 cpi->cyclic_refresh_mode_max_mbs_perframe = (cpi->common.mb_rows * cpi->common.mb_cols) / 40;
2187 cpi->cyclic_refresh_mode_index = 0;
2188 cpi->cyclic_refresh_q = 32;
2189
2190 if (cpi->cyclic_refresh_mode_enabled)
2191 {
2192 CHECK_MEM_ERROR(cpi->cyclic_refresh_map, vpx_calloc((cpi->common.mb_rows * cpi->common.mb_cols), 1));
2193 }
2194 else
2195 cpi->cyclic_refresh_map = (signed char *) NULL;
2196
2197 // Test function for segmentation
2198 //segmentation_test_function((VP8_PTR) cpi);
2199
2200 #ifdef ENTROPY_STATS
2201 init_context_counters();
2202 #endif
2203
2204
2205 cpi->frames_since_key = 8; // Give a sensible default for the first frame.
2206 cpi->key_frame_frequency = cpi->oxcf.key_freq;
2207
2208 cpi->source_alt_ref_pending = FALSE;
2209 cpi->source_alt_ref_active = FALSE;
2210 cpi->common.refresh_alt_ref_frame = 0;
2211
2212 cpi->b_calculate_psnr = CONFIG_PSNR;
2213 #if CONFIG_PSNR
2214 cpi->b_calculate_ssimg = 0;
2215
2216 cpi->count = 0;
2217 cpi->bytes = 0;
2218
2219 if (cpi->b_calculate_psnr)
2220 {
2221 cpi->total_sq_error = 0.0;
2222 cpi->total_sq_error2 = 0.0;
2223 cpi->total_y = 0.0;
2224 cpi->total_u = 0.0;
2225 cpi->total_v = 0.0;
2226 cpi->total = 0.0;
2227 cpi->totalp_y = 0.0;
2228 cpi->totalp_u = 0.0;
2229 cpi->totalp_v = 0.0;
2230 cpi->totalp = 0.0;
2231 cpi->tot_recode_hits = 0;
2232 cpi->summed_quality = 0;
2233 cpi->summed_weights = 0;
2234 }
2235
2236 if (cpi->b_calculate_ssimg)
2237 {
2238 cpi->total_ssimg_y = 0;
2239 cpi->total_ssimg_u = 0;
2240 cpi->total_ssimg_v = 0;
2241 cpi->total_ssimg_all = 0;
2242 }
2243
2244 #ifndef LLONG_MAX
2245 #define LLONG_MAX 9223372036854775807LL
2246 #endif
2247 cpi->first_time_stamp_ever = LLONG_MAX;
2248
2249 #endif
2250
2251 cpi->frames_till_gf_update_due = 0;
2252 cpi->key_frame_count = 1;
2253 cpi->tot_key_frame_bits = 0;
2254
2255 cpi->ni_av_qi = cpi->oxcf.worst_allowed_q;
2256 cpi->ni_tot_qi = 0;
2257 cpi->ni_frames = 0;
2258 cpi->total_byte_count = 0;
2259
2260 cpi->drop_frame = 0;
2261 cpi->drop_count = 0;
2262 cpi->max_drop_count = 0;
2263 cpi->max_consec_dropped_frames = 4;
2264
2265 cpi->rate_correction_factor = 1.0;
2266 cpi->key_frame_rate_correction_factor = 1.0;
2267 cpi->gf_rate_correction_factor = 1.0;
2268 cpi->est_max_qcorrection_factor = 1.0;
2269
2270 cpi->mb.mvcost[0] = &cpi->mb.mvcosts[0][mv_max+1];
2271 cpi->mb.mvcost[1] = &cpi->mb.mvcosts[1][mv_max+1];
2272 cpi->mb.mvsadcost[0] = &cpi->mb.mvsadcosts[0][mv_max+1];
2273 cpi->mb.mvsadcost[1] = &cpi->mb.mvsadcosts[1][mv_max+1];
2274
2275 cal_mvsadcosts(cpi->mb.mvsadcost);
2276
2277 for (i = 0; i < KEY_FRAME_CONTEXT; i++)
2278 {
2279 cpi->prior_key_frame_size[i] = cpi->intra_frame_target;
2280 cpi->prior_key_frame_distance[i] = (int)cpi->output_frame_rate;
2281 }
2282
2283 cpi->check_freq[0] = 15;
2284 cpi->check_freq[1] = 15;
2285
2286 #ifdef OUTPUT_YUV_SRC
2287 yuv_file = fopen("bd.yuv", "ab");
2288 #endif
2289
2290 #if 0
2291 framepsnr = fopen("framepsnr.stt", "a");
2292 kf_list = fopen("kf_list.stt", "w");
2293 #endif
2294
2295 cpi->output_pkt_list = oxcf->output_pkt_list;
2296
2297 #if !(CONFIG_REALTIME_ONLY)
2298
2299 if (cpi->pass == 1)
2300 {
2301 vp8_init_first_pass(cpi);
2302 }
2303 else if (cpi->pass == 2)
2304 {
2305 size_t packet_sz = vp8_firstpass_stats_sz(cpi->common.MBs);
2306 int packets = oxcf->two_pass_stats_in.sz / packet_sz;
2307
2308 cpi->stats_in = oxcf->two_pass_stats_in.buf;
2309 cpi->stats_in_end = (void*)((char *)cpi->stats_in
2310 + (packets - 1) * packet_sz);
2311 vp8_init_second_pass(cpi);
2312 }
2313
2314 #endif
2315
2316 if (cpi->compressor_speed == 2)
2317 {
2318 cpi->cpu_freq = 0; //vp8_get_processor_freq();
2319 cpi->avg_encode_time = 0;
2320 cpi->avg_pick_mode_time = 0;
2321 }
2322
2323 vp8_set_speed_features(cpi);
2324
2325 // Set starting values of RD threshold multipliers (128 = *1)
2326 for (i = 0; i < MAX_MODES; i++)
2327 {
2328 cpi->rd_thresh_mult[i] = 128;
2329 }
2330
2331 #ifdef ENTROPY_STATS
2332 init_mv_ref_counts();
2333 #endif
2334
2335 vp8cx_create_encoder_threads(cpi);
2336
2337 cpi->fn_ptr[BLOCK_16X16].sdf = VARIANCE_INVOKE(&cpi->rtcd.variance, sad16x16);
2338 cpi->fn_ptr[BLOCK_16X16].vf = VARIANCE_INVOKE(&cpi->rtcd.variance, var16x16);
2339 cpi->fn_ptr[BLOCK_16X16].svf = VARIANCE_INVOKE(&cpi->rtcd.variance, subpixvar16x16);
2340 cpi->fn_ptr[BLOCK_16X16].svf_halfpix_h = VARIANCE_INVOKE(&cpi->rtcd.variance, halfpixvar16x16_h);
2341 cpi->fn_ptr[BLOCK_16X16].svf_halfpix_v = VARIANCE_INVOKE(&cpi->rtcd.variance, halfpixvar16x16_v);
2342 cpi->fn_ptr[BLOCK_16X16].svf_halfpix_hv = VARIANCE_INVOKE(&cpi->rtcd.variance, halfpixvar16x16_hv);
2343 cpi->fn_ptr[BLOCK_16X16].sdx3f = VARIANCE_INVOKE(&cpi->rtcd.variance, sad16x16x3);
2344 cpi->fn_ptr[BLOCK_16X16].sdx8f = VARIANCE_INVOKE(&cpi->rtcd.variance, sad16x16x8);
2345 cpi->fn_ptr[BLOCK_16X16].sdx4df = VARIANCE_INVOKE(&cpi->rtcd.variance, sad16x16x4d);
2346
2347 cpi->fn_ptr[BLOCK_16X8].sdf = VARIANCE_INVOKE(&cpi->rtcd.variance, sad16x8);
2348 cpi->fn_ptr[BLOCK_16X8].vf = VARIANCE_INVOKE(&cpi->rtcd.variance, var16x8);
2349 cpi->fn_ptr[BLOCK_16X8].svf = VARIANCE_INVOKE(&cpi->rtcd.variance, subpixvar16x8);
2350 cpi->fn_ptr[BLOCK_16X8].svf_halfpix_h = NULL;
2351 cpi->fn_ptr[BLOCK_16X8].svf_halfpix_v = NULL;
2352 cpi->fn_ptr[BLOCK_16X8].svf_halfpix_hv = NULL;
2353 cpi->fn_ptr[BLOCK_16X8].sdx3f = VARIANCE_INVOKE(&cpi->rtcd.variance, sad16x8x3);
2354 cpi->fn_ptr[BLOCK_16X8].sdx8f = VARIANCE_INVOKE(&cpi->rtcd.variance, sad16x8x8);
2355 cpi->fn_ptr[BLOCK_16X8].sdx4df = VARIANCE_INVOKE(&cpi->rtcd.variance, sad16x8x4d);
2356
2357 cpi->fn_ptr[BLOCK_8X16].sdf = VARIANCE_INVOKE(&cpi->rtcd.variance, sad8x16);
2358 cpi->fn_ptr[BLOCK_8X16].vf = VARIANCE_INVOKE(&cpi->rtcd.variance, var8x16);
2359 cpi->fn_ptr[BLOCK_8X16].svf = VARIANCE_INVOKE(&cpi->rtcd.variance, subpixvar8x16);
2360 cpi->fn_ptr[BLOCK_8X16].svf_halfpix_h = NULL;
2361 cpi->fn_ptr[BLOCK_8X16].svf_halfpix_v = NULL;
2362 cpi->fn_ptr[BLOCK_8X16].svf_halfpix_hv = NULL;
2363 cpi->fn_ptr[BLOCK_8X16].sdx3f = VARIANCE_INVOKE(&cpi->rtcd.variance, sad8x16x3);
2364 cpi->fn_ptr[BLOCK_8X16].sdx8f = VARIANCE_INVOKE(&cpi->rtcd.variance, sad8x16x8);
2365 cpi->fn_ptr[BLOCK_8X16].sdx4df = VARIANCE_INVOKE(&cpi->rtcd.variance, sad8x16x4d);
2366
2367 cpi->fn_ptr[BLOCK_8X8].sdf = VARIANCE_INVOKE(&cpi->rtcd.variance, sad8x8);
2368 cpi->fn_ptr[BLOCK_8X8].vf = VARIANCE_INVOKE(&cpi->rtcd.variance, var8x8);
2369 cpi->fn_ptr[BLOCK_8X8].svf = VARIANCE_INVOKE(&cpi->rtcd.variance, subpixvar8x8);
2370 cpi->fn_ptr[BLOCK_8X8].svf_halfpix_h = NULL;
2371 cpi->fn_ptr[BLOCK_8X8].svf_halfpix_v = NULL;
2372 cpi->fn_ptr[BLOCK_8X8].svf_halfpix_hv = NULL;
2373 cpi->fn_ptr[BLOCK_8X8].sdx3f = VARIANCE_INVOKE(&cpi->rtcd.variance, sad8x8x3);
2374 cpi->fn_ptr[BLOCK_8X8].sdx8f = VARIANCE_INVOKE(&cpi->rtcd.variance, sad8x8x8);
2375 cpi->fn_ptr[BLOCK_8X8].sdx4df = VARIANCE_INVOKE(&cpi->rtcd.variance, sad8x8x4d);
2376
2377 cpi->fn_ptr[BLOCK_4X4].sdf = VARIANCE_INVOKE(&cpi->rtcd.variance, sad4x4);
2378 cpi->fn_ptr[BLOCK_4X4].vf = VARIANCE_INVOKE(&cpi->rtcd.variance, var4x4);
2379 cpi->fn_ptr[BLOCK_4X4].svf = VARIANCE_INVOKE(&cpi->rtcd.variance, subpixvar4x4);
2380 cpi->fn_ptr[BLOCK_4X4].svf_halfpix_h = NULL;
2381 cpi->fn_ptr[BLOCK_4X4].svf_halfpix_v = NULL;
2382 cpi->fn_ptr[BLOCK_4X4].svf_halfpix_hv = NULL;
2383 cpi->fn_ptr[BLOCK_4X4].sdx3f = VARIANCE_INVOKE(&cpi->rtcd.variance, sad4x4x3);
2384 cpi->fn_ptr[BLOCK_4X4].sdx8f = VARIANCE_INVOKE(&cpi->rtcd.variance, sad4x4x8);
2385 cpi->fn_ptr[BLOCK_4X4].sdx4df = VARIANCE_INVOKE(&cpi->rtcd.variance, sad4x4x4d);
2386
2387 #if !(CONFIG_REALTIME_ONLY)
2388 cpi->full_search_sad = SEARCH_INVOKE(&cpi->rtcd.search, full_search);
2389 #endif
2390 cpi->diamond_search_sad = SEARCH_INVOKE(&cpi->rtcd.search, diamond_search);
2391
2392 cpi->ready_for_new_frame = 1;
2393
2394 cpi->source_encode_index = 0;
2395
2396 // make sure frame 1 is okay
2397 cpi->error_bins[0] = cpi->common.MBs;
2398
2399 //vp8cx_init_quantizer() is first called here. Add check in vp8cx_frame_init_quantizer() so that vp8cx_init_quantizer is only called later
2400 //when needed. This will avoid unnecessary calls of vp8cx_init_quantizer() for every frame.
2401 vp8cx_init_quantizer(cpi);
2402 {
2403 vp8_init_loop_filter(cm);
2404 cm->last_frame_type = KEY_FRAME;
2405 cm->last_filter_type = cm->filter_type;
2406 cm->last_sharpness_level = cm->sharpness_level;
2407 }
2408 cpi->common.error.setjmp = 0;
2409 return (VP8_PTR) cpi;
2410
2411 }
2412
2413
vp8_remove_compressor(VP8_PTR * ptr)2414 void vp8_remove_compressor(VP8_PTR *ptr)
2415 {
2416 VP8_COMP *cpi = (VP8_COMP *)(*ptr);
2417
2418 if (!cpi)
2419 return;
2420
2421 if (cpi && (cpi->common.current_video_frame > 0))
2422 {
2423 #if !(CONFIG_REALTIME_ONLY)
2424
2425 if (cpi->pass == 2)
2426 {
2427 vp8_end_second_pass(cpi);
2428 }
2429
2430 #endif
2431
2432 #ifdef ENTROPY_STATS
2433 print_context_counters();
2434 print_tree_update_probs();
2435 print_mode_context();
2436 #endif
2437
2438 #if CONFIG_PSNR
2439
2440 if (cpi->pass != 1)
2441 {
2442 FILE *f = fopen("opsnr.stt", "a");
2443 double time_encoded = (cpi->source_end_time_stamp - cpi->first_time_stamp_ever) / 10000000.000;
2444 double total_encode_time = (cpi->time_receive_data + cpi->time_compress_data) / 1000.000;
2445 double dr = (double)cpi->bytes * (double) 8 / (double)1000 / time_encoded;
2446
2447 if (cpi->b_calculate_psnr)
2448 {
2449 YV12_BUFFER_CONFIG *lst_yv12 = &cpi->common.yv12_fb[cpi->common.lst_fb_idx];
2450 double samples = 3.0 / 2 * cpi->count * lst_yv12->y_width * lst_yv12->y_height;
2451 double total_psnr = vp8_mse2psnr(samples, 255.0, cpi->total_sq_error);
2452 double total_psnr2 = vp8_mse2psnr(samples, 255.0, cpi->total_sq_error2);
2453 double total_ssim = 100 * pow(cpi->summed_quality / cpi->summed_weights, 8.0);
2454
2455 fprintf(f, "Bitrate\tAVGPsnr\tGLBPsnr\tAVPsnrP\tGLPsnrP\tVPXSSIM\t Time(us)\n");
2456 fprintf(f, "%7.3f\t%7.3f\t%7.3f\t%7.3f\t%7.3f\t%7.3f %8.0f\n",
2457 dr, cpi->total / cpi->count, total_psnr, cpi->totalp / cpi->count, total_psnr2, total_ssim,
2458 total_encode_time);
2459 }
2460
2461 if (cpi->b_calculate_ssimg)
2462 {
2463 fprintf(f, "BitRate\tSSIM_Y\tSSIM_U\tSSIM_V\tSSIM_A\t Time(us)\n");
2464 fprintf(f, "%7.3f\t%6.4f\t%6.4f\t%6.4f\t%6.4f\t%8.0f\n", dr,
2465 cpi->total_ssimg_y / cpi->count, cpi->total_ssimg_u / cpi->count,
2466 cpi->total_ssimg_v / cpi->count, cpi->total_ssimg_all / cpi->count, total_encode_time);
2467 }
2468
2469 fclose(f);
2470 #if 0
2471 f = fopen("qskip.stt", "a");
2472 fprintf(f, "minq:%d -maxq:%d skipture:skipfalse = %d:%d\n", cpi->oxcf.best_allowed_q, cpi->oxcf.worst_allowed_q, skiptruecount, skipfalsecount);
2473 fclose(f);
2474 #endif
2475
2476 }
2477
2478 #endif
2479
2480
2481 #ifdef SPEEDSTATS
2482
2483 if (cpi->compressor_speed == 2)
2484 {
2485 int i;
2486 FILE *f = fopen("cxspeed.stt", "a");
2487 cnt_pm /= cpi->common.MBs;
2488
2489 for (i = 0; i < 16; i++)
2490 fprintf(f, "%5d", frames_at_speed[i]);
2491
2492 fprintf(f, "\n");
2493 //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);
2494 fclose(f);
2495 }
2496
2497 #endif
2498
2499
2500 #ifdef MODE_STATS
2501 {
2502 extern int count_mb_seg[4];
2503 FILE *f = fopen("modes.stt", "a");
2504 double dr = (double)cpi->oxcf.frame_rate * (double)bytes * (double)8 / (double)count / (double)1000 ;
2505 fprintf(f, "intra_mode in Intra Frames:\n");
2506 fprintf(f, "Y: %8d, %8d, %8d, %8d, %8d\n", y_modes[0], y_modes[1], y_modes[2], y_modes[3], y_modes[4]);
2507 fprintf(f, "UV:%8d, %8d, %8d, %8d\n", uv_modes[0], uv_modes[1], uv_modes[2], uv_modes[3]);
2508 fprintf(f, "B: ");
2509 {
2510 int i;
2511
2512 for (i = 0; i < 10; i++)
2513 fprintf(f, "%8d, ", b_modes[i]);
2514
2515 fprintf(f, "\n");
2516
2517 }
2518
2519 fprintf(f, "Modes in Inter Frames:\n");
2520 fprintf(f, "Y: %8d, %8d, %8d, %8d, %8d, %8d, %8d, %8d, %8d, %8d\n",
2521 inter_y_modes[0], inter_y_modes[1], inter_y_modes[2], inter_y_modes[3], inter_y_modes[4],
2522 inter_y_modes[5], inter_y_modes[6], inter_y_modes[7], inter_y_modes[8], inter_y_modes[9]);
2523 fprintf(f, "UV:%8d, %8d, %8d, %8d\n", inter_uv_modes[0], inter_uv_modes[1], inter_uv_modes[2], inter_uv_modes[3]);
2524 fprintf(f, "B: ");
2525 {
2526 int i;
2527
2528 for (i = 0; i < 15; i++)
2529 fprintf(f, "%8d, ", inter_b_modes[i]);
2530
2531 fprintf(f, "\n");
2532
2533 }
2534 fprintf(f, "P:%8d, %8d, %8d, %8d\n", count_mb_seg[0], count_mb_seg[1], count_mb_seg[2], count_mb_seg[3]);
2535 fprintf(f, "PB:%8d, %8d, %8d, %8d\n", inter_b_modes[LEFT4X4], inter_b_modes[ABOVE4X4], inter_b_modes[ZERO4X4], inter_b_modes[NEW4X4]);
2536
2537
2538
2539 fclose(f);
2540 }
2541 #endif
2542
2543 #ifdef ENTROPY_STATS
2544 {
2545 int i, j, k;
2546 FILE *fmode = fopen("modecontext.c", "w");
2547
2548 fprintf(fmode, "\n#include \"entropymode.h\"\n\n");
2549 fprintf(fmode, "const unsigned int vp8_kf_default_bmode_counts ");
2550 fprintf(fmode, "[VP8_BINTRAMODES] [VP8_BINTRAMODES] [VP8_BINTRAMODES] =\n{\n");
2551
2552 for (i = 0; i < 10; i++)
2553 {
2554
2555 fprintf(fmode, " { //Above Mode : %d\n", i);
2556
2557 for (j = 0; j < 10; j++)
2558 {
2559
2560 fprintf(fmode, " {");
2561
2562 for (k = 0; k < 10; k++)
2563 {
2564 if (!intra_mode_stats[i][j][k])
2565 fprintf(fmode, " %5d, ", 1);
2566 else
2567 fprintf(fmode, " %5d, ", intra_mode_stats[i][j][k]);
2568 }
2569
2570 fprintf(fmode, "}, // left_mode %d\n", j);
2571
2572 }
2573
2574 fprintf(fmode, " },\n");
2575
2576 }
2577
2578 fprintf(fmode, "};\n");
2579 fclose(fmode);
2580 }
2581 #endif
2582
2583
2584 #if defined(SECTIONBITS_OUTPUT)
2585
2586 if (0)
2587 {
2588 int i;
2589 FILE *f = fopen("tokenbits.stt", "a");
2590
2591 for (i = 0; i < 28; i++)
2592 fprintf(f, "%8d", (int)(Sectionbits[i] / 256));
2593
2594 fprintf(f, "\n");
2595 fclose(f);
2596 }
2597
2598 #endif
2599
2600 #if 0
2601 {
2602 printf("\n_pick_loop_filter_level:%d\n", cpi->time_pick_lpf / 1000);
2603 printf("\n_frames recive_data encod_mb_row compress_frame Total\n");
2604 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);
2605 }
2606 #endif
2607
2608 }
2609
2610 vp8cx_remove_encoder_threads(cpi);
2611
2612 vp8_dealloc_compressor_data(cpi);
2613 vpx_free(cpi->mb.ss);
2614 vpx_free(cpi->tok);
2615 vpx_free(cpi->rdtok);
2616 vpx_free(cpi->cyclic_refresh_map);
2617
2618 vp8_remove_common(&cpi->common);
2619 vpx_free(cpi);
2620 *ptr = 0;
2621
2622 #ifdef OUTPUT_YUV_SRC
2623 fclose(yuv_file);
2624 #endif
2625
2626 #if 0
2627
2628 if (keyfile)
2629 fclose(keyfile);
2630
2631 if (framepsnr)
2632 fclose(framepsnr);
2633
2634 if (kf_list)
2635 fclose(kf_list);
2636
2637 #endif
2638
2639 }
2640
2641
calc_plane_error(unsigned char * orig,int orig_stride,unsigned char * recon,int recon_stride,unsigned int cols,unsigned int rows,vp8_variance_rtcd_vtable_t * rtcd)2642 static uint64_t calc_plane_error(unsigned char *orig, int orig_stride,
2643 unsigned char *recon, int recon_stride,
2644 unsigned int cols, unsigned int rows,
2645 vp8_variance_rtcd_vtable_t *rtcd)
2646 {
2647 unsigned int row, col;
2648 uint64_t total_sse = 0;
2649 int diff;
2650
2651 for (row = 0; row + 16 <= rows; row += 16)
2652 {
2653 for (col = 0; col + 16 <= cols; col += 16)
2654 {
2655 unsigned int sse;
2656
2657 VARIANCE_INVOKE(rtcd, mse16x16)(orig + col, orig_stride,
2658 recon + col, recon_stride,
2659 &sse);
2660 total_sse += sse;
2661 }
2662
2663 /* Handle odd-sized width */
2664 if (col < cols)
2665 {
2666 unsigned int border_row, border_col;
2667 unsigned char *border_orig = orig;
2668 unsigned char *border_recon = recon;
2669
2670 for (border_row = 0; border_row < 16; border_row++)
2671 {
2672 for (border_col = col; border_col < cols; border_col++)
2673 {
2674 diff = border_orig[border_col] - border_recon[border_col];
2675 total_sse += diff * diff;
2676 }
2677
2678 border_orig += orig_stride;
2679 border_recon += recon_stride;
2680 }
2681 }
2682
2683 orig += orig_stride * 16;
2684 recon += recon_stride * 16;
2685 }
2686
2687 /* Handle odd-sized height */
2688 for (; row < rows; row++)
2689 {
2690 for (col = 0; col < cols; col++)
2691 {
2692 diff = orig[col] - recon[col];
2693 total_sse += diff * diff;
2694 }
2695
2696 orig += orig_stride;
2697 recon += recon_stride;
2698 }
2699
2700 return total_sse;
2701 }
2702
2703
generate_psnr_packet(VP8_COMP * cpi)2704 static void generate_psnr_packet(VP8_COMP *cpi)
2705 {
2706 YV12_BUFFER_CONFIG *orig = cpi->Source;
2707 YV12_BUFFER_CONFIG *recon = cpi->common.frame_to_show;
2708 struct vpx_codec_cx_pkt pkt;
2709 uint64_t sse;
2710 int i;
2711 unsigned int width = cpi->common.Width;
2712 unsigned int height = cpi->common.Height;
2713
2714 pkt.kind = VPX_CODEC_PSNR_PKT;
2715 sse = calc_plane_error(orig->y_buffer, orig->y_stride,
2716 recon->y_buffer, recon->y_stride,
2717 width, height,
2718 IF_RTCD(&cpi->rtcd.variance));
2719 pkt.data.psnr.sse[0] = sse;
2720 pkt.data.psnr.sse[1] = sse;
2721 pkt.data.psnr.samples[0] = width * height;
2722 pkt.data.psnr.samples[1] = width * height;
2723
2724 width = (width + 1) / 2;
2725 height = (height + 1) / 2;
2726
2727 sse = calc_plane_error(orig->u_buffer, orig->uv_stride,
2728 recon->u_buffer, recon->uv_stride,
2729 width, height,
2730 IF_RTCD(&cpi->rtcd.variance));
2731 pkt.data.psnr.sse[0] += sse;
2732 pkt.data.psnr.sse[2] = sse;
2733 pkt.data.psnr.samples[0] += width * height;
2734 pkt.data.psnr.samples[2] = width * height;
2735
2736 sse = calc_plane_error(orig->v_buffer, orig->uv_stride,
2737 recon->v_buffer, recon->uv_stride,
2738 width, height,
2739 IF_RTCD(&cpi->rtcd.variance));
2740 pkt.data.psnr.sse[0] += sse;
2741 pkt.data.psnr.sse[3] = sse;
2742 pkt.data.psnr.samples[0] += width * height;
2743 pkt.data.psnr.samples[3] = width * height;
2744
2745 for (i = 0; i < 4; i++)
2746 pkt.data.psnr.psnr[i] = vp8_mse2psnr(pkt.data.psnr.samples[i], 255.0,
2747 pkt.data.psnr.sse[i]);
2748
2749 vpx_codec_pkt_list_add(cpi->output_pkt_list, &pkt);
2750 }
2751
2752
vp8_use_as_reference(VP8_PTR ptr,int ref_frame_flags)2753 int vp8_use_as_reference(VP8_PTR ptr, int ref_frame_flags)
2754 {
2755 VP8_COMP *cpi = (VP8_COMP *)(ptr);
2756
2757 if (ref_frame_flags > 7)
2758 return -1 ;
2759
2760 cpi->ref_frame_flags = ref_frame_flags;
2761 return 0;
2762 }
vp8_update_reference(VP8_PTR ptr,int ref_frame_flags)2763 int vp8_update_reference(VP8_PTR ptr, int ref_frame_flags)
2764 {
2765 VP8_COMP *cpi = (VP8_COMP *)(ptr);
2766
2767 if (ref_frame_flags > 7)
2768 return -1 ;
2769
2770 cpi->common.refresh_golden_frame = 0;
2771 cpi->common.refresh_alt_ref_frame = 0;
2772 cpi->common.refresh_last_frame = 0;
2773
2774 if (ref_frame_flags & VP8_LAST_FLAG)
2775 cpi->common.refresh_last_frame = 1;
2776
2777 if (ref_frame_flags & VP8_GOLD_FLAG)
2778 cpi->common.refresh_golden_frame = 1;
2779
2780 if (ref_frame_flags & VP8_ALT_FLAG)
2781 cpi->common.refresh_alt_ref_frame = 1;
2782
2783 return 0;
2784 }
2785
vp8_get_reference(VP8_PTR ptr,VP8_REFFRAME ref_frame_flag,YV12_BUFFER_CONFIG * sd)2786 int vp8_get_reference(VP8_PTR ptr, VP8_REFFRAME ref_frame_flag, YV12_BUFFER_CONFIG *sd)
2787 {
2788 VP8_COMP *cpi = (VP8_COMP *)(ptr);
2789 VP8_COMMON *cm = &cpi->common;
2790 int ref_fb_idx;
2791
2792 if (ref_frame_flag == VP8_LAST_FLAG)
2793 ref_fb_idx = cm->lst_fb_idx;
2794 else if (ref_frame_flag == VP8_GOLD_FLAG)
2795 ref_fb_idx = cm->gld_fb_idx;
2796 else if (ref_frame_flag == VP8_ALT_FLAG)
2797 ref_fb_idx = cm->alt_fb_idx;
2798 else
2799 return -1;
2800
2801 vp8_yv12_copy_frame_ptr(&cm->yv12_fb[ref_fb_idx], sd);
2802
2803 return 0;
2804 }
vp8_set_reference(VP8_PTR ptr,VP8_REFFRAME ref_frame_flag,YV12_BUFFER_CONFIG * sd)2805 int vp8_set_reference(VP8_PTR ptr, VP8_REFFRAME ref_frame_flag, YV12_BUFFER_CONFIG *sd)
2806 {
2807 VP8_COMP *cpi = (VP8_COMP *)(ptr);
2808 VP8_COMMON *cm = &cpi->common;
2809
2810 int ref_fb_idx;
2811
2812 if (ref_frame_flag == VP8_LAST_FLAG)
2813 ref_fb_idx = cm->lst_fb_idx;
2814 else if (ref_frame_flag == VP8_GOLD_FLAG)
2815 ref_fb_idx = cm->gld_fb_idx;
2816 else if (ref_frame_flag == VP8_ALT_FLAG)
2817 ref_fb_idx = cm->alt_fb_idx;
2818 else
2819 return -1;
2820
2821 vp8_yv12_copy_frame_ptr(sd, &cm->yv12_fb[ref_fb_idx]);
2822
2823 return 0;
2824 }
vp8_update_entropy(VP8_PTR comp,int update)2825 int vp8_update_entropy(VP8_PTR comp, int update)
2826 {
2827 VP8_COMP *cpi = (VP8_COMP *) comp;
2828 VP8_COMMON *cm = &cpi->common;
2829 cm->refresh_entropy_probs = update;
2830
2831 return 0;
2832 }
2833
2834
2835 #if OUTPUT_YUV_SRC
vp8_write_yuv_frame(const char * name,YV12_BUFFER_CONFIG * s)2836 void vp8_write_yuv_frame(const char *name, YV12_BUFFER_CONFIG *s)
2837 {
2838 FILE *yuv_file = fopen(name, "ab");
2839 unsigned char *src = s->y_buffer;
2840 int h = s->y_height;
2841
2842 do
2843 {
2844 fwrite(src, s->y_width, 1, yuv_file);
2845 src += s->y_stride;
2846 }
2847 while (--h);
2848
2849 src = s->u_buffer;
2850 h = s->uv_height;
2851
2852 do
2853 {
2854 fwrite(src, s->uv_width, 1, yuv_file);
2855 src += s->uv_stride;
2856 }
2857 while (--h);
2858
2859 src = s->v_buffer;
2860 h = s->uv_height;
2861
2862 do
2863 {
2864 fwrite(src, s->uv_width, 1, yuv_file);
2865 src += s->uv_stride;
2866 }
2867 while (--h);
2868
2869 fclose(yuv_file);
2870 }
2871 #endif
2872
2873
scale_and_extend_source(YV12_BUFFER_CONFIG * sd,VP8_COMP * cpi)2874 static void scale_and_extend_source(YV12_BUFFER_CONFIG *sd, VP8_COMP *cpi)
2875 {
2876 VP8_COMMON *cm = &cpi->common;
2877
2878 // are we resizing the image
2879 if (cm->horiz_scale != 0 || cm->vert_scale != 0)
2880 {
2881 #if CONFIG_SPATIAL_RESAMPLING
2882 int UNINITIALIZED_IS_SAFE(hr), UNINITIALIZED_IS_SAFE(hs);
2883 int UNINITIALIZED_IS_SAFE(vr), UNINITIALIZED_IS_SAFE(vs);
2884 int tmp_height;
2885
2886 if (cm->vert_scale == 3)
2887 tmp_height = 9;
2888 else
2889 tmp_height = 11;
2890
2891 Scale2Ratio(cm->horiz_scale, &hr, &hs);
2892 Scale2Ratio(cm->vert_scale, &vr, &vs);
2893
2894 vp8_scale_frame(sd, &cpi->scaled_source, cm->temp_scale_frame.y_buffer,
2895 tmp_height, hs, hr, vs, vr, 0);
2896
2897 cpi->Source = &cpi->scaled_source;
2898 #endif
2899 }
2900 // we may need to copy to a buffer so we can extend the image...
2901 else if (cm->Width != cm->yv12_fb[cm->lst_fb_idx].y_width ||
2902 cm->Height != cm->yv12_fb[cm->lst_fb_idx].y_height)
2903 {
2904 //vp8_yv12_copy_frame_ptr(sd, &cpi->scaled_source);
2905 #if HAVE_ARMV7
2906 #if CONFIG_RUNTIME_CPU_DETECT
2907 if (cm->rtcd.flags & HAS_NEON)
2908 #endif
2909 {
2910 vp8_yv12_copy_src_frame_func_neon(sd, &cpi->scaled_source);
2911 }
2912 #if CONFIG_RUNTIME_CPU_DETECT
2913 else
2914 #endif
2915 #endif
2916 #if !HAVE_ARMV7 || CONFIG_RUNTIME_CPU_DETECT
2917 {
2918 vp8_yv12_copy_frame_ptr(sd, &cpi->scaled_source);
2919 }
2920 #endif
2921
2922 cpi->Source = &cpi->scaled_source;
2923 }
2924
2925 vp8_extend_to_multiple_of16(cpi->Source, cm->Width, cm->Height);
2926
2927 }
resize_key_frame(VP8_COMP * cpi)2928 static void resize_key_frame(VP8_COMP *cpi)
2929 {
2930 #if CONFIG_SPATIAL_RESAMPLING
2931 VP8_COMMON *cm = &cpi->common;
2932
2933 // Do we need to apply resampling for one pass cbr.
2934 // In one pass this is more limited than in two pass cbr
2935 // The test and any change is only made one per key frame sequence
2936 if (cpi->oxcf.allow_spatial_resampling && (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER))
2937 {
2938 int UNINITIALIZED_IS_SAFE(hr), UNINITIALIZED_IS_SAFE(hs);
2939 int UNINITIALIZED_IS_SAFE(vr), UNINITIALIZED_IS_SAFE(vs);
2940 int new_width, new_height;
2941
2942 // If we are below the resample DOWN watermark then scale down a notch.
2943 if (cpi->buffer_level < (cpi->oxcf.resample_down_water_mark * cpi->oxcf.optimal_buffer_level / 100))
2944 {
2945 cm->horiz_scale = (cm->horiz_scale < ONETWO) ? cm->horiz_scale + 1 : ONETWO;
2946 cm->vert_scale = (cm->vert_scale < ONETWO) ? cm->vert_scale + 1 : ONETWO;
2947 }
2948 // Should we now start scaling back up
2949 else if (cpi->buffer_level > (cpi->oxcf.resample_up_water_mark * cpi->oxcf.optimal_buffer_level / 100))
2950 {
2951 cm->horiz_scale = (cm->horiz_scale > NORMAL) ? cm->horiz_scale - 1 : NORMAL;
2952 cm->vert_scale = (cm->vert_scale > NORMAL) ? cm->vert_scale - 1 : NORMAL;
2953 }
2954
2955 // Get the new hieght and width
2956 Scale2Ratio(cm->horiz_scale, &hr, &hs);
2957 Scale2Ratio(cm->vert_scale, &vr, &vs);
2958 new_width = ((hs - 1) + (cpi->oxcf.Width * hr)) / hs;
2959 new_height = ((vs - 1) + (cpi->oxcf.Height * vr)) / vs;
2960
2961 // If the image size has changed we need to reallocate the buffers
2962 // and resample the source image
2963 if ((cm->Width != new_width) || (cm->Height != new_height))
2964 {
2965 cm->Width = new_width;
2966 cm->Height = new_height;
2967 vp8_alloc_compressor_data(cpi);
2968 scale_and_extend_source(cpi->un_scaled_source, cpi);
2969 }
2970 }
2971
2972 #endif
2973 }
2974 // return of 0 means drop frame
pick_frame_size(VP8_COMP * cpi)2975 static int pick_frame_size(VP8_COMP *cpi)
2976 {
2977 VP8_COMMON *cm = &cpi->common;
2978
2979 // First Frame is a special case
2980 if (cm->current_video_frame == 0)
2981 {
2982 #if !(CONFIG_REALTIME_ONLY)
2983
2984 if (cpi->pass == 2)
2985 vp8_calc_auto_iframe_target_size(cpi);
2986
2987 // 1 Pass there is no information on which to base size so use bandwidth per second * fixed fraction
2988 else
2989 #endif
2990 cpi->this_frame_target = cpi->oxcf.target_bandwidth / 2;
2991
2992 // in error resilient mode the first frame is bigger since it likely contains
2993 // all the static background
2994 if (cpi->oxcf.error_resilient_mode == 1 || (cpi->compressor_speed == 2))
2995 {
2996 cpi->this_frame_target *= 3; // 5;
2997 }
2998
2999 // Key frame from VFW/auto-keyframe/first frame
3000 cm->frame_type = KEY_FRAME;
3001
3002 }
3003 // Special case for forced key frames
3004 // The frame sizing here is still far from ideal for 2 pass.
3005 else if (cm->frame_flags & FRAMEFLAGS_KEY)
3006 {
3007 cm->frame_type = KEY_FRAME;
3008 resize_key_frame(cpi);
3009 vp8_calc_iframe_target_size(cpi);
3010 }
3011 else if (cm->frame_type == KEY_FRAME)
3012 {
3013 vp8_calc_auto_iframe_target_size(cpi);
3014 }
3015 else
3016 {
3017 // INTER frame: compute target frame size
3018 cm->frame_type = INTER_FRAME;
3019 vp8_calc_pframe_target_size(cpi);
3020
3021 // Check if we're dropping the frame:
3022 if (cpi->drop_frame)
3023 {
3024 cpi->drop_frame = FALSE;
3025 cpi->drop_count++;
3026 return 0;
3027 }
3028 }
3029
3030 // Note target_size in bits * 256 per MB
3031 cpi->target_bits_per_mb = (cpi->this_frame_target * 256) / cpi->common.MBs;
3032
3033 return 1;
3034 }
set_quantizer(VP8_COMP * cpi,int Q)3035 static void set_quantizer(VP8_COMP *cpi, int Q)
3036 {
3037 VP8_COMMON *cm = &cpi->common;
3038 MACROBLOCKD *mbd = &cpi->mb.e_mbd;
3039
3040 cm->base_qindex = Q;
3041
3042 cm->y1dc_delta_q = 0;
3043 cm->y2dc_delta_q = 0;
3044 cm->y2ac_delta_q = 0;
3045 cm->uvdc_delta_q = 0;
3046 cm->uvac_delta_q = 0;
3047
3048 // Set Segment specific quatizers
3049 mbd->segment_feature_data[MB_LVL_ALT_Q][0] = cpi->segment_feature_data[MB_LVL_ALT_Q][0];
3050 mbd->segment_feature_data[MB_LVL_ALT_Q][1] = cpi->segment_feature_data[MB_LVL_ALT_Q][1];
3051 mbd->segment_feature_data[MB_LVL_ALT_Q][2] = cpi->segment_feature_data[MB_LVL_ALT_Q][2];
3052 mbd->segment_feature_data[MB_LVL_ALT_Q][3] = cpi->segment_feature_data[MB_LVL_ALT_Q][3];
3053 }
3054
update_alt_ref_frame_and_stats(VP8_COMP * cpi)3055 static void update_alt_ref_frame_and_stats(VP8_COMP *cpi)
3056 {
3057 VP8_COMMON *cm = &cpi->common;
3058
3059 // Update the golden frame buffer
3060 vp8_yv12_copy_frame_ptr(cm->frame_to_show, &cm->yv12_fb[cm->alt_fb_idx]);
3061
3062 // Select an interval before next GF or altref
3063 if (!cpi->auto_gold)
3064 cpi->frames_till_gf_update_due = cpi->goldfreq;
3065
3066 if ((cpi->pass != 2) && cpi->frames_till_gf_update_due)
3067 {
3068 cpi->current_gf_interval = cpi->frames_till_gf_update_due;
3069
3070 // Set the bits per frame that we should try and recover in subsequent inter frames
3071 // to account for the extra GF spend... note that his does not apply for GF updates
3072 // that occur coincident with a key frame as the extra cost of key frames is dealt
3073 // with elsewhere.
3074
3075 cpi->gf_overspend_bits += cpi->projected_frame_size;
3076 cpi->non_gf_bitrate_adjustment = cpi->gf_overspend_bits / cpi->frames_till_gf_update_due;
3077 }
3078
3079 // Update data structure that monitors level of reference to last GF
3080 vpx_memset(cpi->gf_active_flags, 1, (cm->mb_rows * cm->mb_cols));
3081 cpi->gf_active_count = cm->mb_rows * cm->mb_cols;
3082 // this frame refreshes means next frames don't unless specified by user
3083
3084 cpi->common.frames_since_golden = 0;
3085
3086 // Clear the alternate reference update pending flag.
3087 cpi->source_alt_ref_pending = FALSE;
3088
3089 // Set the alternate refernce frame active flag
3090 cpi->source_alt_ref_active = TRUE;
3091
3092
3093 }
update_golden_frame_and_stats(VP8_COMP * cpi)3094 static void update_golden_frame_and_stats(VP8_COMP *cpi)
3095 {
3096 VP8_COMMON *cm = &cpi->common;
3097
3098 // Update the Golden frame reconstruction buffer if signalled and the GF usage counts.
3099 if (cm->refresh_golden_frame)
3100 {
3101 // Update the golden frame buffer
3102 vp8_yv12_copy_frame_ptr(cm->frame_to_show, &cm->yv12_fb[cm->gld_fb_idx]);
3103
3104 // Select an interval before next GF
3105 if (!cpi->auto_gold)
3106 cpi->frames_till_gf_update_due = cpi->goldfreq;
3107
3108 if ((cpi->pass != 2) && (cpi->frames_till_gf_update_due > 0))
3109 {
3110 cpi->current_gf_interval = cpi->frames_till_gf_update_due;
3111
3112 // Set the bits per frame that we should try and recover in subsequent inter frames
3113 // to account for the extra GF spend... note that his does not apply for GF updates
3114 // that occur coincident with a key frame as the extra cost of key frames is dealt
3115 // with elsewhere.
3116 if ((cm->frame_type != KEY_FRAME) && !cpi->source_alt_ref_active)
3117 {
3118 // Calcluate GF bits to be recovered
3119 // Projected size - av frame bits available for inter frames for clip as a whole
3120 cpi->gf_overspend_bits += (cpi->projected_frame_size - cpi->inter_frame_target);
3121 }
3122
3123 cpi->non_gf_bitrate_adjustment = cpi->gf_overspend_bits / cpi->frames_till_gf_update_due;
3124
3125 }
3126
3127 // Update data structure that monitors level of reference to last GF
3128 vpx_memset(cpi->gf_active_flags, 1, (cm->mb_rows * cm->mb_cols));
3129 cpi->gf_active_count = cm->mb_rows * cm->mb_cols;
3130
3131 // this frame refreshes means next frames don't unless specified by user
3132 cm->refresh_golden_frame = 0;
3133 cpi->common.frames_since_golden = 0;
3134
3135 //if ( cm->frame_type == KEY_FRAME )
3136 //{
3137 cpi->recent_ref_frame_usage[INTRA_FRAME] = 1;
3138 cpi->recent_ref_frame_usage[LAST_FRAME] = 1;
3139 cpi->recent_ref_frame_usage[GOLDEN_FRAME] = 1;
3140 cpi->recent_ref_frame_usage[ALTREF_FRAME] = 1;
3141 //}
3142 //else
3143 //{
3144 // // Carry a potrtion of count over to begining of next gf sequence
3145 // cpi->recent_ref_frame_usage[INTRA_FRAME] >>= 5;
3146 // cpi->recent_ref_frame_usage[LAST_FRAME] >>= 5;
3147 // cpi->recent_ref_frame_usage[GOLDEN_FRAME] >>= 5;
3148 // cpi->recent_ref_frame_usage[ALTREF_FRAME] >>= 5;
3149 //}
3150
3151 // ******** Fixed Q test code only ************
3152 // If we are going to use the ALT reference for the next group of frames set a flag to say so.
3153 if (cpi->oxcf.fixed_q >= 0 &&
3154 cpi->oxcf.play_alternate && !cpi->common.refresh_alt_ref_frame)
3155 {
3156 cpi->source_alt_ref_pending = TRUE;
3157 cpi->frames_till_gf_update_due = cpi->baseline_gf_interval;
3158 }
3159
3160 if (!cpi->source_alt_ref_pending)
3161 cpi->source_alt_ref_active = FALSE;
3162
3163 // Decrement count down till next gf
3164 if (cpi->frames_till_gf_update_due > 0)
3165 cpi->frames_till_gf_update_due--;
3166
3167 }
3168 else if (!cpi->common.refresh_alt_ref_frame)
3169 {
3170 // Decrement count down till next gf
3171 if (cpi->frames_till_gf_update_due > 0)
3172 cpi->frames_till_gf_update_due--;
3173
3174 if (cpi->common.frames_till_alt_ref_frame)
3175 cpi->common.frames_till_alt_ref_frame --;
3176
3177 cpi->common.frames_since_golden ++;
3178
3179 if (cpi->common.frames_since_golden > 1)
3180 {
3181 cpi->recent_ref_frame_usage[INTRA_FRAME] += cpi->count_mb_ref_frame_usage[INTRA_FRAME];
3182 cpi->recent_ref_frame_usage[LAST_FRAME] += cpi->count_mb_ref_frame_usage[LAST_FRAME];
3183 cpi->recent_ref_frame_usage[GOLDEN_FRAME] += cpi->count_mb_ref_frame_usage[GOLDEN_FRAME];
3184 cpi->recent_ref_frame_usage[ALTREF_FRAME] += cpi->count_mb_ref_frame_usage[ALTREF_FRAME];
3185 }
3186 }
3187 }
3188
3189 // This function updates the reference frame probability estimates that
3190 // will be used during mode selection
update_rd_ref_frame_probs(VP8_COMP * cpi)3191 static void update_rd_ref_frame_probs(VP8_COMP *cpi)
3192 {
3193 VP8_COMMON *cm = &cpi->common;
3194
3195 #if 0
3196 const int *const rfct = cpi->recent_ref_frame_usage;
3197 const int rf_intra = rfct[INTRA_FRAME];
3198 const int rf_inter = rfct[LAST_FRAME] + rfct[GOLDEN_FRAME] + rfct[ALTREF_FRAME];
3199
3200 if (cm->frame_type == KEY_FRAME)
3201 {
3202 cpi->prob_intra_coded = 255;
3203 cpi->prob_last_coded = 128;
3204 cpi->prob_gf_coded = 128;
3205 }
3206 else if (!(rf_intra + rf_inter))
3207 {
3208 // This is a trap in case this function is called with cpi->recent_ref_frame_usage[] blank.
3209 cpi->prob_intra_coded = 63;
3210 cpi->prob_last_coded = 128;
3211 cpi->prob_gf_coded = 128;
3212 }
3213 else
3214 {
3215 cpi->prob_intra_coded = (rf_intra * 255) / (rf_intra + rf_inter);
3216
3217 if (cpi->prob_intra_coded < 1)
3218 cpi->prob_intra_coded = 1;
3219
3220 if ((cm->frames_since_golden > 0) || cpi->source_alt_ref_active)
3221 {
3222 cpi->prob_last_coded = rf_inter ? (rfct[LAST_FRAME] * 255) / rf_inter : 128;
3223
3224 if (cpi->prob_last_coded < 1)
3225 cpi->prob_last_coded = 1;
3226
3227 cpi->prob_gf_coded = (rfct[GOLDEN_FRAME] + rfct[ALTREF_FRAME])
3228 ? (rfct[GOLDEN_FRAME] * 255) / (rfct[GOLDEN_FRAME] + rfct[ALTREF_FRAME]) : 128;
3229
3230 if (cpi->prob_gf_coded < 1)
3231 cpi->prob_gf_coded = 1;
3232 }
3233 }
3234
3235 #else
3236 const int *const rfct = cpi->count_mb_ref_frame_usage;
3237 const int rf_intra = rfct[INTRA_FRAME];
3238 const int rf_inter = rfct[LAST_FRAME] + rfct[GOLDEN_FRAME] + rfct[ALTREF_FRAME];
3239
3240 if (cm->frame_type == KEY_FRAME)
3241 {
3242 cpi->prob_intra_coded = 255;
3243 cpi->prob_last_coded = 128;
3244 cpi->prob_gf_coded = 128;
3245 }
3246 else if (!(rf_intra + rf_inter))
3247 {
3248 // This is a trap in case this function is called with cpi->recent_ref_frame_usage[] blank.
3249 cpi->prob_intra_coded = 63;
3250 cpi->prob_last_coded = 128;
3251 cpi->prob_gf_coded = 128;
3252 }
3253 else
3254 {
3255 cpi->prob_intra_coded = (rf_intra * 255) / (rf_intra + rf_inter);
3256
3257 if (cpi->prob_intra_coded < 1)
3258 cpi->prob_intra_coded = 1;
3259
3260 cpi->prob_last_coded = rf_inter ? (rfct[LAST_FRAME] * 255) / rf_inter : 128;
3261
3262 if (cpi->prob_last_coded < 1)
3263 cpi->prob_last_coded = 1;
3264
3265 cpi->prob_gf_coded = (rfct[GOLDEN_FRAME] + rfct[ALTREF_FRAME])
3266 ? (rfct[GOLDEN_FRAME] * 255) / (rfct[GOLDEN_FRAME] + rfct[ALTREF_FRAME]) : 128;
3267
3268 if (cpi->prob_gf_coded < 1)
3269 cpi->prob_gf_coded = 1;
3270 }
3271
3272 // update reference frame costs since we can do better than what we got last frame.
3273
3274 if (cpi->common.refresh_alt_ref_frame)
3275 {
3276 cpi->prob_intra_coded += 40;
3277 cpi->prob_last_coded = 200;
3278 cpi->prob_gf_coded = 1;
3279 }
3280 else if (cpi->common.frames_since_golden == 0)
3281 {
3282 cpi->prob_last_coded = 214;
3283 cpi->prob_gf_coded = 1;
3284 }
3285 else if (cpi->common.frames_since_golden == 1)
3286 {
3287 cpi->prob_last_coded = 192;
3288 cpi->prob_gf_coded = 220;
3289 }
3290 else if (cpi->source_alt_ref_active)
3291 {
3292 //int dist = cpi->common.frames_till_alt_ref_frame + cpi->common.frames_since_golden;
3293 cpi->prob_gf_coded -= 20;
3294
3295 if (cpi->prob_gf_coded < 10)
3296 cpi->prob_gf_coded = 10;
3297 }
3298
3299 #endif
3300 }
3301
3302
3303 // 1 = key, 0 = inter
decide_key_frame(VP8_COMP * cpi)3304 static int decide_key_frame(VP8_COMP *cpi)
3305 {
3306 VP8_COMMON *cm = &cpi->common;
3307
3308 int code_key_frame = FALSE;
3309
3310 cpi->kf_boost = 0;
3311
3312 if (cpi->Speed > 11)
3313 return FALSE;
3314
3315 // Clear down mmx registers
3316 vp8_clear_system_state(); //__asm emms;
3317
3318 if ((cpi->compressor_speed == 2) && (cpi->Speed >= 5) && (cpi->sf.RD == 0))
3319 {
3320 double change = 1.0 * abs((int)(cpi->intra_error - cpi->last_intra_error)) / (1 + cpi->last_intra_error);
3321 double change2 = 1.0 * abs((int)(cpi->prediction_error - cpi->last_prediction_error)) / (1 + cpi->last_prediction_error);
3322 double minerror = cm->MBs * 256;
3323
3324 #if 0
3325
3326 if (10 * cpi->intra_error / (1 + cpi->prediction_error) < 15
3327 && cpi->prediction_error > minerror
3328 && (change > .25 || change2 > .25))
3329 {
3330 FILE *f = fopen("intra_inter.stt", "a");
3331
3332 if (cpi->prediction_error <= 0)
3333 cpi->prediction_error = 1;
3334
3335 fprintf(f, "%d %d %d %d %14.4f\n",
3336 cm->current_video_frame,
3337 (int) cpi->prediction_error,
3338 (int) cpi->intra_error,
3339 (int)((10 * cpi->intra_error) / cpi->prediction_error),
3340 change);
3341
3342 fclose(f);
3343 }
3344
3345 #endif
3346
3347 cpi->last_intra_error = cpi->intra_error;
3348 cpi->last_prediction_error = cpi->prediction_error;
3349
3350 if (10 * cpi->intra_error / (1 + cpi->prediction_error) < 15
3351 && cpi->prediction_error > minerror
3352 && (change > .25 || change2 > .25))
3353 {
3354 /*(change > 1.4 || change < .75)&& cpi->this_frame_percent_intra > cpi->last_frame_percent_intra + 3*/
3355 return TRUE;
3356 }
3357
3358 return FALSE;
3359
3360 }
3361
3362 // If the following are true we might as well code a key frame
3363 if (((cpi->this_frame_percent_intra == 100) &&
3364 (cpi->this_frame_percent_intra > (cpi->last_frame_percent_intra + 2))) ||
3365 ((cpi->this_frame_percent_intra > 95) &&
3366 (cpi->this_frame_percent_intra >= (cpi->last_frame_percent_intra + 5))))
3367 {
3368 code_key_frame = TRUE;
3369 }
3370 // in addition if the following are true and this is not a golden frame then code a key frame
3371 // Note that on golden frames there often seems to be a pop in intra useage anyway hence this
3372 // restriction is designed to prevent spurious key frames. The Intra pop needs to be investigated.
3373 else if (((cpi->this_frame_percent_intra > 60) &&
3374 (cpi->this_frame_percent_intra > (cpi->last_frame_percent_intra * 2))) ||
3375 ((cpi->this_frame_percent_intra > 75) &&
3376 (cpi->this_frame_percent_intra > (cpi->last_frame_percent_intra * 3 / 2))) ||
3377 ((cpi->this_frame_percent_intra > 90) &&
3378 (cpi->this_frame_percent_intra > (cpi->last_frame_percent_intra + 10))))
3379 {
3380 if (!cm->refresh_golden_frame)
3381 code_key_frame = TRUE;
3382 }
3383
3384 return code_key_frame;
3385
3386 }
3387
3388 #if !(CONFIG_REALTIME_ONLY)
Pass1Encode(VP8_COMP * cpi,unsigned long * size,unsigned char * dest,unsigned int * frame_flags)3389 static void Pass1Encode(VP8_COMP *cpi, unsigned long *size, unsigned char *dest, unsigned int *frame_flags)
3390 {
3391 (void) size;
3392 (void) dest;
3393 (void) frame_flags;
3394 set_quantizer(cpi, 26);
3395
3396 scale_and_extend_source(cpi->un_scaled_source, cpi);
3397 vp8_first_pass(cpi);
3398 }
3399 #endif
3400
3401 #if 0
3402 void write_cx_frame_to_file(YV12_BUFFER_CONFIG *frame, int this_frame)
3403 {
3404
3405 // write the frame
3406 FILE *yframe;
3407 int i;
3408 char filename[255];
3409
3410 sprintf(filename, "cx\\y%04d.raw", this_frame);
3411 yframe = fopen(filename, "wb");
3412
3413 for (i = 0; i < frame->y_height; i++)
3414 fwrite(frame->y_buffer + i * frame->y_stride, frame->y_width, 1, yframe);
3415
3416 fclose(yframe);
3417 sprintf(filename, "cx\\u%04d.raw", this_frame);
3418 yframe = fopen(filename, "wb");
3419
3420 for (i = 0; i < frame->uv_height; i++)
3421 fwrite(frame->u_buffer + i * frame->uv_stride, frame->uv_width, 1, yframe);
3422
3423 fclose(yframe);
3424 sprintf(filename, "cx\\v%04d.raw", this_frame);
3425 yframe = fopen(filename, "wb");
3426
3427 for (i = 0; i < frame->uv_height; i++)
3428 fwrite(frame->v_buffer + i * frame->uv_stride, frame->uv_width, 1, yframe);
3429
3430 fclose(yframe);
3431 }
3432 #endif
3433 // return of 0 means drop frame
3434
encode_frame_to_data_rate(VP8_COMP * cpi,unsigned long * size,unsigned char * dest,unsigned int * frame_flags)3435 static void encode_frame_to_data_rate
3436 (
3437 VP8_COMP *cpi,
3438 unsigned long *size,
3439 unsigned char *dest,
3440 unsigned int *frame_flags
3441 )
3442 {
3443 int Q;
3444 int frame_over_shoot_limit;
3445 int frame_under_shoot_limit;
3446
3447 int Loop = FALSE;
3448 int loop_count;
3449 int this_q;
3450 int last_zbin_oq;
3451
3452 int q_low;
3453 int q_high;
3454 int zbin_oq_high;
3455 int zbin_oq_low = 0;
3456 int top_index;
3457 int bottom_index;
3458 VP8_COMMON *cm = &cpi->common;
3459 int active_worst_qchanged = FALSE;
3460
3461 int overshoot_seen = FALSE;
3462 int undershoot_seen = FALSE;
3463 int drop_mark = cpi->oxcf.drop_frames_water_mark * cpi->oxcf.optimal_buffer_level / 100;
3464 int drop_mark75 = drop_mark * 2 / 3;
3465 int drop_mark50 = drop_mark / 4;
3466 int drop_mark25 = drop_mark / 8;
3467
3468 // Clear down mmx registers to allow floating point in what follows
3469 vp8_clear_system_state();
3470
3471 // Test code for segmentation of gf/arf (0,0)
3472 //segmentation_test_function((VP8_PTR) cpi);
3473
3474 // For an alt ref frame in 2 pass we skip the call to the second pass function that sets the target bandwidth
3475 #if !(CONFIG_REALTIME_ONLY)
3476
3477 if (cpi->pass == 2)
3478 {
3479 if (cpi->common.refresh_alt_ref_frame)
3480 {
3481 cpi->per_frame_bandwidth = cpi->gf_bits; // Per frame bit target for the alt ref frame
3482 cpi->target_bandwidth = cpi->gf_bits * cpi->output_frame_rate; // per second target bitrate
3483 }
3484 }
3485 else
3486 #endif
3487 cpi->per_frame_bandwidth = (int)(cpi->target_bandwidth / cpi->output_frame_rate);
3488
3489 // Default turn off buffer to buffer copying
3490 cm->copy_buffer_to_gf = 0;
3491 cm->copy_buffer_to_arf = 0;
3492
3493 // Clear zbin over-quant value and mode boost values.
3494 cpi->zbin_over_quant = 0;
3495 cpi->zbin_mode_boost = 0;
3496
3497 // Enable mode based tweaking of the zbin
3498 cpi->zbin_mode_boost_enabled = TRUE;
3499
3500 // Current default encoder behaviour for the altref sign bias
3501 if (cpi->source_alt_ref_active)
3502 cpi->common.ref_frame_sign_bias[ALTREF_FRAME] = 1;
3503 else
3504 cpi->common.ref_frame_sign_bias[ALTREF_FRAME] = 0;
3505
3506 // Check to see if a key frame is signalled
3507 // For two pass with auto key frame enabled cm->frame_type may already be set, but not for one pass.
3508 if ((cm->current_video_frame == 0) ||
3509 (cm->frame_flags & FRAMEFLAGS_KEY) ||
3510 (cpi->oxcf.auto_key && (cpi->frames_since_key % cpi->key_frame_frequency == 0)))
3511 {
3512 // Key frame from VFW/auto-keyframe/first frame
3513 cm->frame_type = KEY_FRAME;
3514 }
3515
3516 // Set default state for segment and mode based loop filter update flags
3517 cpi->mb.e_mbd.update_mb_segmentation_map = 0;
3518 cpi->mb.e_mbd.update_mb_segmentation_data = 0;
3519 cpi->mb.e_mbd.mode_ref_lf_delta_update = 0;
3520
3521 // Set various flags etc to special state if it is a key frame
3522 if (cm->frame_type == KEY_FRAME)
3523 {
3524 int i;
3525
3526 // Reset the loop filter deltas and segmentation map
3527 setup_features(cpi);
3528
3529 // If segmentation is enabled force a map update for key frames
3530 if (cpi->mb.e_mbd.segmentation_enabled)
3531 {
3532 cpi->mb.e_mbd.update_mb_segmentation_map = 1;
3533 cpi->mb.e_mbd.update_mb_segmentation_data = 1;
3534 }
3535
3536 // The alternate reference frame cannot be active for a key frame
3537 cpi->source_alt_ref_active = FALSE;
3538
3539 // Reset the RD threshold multipliers to default of * 1 (128)
3540 for (i = 0; i < MAX_MODES; i++)
3541 {
3542 cpi->rd_thresh_mult[i] = 128;
3543 }
3544 }
3545
3546 // Test code for segmentation
3547 //if ( (cm->frame_type == KEY_FRAME) || ((cm->current_video_frame % 2) == 0))
3548 //if ( (cm->current_video_frame % 2) == 0 )
3549 // enable_segmentation((VP8_PTR)cpi);
3550 //else
3551 // disable_segmentation((VP8_PTR)cpi);
3552
3553 #if 0
3554 // Experimental code for lagged compress and one pass
3555 // Initialise one_pass GF frames stats
3556 // Update stats used for GF selection
3557 //if ( cpi->pass == 0 )
3558 {
3559 cpi->one_pass_frame_index = cm->current_video_frame % MAX_LAG_BUFFERS;
3560
3561 cpi->one_pass_frame_stats[cpi->one_pass_frame_index ].frames_so_far = 0;
3562 cpi->one_pass_frame_stats[cpi->one_pass_frame_index ].frame_intra_error = 0.0;
3563 cpi->one_pass_frame_stats[cpi->one_pass_frame_index ].frame_coded_error = 0.0;
3564 cpi->one_pass_frame_stats[cpi->one_pass_frame_index ].frame_pcnt_inter = 0.0;
3565 cpi->one_pass_frame_stats[cpi->one_pass_frame_index ].frame_pcnt_motion = 0.0;
3566 cpi->one_pass_frame_stats[cpi->one_pass_frame_index ].frame_mvr = 0.0;
3567 cpi->one_pass_frame_stats[cpi->one_pass_frame_index ].frame_mvr_abs = 0.0;
3568 cpi->one_pass_frame_stats[cpi->one_pass_frame_index ].frame_mvc = 0.0;
3569 cpi->one_pass_frame_stats[cpi->one_pass_frame_index ].frame_mvc_abs = 0.0;
3570 }
3571 #endif
3572
3573 update_rd_ref_frame_probs(cpi);
3574
3575 if (cpi->drop_frames_allowed)
3576 {
3577 // The reset to decimation 0 is only done here for one pass.
3578 // Once it is set two pass leaves decimation on till the next kf.
3579 if ((cpi->buffer_level > drop_mark) && (cpi->decimation_factor > 0))
3580 cpi->decimation_factor --;
3581
3582 if (cpi->buffer_level > drop_mark75 && cpi->decimation_factor > 0)
3583 cpi->decimation_factor = 1;
3584
3585 else if (cpi->buffer_level < drop_mark25 && (cpi->decimation_factor == 2 || cpi->decimation_factor == 3))
3586 {
3587 cpi->decimation_factor = 3;
3588 }
3589 else if (cpi->buffer_level < drop_mark50 && (cpi->decimation_factor == 1 || cpi->decimation_factor == 2))
3590 {
3591 cpi->decimation_factor = 2;
3592 }
3593 else if (cpi->buffer_level < drop_mark75 && (cpi->decimation_factor == 0 || cpi->decimation_factor == 1))
3594 {
3595 cpi->decimation_factor = 1;
3596 }
3597
3598 //vpx_log("Encoder: Decimation Factor: %d \n",cpi->decimation_factor);
3599 }
3600
3601 // The following decimates the frame rate according to a regular pattern (i.e. to 1/2 or 2/3 frame rate)
3602 // This can be used to help prevent buffer under-run in CBR mode. Alternatively it might be desirable in
3603 // some situations to drop frame rate but throw more bits at each frame.
3604 //
3605 // Note that dropping a key frame can be problematic if spatial resampling is also active
3606 if (cpi->decimation_factor > 0)
3607 {
3608 switch (cpi->decimation_factor)
3609 {
3610 case 1:
3611 cpi->per_frame_bandwidth = cpi->per_frame_bandwidth * 3 / 2;
3612 break;
3613 case 2:
3614 cpi->per_frame_bandwidth = cpi->per_frame_bandwidth * 5 / 4;
3615 break;
3616 case 3:
3617 cpi->per_frame_bandwidth = cpi->per_frame_bandwidth * 5 / 4;
3618 break;
3619 }
3620
3621 // Note that we should not throw out a key frame (especially when spatial resampling is enabled).
3622 if ((cm->frame_type == KEY_FRAME)) // && cpi->oxcf.allow_spatial_resampling )
3623 {
3624 cpi->decimation_count = cpi->decimation_factor;
3625 }
3626 else if (cpi->decimation_count > 0)
3627 {
3628 cpi->decimation_count --;
3629 cpi->bits_off_target += cpi->av_per_frame_bandwidth;
3630 cm->current_video_frame++;
3631 cpi->frames_since_key++;
3632
3633 #if CONFIG_PSNR
3634 cpi->count ++;
3635 #endif
3636
3637 cpi->buffer_level = cpi->bits_off_target;
3638
3639 return;
3640 }
3641 else
3642 cpi->decimation_count = cpi->decimation_factor;
3643 }
3644
3645 // Decide how big to make the frame
3646 if (!pick_frame_size(cpi))
3647 {
3648 cm->current_video_frame++;
3649 cpi->frames_since_key++;
3650 return;
3651 }
3652
3653 // Reduce active_worst_allowed_q for CBR if our buffer is getting too full.
3654 // This has a knock on effect on active best quality as well.
3655 // For CBR if the buffer reaches its maximum level then we can no longer
3656 // save up bits for later frames so we might as well use them up
3657 // on the current frame.
3658 if ((cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER) &&
3659 (cpi->buffer_level >= cpi->oxcf.optimal_buffer_level) && cpi->buffered_mode)
3660 {
3661 int Adjustment = cpi->active_worst_quality / 4; // Max adjustment is 1/4
3662
3663 if (Adjustment)
3664 {
3665 int buff_lvl_step;
3666 int tmp_lvl = cpi->buffer_level;
3667
3668 if (cpi->buffer_level < cpi->oxcf.maximum_buffer_size)
3669 {
3670 buff_lvl_step = (cpi->oxcf.maximum_buffer_size - cpi->oxcf.optimal_buffer_level) / Adjustment;
3671
3672 if (buff_lvl_step)
3673 {
3674 Adjustment = (cpi->buffer_level - cpi->oxcf.optimal_buffer_level) / buff_lvl_step;
3675 cpi->active_worst_quality -= Adjustment;
3676 }
3677 }
3678 else
3679 {
3680 cpi->active_worst_quality -= Adjustment;
3681 }
3682 }
3683 }
3684
3685 // Set an active best quality and if necessary active worst quality
3686 if (cpi->pass == 2 || (cm->current_video_frame > 150))
3687 {
3688 int Q;
3689 int i;
3690 int bpm_target;
3691 //int tmp;
3692
3693 vp8_clear_system_state();
3694
3695 Q = cpi->active_worst_quality;
3696
3697 if ((cm->frame_type == KEY_FRAME) || cm->refresh_golden_frame || cpi->common.refresh_alt_ref_frame)
3698 {
3699 if (cm->frame_type != KEY_FRAME)
3700 {
3701 if (cpi->avg_frame_qindex < cpi->active_worst_quality)
3702 Q = cpi->avg_frame_qindex;
3703
3704 if ( cpi->gfu_boost > 1000 )
3705 cpi->active_best_quality = gf_low_motion_minq[Q];
3706 else if ( cpi->gfu_boost < 400 )
3707 cpi->active_best_quality = gf_high_motion_minq[Q];
3708 else
3709 cpi->active_best_quality = gf_mid_motion_minq[Q];
3710
3711 /*cpi->active_best_quality = gf_arf_minq[Q];
3712 tmp = (cpi->gfu_boost > 1000) ? 600 : cpi->gfu_boost - 400;
3713 //tmp = (cpi->gfu_boost > 1000) ? 600 :
3714 //(cpi->gfu_boost < 400) ? 0 : cpi->gfu_boost - 400;
3715 tmp = 128 - (tmp >> 4);
3716 cpi->active_best_quality = (cpi->active_best_quality * tmp)>>7;*/
3717
3718 }
3719 // KEY FRAMES
3720 else
3721 {
3722 if (cpi->gfu_boost > 600)
3723 cpi->active_best_quality = kf_low_motion_minq[Q];
3724 else
3725 cpi->active_best_quality = kf_high_motion_minq[Q];
3726 }
3727 }
3728 else
3729 {
3730 cpi->active_best_quality = inter_minq[Q];
3731 }
3732
3733 // If CBR and the buffer is as full then it is reasonable to allow higher quality on the frames
3734 // to prevent bits just going to waste.
3735 if (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER)
3736 {
3737 // Note that the use of >= here elliminates the risk of a devide by 0 error in the else if clause
3738 if (cpi->buffer_level >= cpi->oxcf.maximum_buffer_size)
3739 cpi->active_best_quality = cpi->best_quality;
3740
3741 else if (cpi->buffer_level > cpi->oxcf.optimal_buffer_level)
3742 {
3743 int Fraction = ((cpi->buffer_level - cpi->oxcf.optimal_buffer_level) * 128) / (cpi->oxcf.maximum_buffer_size - cpi->oxcf.optimal_buffer_level);
3744 int min_qadjustment = ((cpi->active_best_quality - cpi->best_quality) * Fraction) / 128;
3745
3746 cpi->active_best_quality -= min_qadjustment;
3747 }
3748
3749 }
3750 }
3751
3752 // Clip the active best and worst quality values to limits
3753 if (cpi->active_worst_quality > cpi->worst_quality)
3754 cpi->active_worst_quality = cpi->worst_quality;
3755
3756 if (cpi->active_best_quality < cpi->best_quality)
3757 cpi->active_best_quality = cpi->best_quality;
3758 else if (cpi->active_best_quality > cpi->active_worst_quality)
3759 cpi->active_best_quality = cpi->active_worst_quality;
3760
3761 // Determine initial Q to try
3762 Q = vp8_regulate_q(cpi, cpi->this_frame_target);
3763 last_zbin_oq = cpi->zbin_over_quant;
3764
3765 // Set highest allowed value for Zbin over quant
3766 if (cm->frame_type == KEY_FRAME)
3767 zbin_oq_high = 0; //ZBIN_OQ_MAX/16
3768 else if (cm->refresh_alt_ref_frame || (cm->refresh_golden_frame && !cpi->source_alt_ref_active))
3769 zbin_oq_high = 16;
3770 else
3771 zbin_oq_high = ZBIN_OQ_MAX;
3772
3773 // Setup background Q adjustment for error resilliant mode
3774 if (cpi->cyclic_refresh_mode_enabled)
3775 cyclic_background_refresh(cpi, Q, 0);
3776
3777 vp8_compute_frame_size_bounds(cpi, &frame_under_shoot_limit, &frame_over_shoot_limit);
3778
3779 // Limit Q range for the adaptive loop (Values not clipped to range 20-60 as in VP8).
3780 bottom_index = cpi->active_best_quality;
3781 top_index = cpi->active_worst_quality;
3782
3783 vp8_save_coding_context(cpi);
3784
3785 loop_count = 0;
3786
3787 q_low = cpi->best_quality;
3788 q_high = cpi->worst_quality;
3789
3790
3791 scale_and_extend_source(cpi->un_scaled_source, cpi);
3792 #if !(CONFIG_REALTIME_ONLY) && CONFIG_POSTPROC
3793
3794 if (cpi->oxcf.noise_sensitivity > 0)
3795 {
3796 unsigned char *src;
3797 int l = 0;
3798
3799 switch (cpi->oxcf.noise_sensitivity)
3800 {
3801 case 1:
3802 l = 20;
3803 break;
3804 case 2:
3805 l = 40;
3806 break;
3807 case 3:
3808 l = 60;
3809 break;
3810 case 4:
3811 l = 80;
3812 break;
3813 case 5:
3814 l = 100;
3815 break;
3816 case 6:
3817 l = 150;
3818 break;
3819 }
3820
3821
3822 if (cm->frame_type == KEY_FRAME)
3823 {
3824 vp8_de_noise(cpi->Source, cpi->Source, l , 1, 0, RTCD(postproc));
3825 cpi->ppi.frame = 0;
3826 }
3827 else
3828 {
3829 vp8_de_noise(cpi->Source, cpi->Source, l , 1, 0, RTCD(postproc));
3830
3831 src = cpi->Source->y_buffer;
3832
3833 if (cpi->Source->y_stride < 0)
3834 {
3835 src += cpi->Source->y_stride * (cpi->Source->y_height - 1);
3836 }
3837
3838 //temp_filter(&cpi->ppi,src,src,
3839 // cm->last_frame.y_width * cm->last_frame.y_height,
3840 // cpi->oxcf.noise_sensitivity);
3841 }
3842 }
3843
3844 #endif
3845
3846 #ifdef OUTPUT_YUV_SRC
3847 vp8_write_yuv_frame(cpi->Source);
3848 #endif
3849
3850 do
3851 {
3852 vp8_clear_system_state(); //__asm emms;
3853
3854 /*
3855 if(cpi->is_src_frame_alt_ref)
3856 Q = 127;
3857 */
3858
3859 set_quantizer(cpi, Q);
3860 this_q = Q;
3861
3862 // setup skip prob for costing in mode/mv decision
3863 if (cpi->common.mb_no_coeff_skip)
3864 {
3865 cpi->prob_skip_false = cpi->base_skip_false_prob[Q];
3866
3867 if (cm->frame_type != KEY_FRAME)
3868 {
3869 if (cpi->common.refresh_alt_ref_frame)
3870 {
3871 if (cpi->last_skip_false_probs[2] != 0)
3872 cpi->prob_skip_false = cpi->last_skip_false_probs[2];
3873
3874 /*
3875 if(cpi->last_skip_false_probs[2]!=0 && abs(Q- cpi->last_skip_probs_q[2])<=16 )
3876 cpi->prob_skip_false = cpi->last_skip_false_probs[2];
3877 else if (cpi->last_skip_false_probs[2]!=0)
3878 cpi->prob_skip_false = (cpi->last_skip_false_probs[2] + cpi->prob_skip_false ) / 2;
3879 */
3880 }
3881 else if (cpi->common.refresh_golden_frame)
3882 {
3883 if (cpi->last_skip_false_probs[1] != 0)
3884 cpi->prob_skip_false = cpi->last_skip_false_probs[1];
3885
3886 /*
3887 if(cpi->last_skip_false_probs[1]!=0 && abs(Q- cpi->last_skip_probs_q[1])<=16 )
3888 cpi->prob_skip_false = cpi->last_skip_false_probs[1];
3889 else if (cpi->last_skip_false_probs[1]!=0)
3890 cpi->prob_skip_false = (cpi->last_skip_false_probs[1] + cpi->prob_skip_false ) / 2;
3891 */
3892 }
3893 else
3894 {
3895 if (cpi->last_skip_false_probs[0] != 0)
3896 cpi->prob_skip_false = cpi->last_skip_false_probs[0];
3897
3898 /*
3899 if(cpi->last_skip_false_probs[0]!=0 && abs(Q- cpi->last_skip_probs_q[0])<=16 )
3900 cpi->prob_skip_false = cpi->last_skip_false_probs[0];
3901 else if(cpi->last_skip_false_probs[0]!=0)
3902 cpi->prob_skip_false = (cpi->last_skip_false_probs[0] + cpi->prob_skip_false ) / 2;
3903 */
3904 }
3905
3906 //as this is for cost estimate, let's make sure it does not go extreme eitehr way
3907 if (cpi->prob_skip_false < 5)
3908 cpi->prob_skip_false = 5;
3909
3910 if (cpi->prob_skip_false > 250)
3911 cpi->prob_skip_false = 250;
3912
3913 if (cpi->is_src_frame_alt_ref)
3914 cpi->prob_skip_false = 1;
3915
3916
3917 }
3918
3919 #if 0
3920
3921 if (cpi->pass != 1)
3922 {
3923 FILE *f = fopen("skip.stt", "a");
3924 fprintf(f, "%d, %d, %4d ", cpi->common.refresh_golden_frame, cpi->common.refresh_alt_ref_frame, cpi->prob_skip_false);
3925 fclose(f);
3926 }
3927
3928 #endif
3929
3930 }
3931
3932 if (cm->frame_type == KEY_FRAME)
3933 vp8_setup_key_frame(cpi);
3934
3935 // transform / motion compensation build reconstruction frame
3936
3937 vp8_encode_frame(cpi);
3938 cpi->projected_frame_size -= vp8_estimate_entropy_savings(cpi);
3939 cpi->projected_frame_size = (cpi->projected_frame_size > 0) ? cpi->projected_frame_size : 0;
3940
3941 vp8_clear_system_state(); //__asm emms;
3942
3943 // Test to see if the stats generated for this frame indicate that we should have coded a key frame
3944 // (assuming that we didn't)!
3945 if (cpi->pass != 2 && cpi->oxcf.auto_key && cm->frame_type != KEY_FRAME)
3946 {
3947 if (decide_key_frame(cpi))
3948 {
3949 vp8_calc_auto_iframe_target_size(cpi);
3950
3951 // Reset all our sizing numbers and recode
3952 cm->frame_type = KEY_FRAME;
3953
3954 // Clear the Alt reference frame active flag when we have a key frame
3955 cpi->source_alt_ref_active = FALSE;
3956
3957 // Reset the loop filter deltas and segmentation map
3958 setup_features(cpi);
3959
3960 // If segmentation is enabled force a map update for key frames
3961 if (cpi->mb.e_mbd.segmentation_enabled)
3962 {
3963 cpi->mb.e_mbd.update_mb_segmentation_map = 1;
3964 cpi->mb.e_mbd.update_mb_segmentation_data = 1;
3965 }
3966
3967 vp8_restore_coding_context(cpi);
3968
3969 Q = vp8_regulate_q(cpi, cpi->this_frame_target);
3970
3971 q_low = cpi->best_quality;
3972 q_high = cpi->worst_quality;
3973
3974 vp8_compute_frame_size_bounds(cpi, &frame_under_shoot_limit, &frame_over_shoot_limit);
3975
3976 // Limit Q range for the adaptive loop (Values not clipped to range 20-60 as in VP8).
3977 bottom_index = cpi->active_best_quality;
3978 top_index = cpi->active_worst_quality;
3979
3980
3981 loop_count++;
3982 Loop = TRUE;
3983
3984 resize_key_frame(cpi);
3985 continue;
3986 }
3987 }
3988
3989 vp8_clear_system_state();
3990
3991 if (frame_over_shoot_limit == 0)
3992 frame_over_shoot_limit = 1;
3993
3994 // Are we are overshooting and up against the limit of active max Q.
3995 if (((cpi->pass != 2) || (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER)) &&
3996 (Q == cpi->active_worst_quality) &&
3997 (cpi->active_worst_quality < cpi->worst_quality) &&
3998 (cpi->projected_frame_size > frame_over_shoot_limit))
3999 {
4000 int over_size_percent = ((cpi->projected_frame_size - frame_over_shoot_limit) * 100) / frame_over_shoot_limit;
4001
4002 // If so is there any scope for relaxing it
4003 while ((cpi->active_worst_quality < cpi->worst_quality) && (over_size_percent > 0))
4004 {
4005 cpi->active_worst_quality++;
4006 top_index = cpi->active_worst_quality;
4007 over_size_percent = (int)(over_size_percent * 0.96); // Assume 1 qstep = about 4% on frame size.
4008 }
4009
4010 // If we have updated the active max Q do not call vp8_update_rate_correction_factors() this loop.
4011 active_worst_qchanged = TRUE;
4012 }
4013 else
4014 active_worst_qchanged = FALSE;
4015
4016 #if !(CONFIG_REALTIME_ONLY)
4017
4018 // Is the projected frame size out of range and are we allowed to attempt to recode.
4019 if (((cpi->sf.recode_loop == 1) ||
4020 ((cpi->sf.recode_loop == 2) && (cm->refresh_golden_frame || (cm->frame_type == KEY_FRAME)))) &&
4021 (((cpi->projected_frame_size > frame_over_shoot_limit) && (Q < top_index)) ||
4022 //((cpi->projected_frame_size > frame_over_shoot_limit ) && (Q == top_index) && (cpi->zbin_over_quant < ZBIN_OQ_MAX)) ||
4023 ((cpi->projected_frame_size < frame_under_shoot_limit) && (Q > bottom_index)))
4024 )
4025 {
4026 int last_q = Q;
4027 int Retries = 0;
4028
4029 // Frame size out of permitted range:
4030 // Update correction factor & compute new Q to try...
4031 if (cpi->projected_frame_size > frame_over_shoot_limit)
4032 {
4033 //if ( cpi->zbin_over_quant == 0 )
4034 q_low = (Q < q_high) ? (Q + 1) : q_high; // Raise Qlow as to at least the current value
4035
4036 if (cpi->zbin_over_quant > 0) // If we are using over quant do the same for zbin_oq_low
4037 zbin_oq_low = (cpi->zbin_over_quant < zbin_oq_high) ? (cpi->zbin_over_quant + 1) : zbin_oq_high;
4038
4039 //if ( undershoot_seen || (Q == MAXQ) )
4040 if (undershoot_seen)
4041 {
4042 // Update rate_correction_factor unless cpi->active_worst_quality has changed.
4043 if (!active_worst_qchanged)
4044 vp8_update_rate_correction_factors(cpi, 1);
4045
4046 Q = (q_high + q_low + 1) / 2;
4047
4048 // Adjust cpi->zbin_over_quant (only allowed when Q is max)
4049 if (Q < MAXQ)
4050 cpi->zbin_over_quant = 0;
4051 else
4052 {
4053 zbin_oq_low = (cpi->zbin_over_quant < zbin_oq_high) ? (cpi->zbin_over_quant + 1) : zbin_oq_high;
4054 cpi->zbin_over_quant = (zbin_oq_high + zbin_oq_low) / 2;
4055 }
4056 }
4057 else
4058 {
4059 // Update rate_correction_factor unless cpi->active_worst_quality has changed.
4060 if (!active_worst_qchanged)
4061 vp8_update_rate_correction_factors(cpi, 0);
4062
4063 Q = vp8_regulate_q(cpi, cpi->this_frame_target);
4064
4065 while (((Q < q_low) || (cpi->zbin_over_quant < zbin_oq_low)) && (Retries < 10))
4066 {
4067 vp8_update_rate_correction_factors(cpi, 0);
4068 Q = vp8_regulate_q(cpi, cpi->this_frame_target);
4069 Retries ++;
4070 }
4071 }
4072
4073 overshoot_seen = TRUE;
4074 }
4075 else
4076 {
4077 if (cpi->zbin_over_quant == 0)
4078 q_high = (Q > q_low) ? (Q - 1) : q_low; // Lower q_high if not using over quant
4079 else // else lower zbin_oq_high
4080 zbin_oq_high = (cpi->zbin_over_quant > zbin_oq_low) ? (cpi->zbin_over_quant - 1) : zbin_oq_low;
4081
4082 if (overshoot_seen)
4083 {
4084 // Update rate_correction_factor unless cpi->active_worst_quality has changed.
4085 if (!active_worst_qchanged)
4086 vp8_update_rate_correction_factors(cpi, 1);
4087
4088 Q = (q_high + q_low) / 2;
4089
4090 // Adjust cpi->zbin_over_quant (only allowed when Q is max)
4091 if (Q < MAXQ)
4092 cpi->zbin_over_quant = 0;
4093 else
4094 cpi->zbin_over_quant = (zbin_oq_high + zbin_oq_low) / 2;
4095 }
4096 else
4097 {
4098 // Update rate_correction_factor unless cpi->active_worst_quality has changed.
4099 if (!active_worst_qchanged)
4100 vp8_update_rate_correction_factors(cpi, 0);
4101
4102 Q = vp8_regulate_q(cpi, cpi->this_frame_target);
4103
4104 while (((Q > q_high) || (cpi->zbin_over_quant > zbin_oq_high)) && (Retries < 10))
4105 {
4106 vp8_update_rate_correction_factors(cpi, 0);
4107 Q = vp8_regulate_q(cpi, cpi->this_frame_target);
4108 Retries ++;
4109 }
4110 }
4111
4112 undershoot_seen = TRUE;
4113 }
4114
4115 // Clamp Q to upper and lower limits:
4116 if (Q > q_high)
4117 Q = q_high;
4118 else if (Q < q_low)
4119 Q = q_low;
4120
4121 // Clamp cpi->zbin_over_quant
4122 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;
4123
4124 //Loop = ((Q != last_q) || (last_zbin_oq != cpi->zbin_over_quant)) ? TRUE : FALSE;
4125 Loop = ((Q != last_q)) ? TRUE : FALSE;
4126 last_zbin_oq = cpi->zbin_over_quant;
4127 }
4128 else
4129 #endif
4130 Loop = FALSE;
4131
4132 if (cpi->is_src_frame_alt_ref)
4133 Loop = FALSE;
4134
4135 if (Loop == TRUE)
4136 {
4137 vp8_restore_coding_context(cpi);
4138 loop_count++;
4139 #if CONFIG_PSNR
4140 cpi->tot_recode_hits++;
4141 #endif
4142 }
4143 }
4144 while (Loop == TRUE);
4145
4146 #if 0
4147 // Experimental code for lagged and one pass
4148 // Update stats used for one pass GF selection
4149 {
4150 /*
4151 int frames_so_far;
4152 double frame_intra_error;
4153 double frame_coded_error;
4154 double frame_pcnt_inter;
4155 double frame_pcnt_motion;
4156 double frame_mvr;
4157 double frame_mvr_abs;
4158 double frame_mvc;
4159 double frame_mvc_abs;
4160 */
4161
4162 cpi->one_pass_frame_stats[cpi->one_pass_frame_index].frame_coded_error = (double)cpi->prediction_error;
4163 cpi->one_pass_frame_stats[cpi->one_pass_frame_index].frame_intra_error = (double)cpi->intra_error;
4164 cpi->one_pass_frame_stats[cpi->one_pass_frame_index].frame_pcnt_inter = (double)(100 - cpi->this_frame_percent_intra) / 100.0;
4165 }
4166 #endif
4167
4168 // Update the GF useage maps.
4169 // This is done after completing the compression of a frame when all modes etc. are finalized but before loop filter
4170 vp8_update_gf_useage_maps(cpi, cm, &cpi->mb);
4171
4172 if (cm->frame_type == KEY_FRAME)
4173 cm->refresh_last_frame = 1;
4174
4175 #if 0
4176 {
4177 FILE *f = fopen("gfactive.stt", "a");
4178 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);
4179 fclose(f);
4180 }
4181 #endif
4182
4183 // 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
4184 // This is purely an encoder descision at present.
4185 if (!cpi->oxcf.error_resilient_mode && cm->refresh_golden_frame)
4186 cm->copy_buffer_to_arf = 2;
4187 else
4188 cm->copy_buffer_to_arf = 0;
4189
4190 if (cm->refresh_last_frame)
4191 {
4192 vp8_swap_yv12_buffer(&cm->yv12_fb[cm->lst_fb_idx], &cm->yv12_fb[cm->new_fb_idx]);
4193 cm->frame_to_show = &cm->yv12_fb[cm->lst_fb_idx];
4194 }
4195 else
4196 cm->frame_to_show = &cm->yv12_fb[cm->new_fb_idx];
4197
4198
4199
4200 //#pragma omp parallel sections
4201 {
4202
4203 //#pragma omp section
4204 {
4205
4206 struct vpx_usec_timer timer;
4207
4208 vpx_usec_timer_start(&timer);
4209
4210 if (cpi->sf.auto_filter == 0)
4211 vp8cx_pick_filter_level_fast(cpi->Source, cpi);
4212 else
4213 vp8cx_pick_filter_level(cpi->Source, cpi);
4214
4215 vpx_usec_timer_mark(&timer);
4216
4217 cpi->time_pick_lpf += vpx_usec_timer_elapsed(&timer);
4218
4219 if (cm->no_lpf)
4220 cm->filter_level = 0;
4221
4222 if (cm->filter_level > 0)
4223 {
4224 vp8cx_set_alt_lf_level(cpi, cm->filter_level);
4225 vp8_loop_filter_frame(cm, &cpi->mb.e_mbd, cm->filter_level);
4226 cm->last_frame_type = cm->frame_type;
4227 cm->last_filter_type = cm->filter_type;
4228 cm->last_sharpness_level = cm->sharpness_level;
4229 }
4230
4231 vp8_yv12_extend_frame_borders_ptr(cm->frame_to_show);
4232
4233 if (cpi->oxcf.error_resilient_mode == 1)
4234 {
4235 cm->refresh_entropy_probs = 0;
4236 }
4237
4238 }
4239 //#pragma omp section
4240 {
4241 // build the bitstream
4242 vp8_pack_bitstream(cpi, dest, size);
4243 }
4244 }
4245
4246 {
4247 YV12_BUFFER_CONFIG *lst_yv12 = &cm->yv12_fb[cm->lst_fb_idx];
4248 YV12_BUFFER_CONFIG *new_yv12 = &cm->yv12_fb[cm->new_fb_idx];
4249 YV12_BUFFER_CONFIG *gld_yv12 = &cm->yv12_fb[cm->gld_fb_idx];
4250 YV12_BUFFER_CONFIG *alt_yv12 = &cm->yv12_fb[cm->alt_fb_idx];
4251 // At this point the new frame has been encoded coded.
4252 // If any buffer copy / swaping is signalled it should be done here.
4253 if (cm->frame_type == KEY_FRAME)
4254 {
4255 vp8_yv12_copy_frame_ptr(cm->frame_to_show, gld_yv12);
4256 vp8_yv12_copy_frame_ptr(cm->frame_to_show, alt_yv12);
4257 }
4258 else // For non key frames
4259 {
4260 // Code to copy between reference buffers
4261 if (cm->copy_buffer_to_arf)
4262 {
4263 if (cm->copy_buffer_to_arf == 1)
4264 {
4265 if (cm->refresh_last_frame)
4266 // We copy new_frame here because last and new buffers will already have been swapped if cm->refresh_last_frame is set.
4267 vp8_yv12_copy_frame_ptr(new_yv12, alt_yv12);
4268 else
4269 vp8_yv12_copy_frame_ptr(lst_yv12, alt_yv12);
4270 }
4271 else if (cm->copy_buffer_to_arf == 2)
4272 vp8_yv12_copy_frame_ptr(gld_yv12, alt_yv12);
4273 }
4274
4275 if (cm->copy_buffer_to_gf)
4276 {
4277 if (cm->copy_buffer_to_gf == 1)
4278 {
4279 if (cm->refresh_last_frame)
4280 // We copy new_frame here because last and new buffers will already have been swapped if cm->refresh_last_frame is set.
4281 vp8_yv12_copy_frame_ptr(new_yv12, gld_yv12);
4282 else
4283 vp8_yv12_copy_frame_ptr(lst_yv12, gld_yv12);
4284 }
4285 else if (cm->copy_buffer_to_gf == 2)
4286 vp8_yv12_copy_frame_ptr(alt_yv12, gld_yv12);
4287 }
4288 }
4289 }
4290
4291 // Update rate control heuristics
4292 cpi->total_byte_count += (*size);
4293 cpi->projected_frame_size = (*size) << 3;
4294
4295 if (!active_worst_qchanged)
4296 vp8_update_rate_correction_factors(cpi, 2);
4297
4298 cpi->last_q[cm->frame_type] = cm->base_qindex;
4299
4300 if (cm->frame_type == KEY_FRAME)
4301 {
4302 vp8_adjust_key_frame_context(cpi);
4303 }
4304
4305 // Keep a record of ambient average Q.
4306 if (cm->frame_type == KEY_FRAME)
4307 cpi->avg_frame_qindex = cm->base_qindex;
4308 else
4309 cpi->avg_frame_qindex = (2 + 3 * cpi->avg_frame_qindex + cm->base_qindex) >> 2;
4310
4311 // Keep a record from which we can calculate the average Q excluding GF updates and key frames
4312 if ((cm->frame_type != KEY_FRAME) && !cm->refresh_golden_frame && !cm->refresh_alt_ref_frame)
4313 {
4314 cpi->ni_frames++;
4315
4316 // Calculate the average Q for normal inter frames (not key or GFU frames)
4317 // This is used as a basis for setting active worst quality.
4318 if (cpi->ni_frames > 150)
4319 {
4320 cpi->ni_tot_qi += Q;
4321 cpi->ni_av_qi = (cpi->ni_tot_qi / cpi->ni_frames);
4322 }
4323 // Early in the clip ... average the current frame Q value with the default
4324 // entered by the user as a dampening measure
4325 else
4326 {
4327 cpi->ni_tot_qi += Q;
4328 cpi->ni_av_qi = ((cpi->ni_tot_qi / cpi->ni_frames) + cpi->worst_quality + 1) / 2;
4329 }
4330
4331 // If the average Q is higher than what was used in the last frame
4332 // (after going through the recode loop to keep the frame size within range)
4333 // then use the last frame value - 1.
4334 // The -1 is designed to stop Q and hence the data rate, from progressively
4335 // falling away during difficult sections, but at the same time reduce the number of
4336 // itterations around the recode loop.
4337 if (Q > cpi->ni_av_qi)
4338 cpi->ni_av_qi = Q - 1;
4339
4340 }
4341
4342 #if 0
4343
4344 // If the frame was massively oversize and we are below optimal buffer level drop next frame
4345 if ((cpi->drop_frames_allowed) &&
4346 (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER) &&
4347 (cpi->buffer_level < cpi->oxcf.drop_frames_water_mark * cpi->oxcf.optimal_buffer_level / 100) &&
4348 (cpi->projected_frame_size > (4 * cpi->this_frame_target)))
4349 {
4350 cpi->drop_frame = TRUE;
4351 }
4352
4353 #endif
4354
4355 // Set the count for maximum consequative dropped frames based upon the ratio of
4356 // this frame size to the target average per frame bandwidth.
4357 // (cpi->av_per_frame_bandwidth > 0) is just a sanity check to prevent / 0.
4358 if (cpi->drop_frames_allowed && (cpi->av_per_frame_bandwidth > 0))
4359 {
4360 cpi->max_drop_count = cpi->projected_frame_size / cpi->av_per_frame_bandwidth;
4361
4362 if (cpi->max_drop_count > cpi->max_consec_dropped_frames)
4363 cpi->max_drop_count = cpi->max_consec_dropped_frames;
4364 }
4365
4366 // Update the buffer level variable.
4367 if (cpi->common.refresh_alt_ref_frame)
4368 cpi->bits_off_target -= cpi->projected_frame_size;
4369 else
4370 cpi->bits_off_target += cpi->av_per_frame_bandwidth - cpi->projected_frame_size;
4371
4372 // Rolling monitors of whether we are over or underspending used to help regulate min and Max Q in two pass.
4373 cpi->rolling_target_bits = ((cpi->rolling_target_bits * 3) + cpi->this_frame_target + 2) / 4;
4374 cpi->rolling_actual_bits = ((cpi->rolling_actual_bits * 3) + cpi->projected_frame_size + 2) / 4;
4375 cpi->long_rolling_target_bits = ((cpi->long_rolling_target_bits * 31) + cpi->this_frame_target + 16) / 32;
4376 cpi->long_rolling_actual_bits = ((cpi->long_rolling_actual_bits * 31) + cpi->projected_frame_size + 16) / 32;
4377
4378 // Actual bits spent
4379 cpi->total_actual_bits += cpi->projected_frame_size;
4380
4381 // Debug stats
4382 cpi->total_target_vs_actual += (cpi->this_frame_target - cpi->projected_frame_size);
4383
4384 cpi->buffer_level = cpi->bits_off_target;
4385
4386 // Update bits left to the kf and gf groups to account for overshoot or undershoot on these frames
4387 if (cm->frame_type == KEY_FRAME)
4388 {
4389 cpi->kf_group_bits += cpi->this_frame_target - cpi->projected_frame_size;
4390
4391 if (cpi->kf_group_bits < 0)
4392 cpi->kf_group_bits = 0 ;
4393 }
4394 else if (cm->refresh_golden_frame || cm->refresh_alt_ref_frame)
4395 {
4396 cpi->gf_group_bits += cpi->this_frame_target - cpi->projected_frame_size;
4397
4398 if (cpi->gf_group_bits < 0)
4399 cpi->gf_group_bits = 0 ;
4400 }
4401
4402 if (cm->frame_type != KEY_FRAME)
4403 {
4404 if (cpi->common.refresh_alt_ref_frame)
4405 {
4406 cpi->last_skip_false_probs[2] = cpi->prob_skip_false;
4407 cpi->last_skip_probs_q[2] = cm->base_qindex;
4408 }
4409 else if (cpi->common.refresh_golden_frame)
4410 {
4411 cpi->last_skip_false_probs[1] = cpi->prob_skip_false;
4412 cpi->last_skip_probs_q[1] = cm->base_qindex;
4413 }
4414 else
4415 {
4416 cpi->last_skip_false_probs[0] = cpi->prob_skip_false;
4417 cpi->last_skip_probs_q[0] = cm->base_qindex;
4418
4419 //update the baseline
4420 cpi->base_skip_false_prob[cm->base_qindex] = cpi->prob_skip_false;
4421
4422 }
4423 }
4424
4425 #if 0 && CONFIG_PSNR
4426 {
4427 FILE *f = fopen("tmp.stt", "a");
4428
4429 vp8_clear_system_state(); //__asm emms;
4430
4431 if (cpi->total_coded_error_left != 0.0)
4432 fprintf(f, "%10d %10d %10d %10d %10d %10d %10d %10d %6ld %6ld"
4433 "%6ld %6ld %5ld %5ld %5ld %8ld %8.2f %10d %10.3f"
4434 "%10.3f %8ld\n",
4435 cpi->common.current_video_frame, cpi->this_frame_target,
4436 cpi->projected_frame_size,
4437 (cpi->projected_frame_size - cpi->this_frame_target),
4438 (int)cpi->total_target_vs_actual,
4439 (cpi->oxcf.starting_buffer_level-cpi->bits_off_target),
4440 (int)cpi->total_actual_bits, cm->base_qindex,
4441 cpi->active_best_quality, cpi->active_worst_quality,
4442 cpi->avg_frame_qindex, cpi->zbin_over_quant,
4443 cm->refresh_golden_frame, cm->refresh_alt_ref_frame,
4444 cm->frame_type, cpi->gfu_boost,
4445 cpi->est_max_qcorrection_factor, (int)cpi->bits_left,
4446 cpi->total_coded_error_left,
4447 (double)cpi->bits_left / cpi->total_coded_error_left,
4448 cpi->tot_recode_hits);
4449 else
4450 fprintf(f, "%10d %10d %10d %10d %10d %10d %10d %10d %6ld %6ld"
4451 "%6ld %6ld %5ld %5ld %5ld %8ld %8.2f %10d %10.3f"
4452 "%8ld\n",
4453 cpi->common.current_video_frame,
4454 cpi->this_frame_target, cpi->projected_frame_size,
4455 (cpi->projected_frame_size - cpi->this_frame_target),
4456 (int)cpi->total_target_vs_actual,
4457 (cpi->oxcf.starting_buffer_level-cpi->bits_off_target),
4458 (int)cpi->total_actual_bits, cm->base_qindex,
4459 cpi->active_best_quality, cpi->active_worst_quality,
4460 cpi->avg_frame_qindex, cpi->zbin_over_quant,
4461 cm->refresh_golden_frame, cm->refresh_alt_ref_frame,
4462 cm->frame_type, cpi->gfu_boost,
4463 cpi->est_max_qcorrection_factor, (int)cpi->bits_left,
4464 cpi->total_coded_error_left, cpi->tot_recode_hits);
4465
4466 fclose(f);
4467
4468 {
4469 FILE *fmodes = fopen("Modes.stt", "a");
4470 int i;
4471
4472 fprintf(fmodes, "%6d:%1d:%1d:%1d ",
4473 cpi->common.current_video_frame,
4474 cm->frame_type, cm->refresh_golden_frame,
4475 cm->refresh_alt_ref_frame);
4476
4477 for (i = 0; i < MAX_MODES; i++)
4478 fprintf(fmodes, "%5d ", cpi->mode_chosen_counts[i]);
4479
4480 fprintf(fmodes, "\n");
4481
4482 fclose(fmodes);
4483 }
4484 }
4485
4486 #endif
4487
4488 // If this was a kf or Gf note the Q
4489 if ((cm->frame_type == KEY_FRAME) || cm->refresh_golden_frame || cm->refresh_alt_ref_frame)
4490 cm->last_kf_gf_q = cm->base_qindex;
4491
4492 if (cm->refresh_golden_frame == 1)
4493 cm->frame_flags = cm->frame_flags | FRAMEFLAGS_GOLDEN;
4494 else
4495 cm->frame_flags = cm->frame_flags&~FRAMEFLAGS_GOLDEN;
4496
4497 if (cm->refresh_alt_ref_frame == 1)
4498 cm->frame_flags = cm->frame_flags | FRAMEFLAGS_ALTREF;
4499 else
4500 cm->frame_flags = cm->frame_flags&~FRAMEFLAGS_ALTREF;
4501
4502
4503 if (cm->refresh_last_frame & cm->refresh_golden_frame) // both refreshed
4504 cpi->gold_is_last = 1;
4505 else if (cm->refresh_last_frame ^ cm->refresh_golden_frame) // 1 refreshed but not the other
4506 cpi->gold_is_last = 0;
4507
4508 if (cm->refresh_last_frame & cm->refresh_alt_ref_frame) // both refreshed
4509 cpi->alt_is_last = 1;
4510 else if (cm->refresh_last_frame ^ cm->refresh_alt_ref_frame) // 1 refreshed but not the other
4511 cpi->alt_is_last = 0;
4512
4513 if (cm->refresh_alt_ref_frame & cm->refresh_golden_frame) // both refreshed
4514 cpi->gold_is_alt = 1;
4515 else if (cm->refresh_alt_ref_frame ^ cm->refresh_golden_frame) // 1 refreshed but not the other
4516 cpi->gold_is_alt = 0;
4517
4518 cpi->ref_frame_flags = VP8_ALT_FLAG | VP8_GOLD_FLAG | VP8_LAST_FLAG;
4519
4520 if (cpi->gold_is_last)
4521 cpi->ref_frame_flags &= ~VP8_GOLD_FLAG;
4522
4523 if (cpi->alt_is_last)
4524 cpi->ref_frame_flags &= ~VP8_ALT_FLAG;
4525
4526 if (cpi->gold_is_alt)
4527 cpi->ref_frame_flags &= ~VP8_ALT_FLAG;
4528
4529
4530 if (cpi->oxcf.error_resilient_mode)
4531 {
4532 // Is this an alternate reference update
4533 if (cpi->common.refresh_alt_ref_frame)
4534 vp8_yv12_copy_frame_ptr(cm->frame_to_show, &cm->yv12_fb[cm->alt_fb_idx]);
4535
4536 if (cpi->common.refresh_golden_frame)
4537 vp8_yv12_copy_frame_ptr(cm->frame_to_show, &cm->yv12_fb[cm->gld_fb_idx]);
4538 }
4539 else
4540 {
4541 if (cpi->oxcf.play_alternate && cpi->common.refresh_alt_ref_frame)
4542 // Update the alternate reference frame and stats as appropriate.
4543 update_alt_ref_frame_and_stats(cpi);
4544 else
4545 // Update the Golden frame and golden frame and stats as appropriate.
4546 update_golden_frame_and_stats(cpi);
4547 }
4548
4549 if (cm->frame_type == KEY_FRAME)
4550 {
4551 // Tell the caller that the frame was coded as a key frame
4552 *frame_flags = cm->frame_flags | FRAMEFLAGS_KEY;
4553
4554 // As this frame is a key frame the next defaults to an inter frame.
4555 cm->frame_type = INTER_FRAME;
4556
4557 cpi->last_frame_percent_intra = 100;
4558 }
4559 else
4560 {
4561 *frame_flags = cm->frame_flags&~FRAMEFLAGS_KEY;
4562
4563 cpi->last_frame_percent_intra = cpi->this_frame_percent_intra;
4564 }
4565
4566 // Clear the one shot update flags for segmentation map and mode/ref loop filter deltas.
4567 cpi->mb.e_mbd.update_mb_segmentation_map = 0;
4568 cpi->mb.e_mbd.update_mb_segmentation_data = 0;
4569 cpi->mb.e_mbd.mode_ref_lf_delta_update = 0;
4570
4571
4572 // Dont increment frame counters if this was an altref buffer update not a real frame
4573 if (cm->show_frame)
4574 {
4575 cm->current_video_frame++;
4576 cpi->frames_since_key++;
4577 }
4578
4579 // reset to normal state now that we are done.
4580
4581
4582
4583 #if 0
4584 {
4585 char filename[512];
4586 FILE *recon_file;
4587 sprintf(filename, "enc%04d.yuv", (int) cm->current_video_frame);
4588 recon_file = fopen(filename, "wb");
4589 fwrite(cm->yv12_fb[cm->lst_fb_idx].buffer_alloc,
4590 cm->yv12_fb[cm->lst_fb_idx].frame_size, 1, recon_file);
4591 fclose(recon_file);
4592 }
4593 #endif
4594
4595 // DEBUG
4596 //vp8_write_yuv_frame("encoder_recon.yuv", cm->frame_to_show);
4597
4598
4599 }
4600
vp8_is_gf_update_needed(VP8_PTR ptr)4601 int vp8_is_gf_update_needed(VP8_PTR ptr)
4602 {
4603 VP8_COMP *cpi = (VP8_COMP *) ptr;
4604 int ret_val;
4605
4606 ret_val = cpi->gf_update_recommended;
4607 cpi->gf_update_recommended = 0;
4608
4609 return ret_val;
4610 }
4611
vp8_check_gf_quality(VP8_COMP * cpi)4612 void vp8_check_gf_quality(VP8_COMP *cpi)
4613 {
4614 VP8_COMMON *cm = &cpi->common;
4615 int gf_active_pct = (100 * cpi->gf_active_count) / (cm->mb_rows * cm->mb_cols);
4616 int gf_ref_usage_pct = (cpi->count_mb_ref_frame_usage[GOLDEN_FRAME] * 100) / (cm->mb_rows * cm->mb_cols);
4617 int last_ref_zz_useage = (cpi->inter_zz_count * 100) / (cm->mb_rows * cm->mb_cols);
4618
4619 // Gf refresh is not currently being signalled
4620 if (cpi->gf_update_recommended == 0)
4621 {
4622 if (cpi->common.frames_since_golden > 7)
4623 {
4624 // Low use of gf
4625 if ((gf_active_pct < 10) || ((gf_active_pct + gf_ref_usage_pct) < 15))
4626 {
4627 // ...but last frame zero zero usage is reasonbable so a new gf might be appropriate
4628 if (last_ref_zz_useage >= 25)
4629 {
4630 cpi->gf_bad_count ++;
4631
4632 if (cpi->gf_bad_count >= 8) // Check that the condition is stable
4633 {
4634 cpi->gf_update_recommended = 1;
4635 cpi->gf_bad_count = 0;
4636 }
4637 }
4638 else
4639 cpi->gf_bad_count = 0; // Restart count as the background is not stable enough
4640 }
4641 else
4642 cpi->gf_bad_count = 0; // Gf useage has picked up so reset count
4643 }
4644 }
4645 // If the signal is set but has not been read should we cancel it.
4646 else if (last_ref_zz_useage < 15)
4647 {
4648 cpi->gf_update_recommended = 0;
4649 cpi->gf_bad_count = 0;
4650 }
4651
4652 #if 0
4653 {
4654 FILE *f = fopen("gfneeded.stt", "a");
4655 fprintf(f, "%10d %10d %10d %10d %10ld \n",
4656 cm->current_video_frame,
4657 cpi->common.frames_since_golden,
4658 gf_active_pct, gf_ref_usage_pct,
4659 cpi->gf_update_recommended);
4660 fclose(f);
4661 }
4662
4663 #endif
4664 }
4665
4666 #if !(CONFIG_REALTIME_ONLY)
Pass2Encode(VP8_COMP * cpi,unsigned long * size,unsigned char * dest,unsigned int * frame_flags)4667 static void Pass2Encode(VP8_COMP *cpi, unsigned long *size, unsigned char *dest, unsigned int *frame_flags)
4668 {
4669
4670 if (!cpi->common.refresh_alt_ref_frame)
4671 vp8_second_pass(cpi);
4672
4673 encode_frame_to_data_rate(cpi, size, dest, frame_flags);
4674 cpi->bits_left -= 8 * *size;
4675
4676 if (!cpi->common.refresh_alt_ref_frame)
4677 {
4678 double two_pass_min_rate = (double)(cpi->oxcf.target_bandwidth
4679 *cpi->oxcf.two_pass_vbrmin_section / 100);
4680 cpi->bits_left += (long long)(two_pass_min_rate / cpi->oxcf.frame_rate);
4681 }
4682 }
4683 #endif
4684
4685 //For ARM NEON, d8-d15 are callee-saved registers, and need to be saved by us.
4686 #if HAVE_ARMV7
4687 extern void vp8_push_neon(INT64 *store);
4688 extern void vp8_pop_neon(INT64 *store);
4689 #endif
vp8_receive_raw_frame(VP8_PTR ptr,unsigned int frame_flags,YV12_BUFFER_CONFIG * sd,INT64 time_stamp,INT64 end_time)4690 int vp8_receive_raw_frame(VP8_PTR ptr, unsigned int frame_flags, YV12_BUFFER_CONFIG *sd, INT64 time_stamp, INT64 end_time)
4691 {
4692 INT64 store_reg[8];
4693 VP8_COMP *cpi = (VP8_COMP *) ptr;
4694 VP8_COMMON *cm = &cpi->common;
4695 struct vpx_usec_timer timer;
4696
4697 if (!cpi)
4698 return -1;
4699
4700 #if HAVE_ARMV7
4701 #if CONFIG_RUNTIME_CPU_DETECT
4702 if (cm->rtcd.flags & HAS_NEON)
4703 #endif
4704 {
4705 vp8_push_neon(store_reg);
4706 }
4707 #endif
4708
4709 vpx_usec_timer_start(&timer);
4710
4711 // no more room for frames;
4712 if (cpi->source_buffer_count != 0 && cpi->source_buffer_count >= cpi->oxcf.lag_in_frames)
4713 {
4714 #if HAVE_ARMV7
4715 #if CONFIG_RUNTIME_CPU_DETECT
4716 if (cm->rtcd.flags & HAS_NEON)
4717 #endif
4718 {
4719 vp8_pop_neon(store_reg);
4720 }
4721 #endif
4722 return -1;
4723 }
4724
4725 //printf("in-cpi->source_buffer_count: %d\n", cpi->source_buffer_count);
4726
4727 cm->clr_type = sd->clrtype;
4728
4729 // make a copy of the frame for use later...
4730 #if !(CONFIG_REALTIME_ONLY)
4731
4732 if (cpi->oxcf.allow_lag)
4733 {
4734 int which_buffer = cpi->source_encode_index - 1;
4735 SOURCE_SAMPLE *s;
4736
4737 if (which_buffer == -1)
4738 which_buffer = cpi->oxcf.lag_in_frames - 1;
4739
4740 if (cpi->source_buffer_count < cpi->oxcf.lag_in_frames - 1)
4741 which_buffer = cpi->source_buffer_count;
4742
4743 s = &cpi->src_buffer[which_buffer];
4744
4745 s->source_time_stamp = time_stamp;
4746 s->source_end_time_stamp = end_time;
4747 s->source_frame_flags = frame_flags;
4748 vp8_yv12_copy_frame_ptr(sd, &s->source_buffer);
4749
4750 cpi->source_buffer_count ++;
4751 }
4752 else
4753 #endif
4754 {
4755 SOURCE_SAMPLE *s;
4756 s = &cpi->src_buffer[0];
4757 s->source_end_time_stamp = end_time;
4758 s->source_time_stamp = time_stamp;
4759 s->source_frame_flags = frame_flags;
4760 #if HAVE_ARMV7
4761 #if CONFIG_RUNTIME_CPU_DETECT
4762 if (cm->rtcd.flags & HAS_NEON)
4763 #endif
4764 {
4765 vp8_yv12_copy_src_frame_func_neon(sd, &s->source_buffer);
4766 }
4767 #if CONFIG_RUNTIME_CPU_DETECT
4768 else
4769 #endif
4770 #endif
4771 #if !HAVE_ARMV7 || CONFIG_RUNTIME_CPU_DETECT
4772 {
4773 vp8_yv12_copy_frame_ptr(sd, &s->source_buffer);
4774 }
4775 #endif
4776 cpi->source_buffer_count = 1;
4777 }
4778
4779 vpx_usec_timer_mark(&timer);
4780 cpi->time_receive_data += vpx_usec_timer_elapsed(&timer);
4781
4782 #if HAVE_ARMV7
4783 #if CONFIG_RUNTIME_CPU_DETECT
4784 if (cm->rtcd.flags & HAS_NEON)
4785 #endif
4786 {
4787 vp8_pop_neon(store_reg);
4788 }
4789 #endif
4790
4791 return 0;
4792 }
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)4793 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)
4794 {
4795 INT64 store_reg[8];
4796 VP8_COMP *cpi = (VP8_COMP *) ptr;
4797 VP8_COMMON *cm = &cpi->common;
4798 struct vpx_usec_timer tsctimer;
4799 struct vpx_usec_timer ticktimer;
4800 struct vpx_usec_timer cmptimer;
4801
4802 if (!cpi)
4803 return -1;
4804
4805 #if HAVE_ARMV7
4806 #if CONFIG_RUNTIME_CPU_DETECT
4807 if (cm->rtcd.flags & HAS_NEON)
4808 #endif
4809 {
4810 vp8_push_neon(store_reg);
4811 }
4812 #endif
4813
4814 vpx_usec_timer_start(&cmptimer);
4815
4816
4817 // flush variable tells us that even though we have less than 10 frames
4818 // in our buffer we need to start producing compressed frames.
4819 // Probably because we are at the end of a file....
4820 if ((cpi->source_buffer_count == cpi->oxcf.lag_in_frames && cpi->oxcf.lag_in_frames > 0)
4821 || (!cpi->oxcf.allow_lag && cpi->source_buffer_count > 0)
4822 || (flush && cpi->source_buffer_count > 0))
4823 {
4824
4825 SOURCE_SAMPLE *s;
4826
4827 s = &cpi->src_buffer[cpi->source_encode_index];
4828 cpi->source_time_stamp = s->source_time_stamp;
4829 cpi->source_end_time_stamp = s->source_end_time_stamp;
4830
4831 #if !(CONFIG_REALTIME_ONLY)
4832
4833 // Should we code an alternate reference frame
4834 if (cpi->oxcf.error_resilient_mode == 0 &&
4835 cpi->oxcf.play_alternate &&
4836 cpi->source_alt_ref_pending &&
4837 (cpi->frames_till_gf_update_due < cpi->source_buffer_count) &&
4838 cpi->oxcf.lag_in_frames != 0)
4839 {
4840 cpi->last_alt_ref_sei = (cpi->source_encode_index + cpi->frames_till_gf_update_due) % cpi->oxcf.lag_in_frames;
4841
4842 #if VP8_TEMPORAL_ALT_REF
4843
4844 if (cpi->oxcf.arnr_max_frames > 0)
4845 {
4846 #if 0
4847 // my attempt at a loop that tests the results of strength filter.
4848 int start_frame = cpi->last_alt_ref_sei - 3;
4849
4850 int i, besti = -1, pastin = cpi->oxcf.arnr_strength;
4851
4852 int besterr;
4853
4854 if (start_frame < 0)
4855 start_frame += cpi->oxcf.lag_in_frames;
4856
4857 besterr = vp8_calc_low_ss_err(&cpi->src_buffer[cpi->last_alt_ref_sei].source_buffer,
4858 &cpi->src_buffer[start_frame].source_buffer, IF_RTCD(&cpi->rtcd.variance));
4859
4860 for (i = 0; i < 7; i++)
4861 {
4862 int thiserr;
4863 cpi->oxcf.arnr_strength = i;
4864 vp8cx_temp_filter_c(cpi);
4865
4866 thiserr = vp8_calc_low_ss_err(&cpi->alt_ref_buffer.source_buffer,
4867 &cpi->src_buffer[start_frame].source_buffer, IF_RTCD(&cpi->rtcd.variance));
4868
4869 if (10 * thiserr < besterr * 8)
4870 {
4871 besterr = thiserr;
4872 besti = i;
4873 }
4874 }
4875
4876 if (besti != -1)
4877 {
4878 cpi->oxcf.arnr_strength = besti;
4879 vp8cx_temp_filter_c(cpi);
4880 s = &cpi->alt_ref_buffer;
4881
4882 // FWG not sure if I need to copy this data for the Alt Ref frame
4883 s->source_time_stamp = cpi->src_buffer[cpi->last_alt_ref_sei].source_time_stamp;
4884 s->source_end_time_stamp = cpi->src_buffer[cpi->last_alt_ref_sei].source_end_time_stamp;
4885 s->source_frame_flags = cpi->src_buffer[cpi->last_alt_ref_sei].source_frame_flags;
4886 }
4887 else
4888 s = &cpi->src_buffer[cpi->last_alt_ref_sei];
4889
4890 #else
4891 vp8cx_temp_filter_c(cpi);
4892 s = &cpi->alt_ref_buffer;
4893
4894 // FWG not sure if I need to copy this data for the Alt Ref frame
4895 s->source_time_stamp = cpi->src_buffer[cpi->last_alt_ref_sei].source_time_stamp;
4896 s->source_end_time_stamp = cpi->src_buffer[cpi->last_alt_ref_sei].source_end_time_stamp;
4897 s->source_frame_flags = cpi->src_buffer[cpi->last_alt_ref_sei].source_frame_flags;
4898
4899 #endif
4900 }
4901 else
4902 #endif
4903 s = &cpi->src_buffer[cpi->last_alt_ref_sei];
4904
4905 cm->frames_till_alt_ref_frame = cpi->frames_till_gf_update_due;
4906 cm->refresh_alt_ref_frame = 1;
4907 cm->refresh_golden_frame = 0;
4908 cm->refresh_last_frame = 0;
4909 cm->show_frame = 0;
4910 cpi->source_alt_ref_pending = FALSE; // Clear Pending altf Ref flag.
4911 cpi->is_src_frame_alt_ref = 0;
4912 cpi->is_next_src_alt_ref = 0;
4913 }
4914 else
4915 #endif
4916 {
4917 cm->show_frame = 1;
4918 #if !(CONFIG_REALTIME_ONLY)
4919
4920 if (cpi->oxcf.allow_lag)
4921 {
4922 if (cpi->source_encode_index == cpi->last_alt_ref_sei)
4923 {
4924 cpi->is_src_frame_alt_ref = 1;
4925 cpi->last_alt_ref_sei = -1;
4926 }
4927 else
4928 cpi->is_src_frame_alt_ref = 0;
4929
4930 cpi->source_encode_index = (cpi->source_encode_index + 1) % cpi->oxcf.lag_in_frames;
4931
4932 if(cpi->source_encode_index == cpi->last_alt_ref_sei)
4933 cpi->is_next_src_alt_ref = 1;
4934 else
4935 cpi->is_next_src_alt_ref = 0;
4936 }
4937
4938 #endif
4939 cpi->source_buffer_count--;
4940 }
4941
4942 cpi->un_scaled_source = &s->source_buffer;
4943 cpi->Source = &s->source_buffer;
4944 cpi->source_frame_flags = s->source_frame_flags;
4945
4946 *time_stamp = cpi->source_time_stamp;
4947 *time_end = cpi->source_end_time_stamp;
4948 }
4949 else
4950 {
4951 *size = 0;
4952 #if !(CONFIG_REALTIME_ONLY)
4953
4954 if (flush && cpi->pass == 1 && !cpi->first_pass_done)
4955 {
4956 vp8_end_first_pass(cpi); /* get last stats packet */
4957 cpi->first_pass_done = 1;
4958 }
4959
4960 #endif
4961
4962 #if HAVE_ARMV7
4963 #if CONFIG_RUNTIME_CPU_DETECT
4964 if (cm->rtcd.flags & HAS_NEON)
4965 #endif
4966 {
4967 vp8_pop_neon(store_reg);
4968 }
4969 #endif
4970 return -1;
4971 }
4972
4973 *frame_flags = cpi->source_frame_flags;
4974
4975 #if CONFIG_PSNR
4976
4977 if (cpi->source_time_stamp < cpi->first_time_stamp_ever)
4978 cpi->first_time_stamp_ever = cpi->source_time_stamp;
4979
4980 #endif
4981
4982 // adjust frame rates based on timestamps given
4983 if (!cm->refresh_alt_ref_frame)
4984 {
4985 if (cpi->last_time_stamp_seen == 0)
4986 {
4987 double this_fps = 10000000.000 / (cpi->source_end_time_stamp - cpi->source_time_stamp);
4988
4989 vp8_new_frame_rate(cpi, this_fps);
4990 }
4991 else
4992 {
4993 long long nanosecs = cpi->source_time_stamp - cpi->last_time_stamp_seen;
4994 double this_fps = 10000000.000 / nanosecs;
4995
4996 vp8_new_frame_rate(cpi, (7 * cpi->oxcf.frame_rate + this_fps) / 8);
4997
4998 }
4999
5000 cpi->last_time_stamp_seen = cpi->source_time_stamp;
5001 }
5002
5003 if (cpi->compressor_speed == 2)
5004 {
5005 vp8_check_gf_quality(cpi);
5006 }
5007
5008 if (!cpi)
5009 {
5010 #if HAVE_ARMV7
5011 #if CONFIG_RUNTIME_CPU_DETECT
5012 if (cm->rtcd.flags & HAS_NEON)
5013 #endif
5014 {
5015 vp8_pop_neon(store_reg);
5016 }
5017 #endif
5018 return 0;
5019 }
5020
5021 if (cpi->compressor_speed == 2)
5022 {
5023 vpx_usec_timer_start(&tsctimer);
5024 vpx_usec_timer_start(&ticktimer);
5025 }
5026
5027 // start with a 0 size frame
5028 *size = 0;
5029
5030 // Clear down mmx registers
5031 vp8_clear_system_state(); //__asm emms;
5032
5033 cm->frame_type = INTER_FRAME;
5034 cm->frame_flags = *frame_flags;
5035
5036 #if 0
5037
5038 if (cm->refresh_alt_ref_frame)
5039 {
5040 //cm->refresh_golden_frame = 1;
5041 cm->refresh_golden_frame = 0;
5042 cm->refresh_last_frame = 0;
5043 }
5044 else
5045 {
5046 cm->refresh_golden_frame = 0;
5047 cm->refresh_last_frame = 1;
5048 }
5049
5050 #endif
5051
5052 #if !(CONFIG_REALTIME_ONLY)
5053
5054 if (cpi->pass == 1)
5055 {
5056 Pass1Encode(cpi, size, dest, frame_flags);
5057 }
5058 else if (cpi->pass == 2)
5059 {
5060 Pass2Encode(cpi, size, dest, frame_flags);
5061 }
5062 else
5063 #endif
5064 encode_frame_to_data_rate(cpi, size, dest, frame_flags);
5065
5066 if (cpi->compressor_speed == 2)
5067 {
5068 unsigned int duration, duration2;
5069 vpx_usec_timer_mark(&tsctimer);
5070 vpx_usec_timer_mark(&ticktimer);
5071
5072 duration = vpx_usec_timer_elapsed(&ticktimer);
5073 duration2 = (unsigned int)((double)duration / 2);
5074
5075 if (cm->frame_type != KEY_FRAME)
5076 {
5077 if (cpi->avg_encode_time == 0)
5078 cpi->avg_encode_time = duration;
5079 else
5080 cpi->avg_encode_time = (7 * cpi->avg_encode_time + duration) >> 3;
5081 }
5082
5083 if (duration2)
5084 {
5085 //if(*frame_flags!=1)
5086 {
5087
5088 if (cpi->avg_pick_mode_time == 0)
5089 cpi->avg_pick_mode_time = duration2;
5090 else
5091 cpi->avg_pick_mode_time = (7 * cpi->avg_pick_mode_time + duration2) >> 3;
5092 }
5093 }
5094
5095 }
5096
5097 if (cm->refresh_entropy_probs == 0)
5098 {
5099 vpx_memcpy(&cm->fc, &cm->lfc, sizeof(cm->fc));
5100 }
5101
5102 // if its a dropped frame honor the requests on subsequent frames
5103 if (*size > 0)
5104 {
5105
5106 // return to normal state
5107 cm->refresh_entropy_probs = 1;
5108 cm->refresh_alt_ref_frame = 0;
5109 cm->refresh_golden_frame = 0;
5110 cm->refresh_last_frame = 1;
5111 cm->frame_type = INTER_FRAME;
5112
5113 }
5114
5115 cpi->ready_for_new_frame = 1;
5116
5117 vpx_usec_timer_mark(&cmptimer);
5118 cpi->time_compress_data += vpx_usec_timer_elapsed(&cmptimer);
5119
5120 if (cpi->b_calculate_psnr && cpi->pass != 1 && cm->show_frame)
5121 generate_psnr_packet(cpi);
5122
5123 #if CONFIG_PSNR
5124
5125 if (cpi->pass != 1)
5126 {
5127 cpi->bytes += *size;
5128
5129 if (cm->show_frame)
5130 {
5131
5132 cpi->count ++;
5133
5134 if (cpi->b_calculate_psnr)
5135 {
5136 double y, u, v;
5137 double sq_error;
5138 double frame_psnr = vp8_calc_psnr(cpi->Source, cm->frame_to_show, &y, &u, &v, &sq_error);
5139
5140 cpi->total_y += y;
5141 cpi->total_u += u;
5142 cpi->total_v += v;
5143 cpi->total_sq_error += sq_error;
5144 cpi->total += frame_psnr;
5145 {
5146 double y2, u2, v2, frame_psnr2, frame_ssim2 = 0;
5147 double weight = 0;
5148
5149 vp8_deblock(cm->frame_to_show, &cm->post_proc_buffer, cm->filter_level * 10 / 6, 1, 0, IF_RTCD(&cm->rtcd.postproc));
5150 vp8_clear_system_state();
5151 frame_psnr2 = vp8_calc_psnr(cpi->Source, &cm->post_proc_buffer, &y2, &u2, &v2, &sq_error);
5152 frame_ssim2 = vp8_calc_ssim(cpi->Source, &cm->post_proc_buffer, 1, &weight);
5153
5154 cpi->summed_quality += frame_ssim2 * weight;
5155 cpi->summed_weights += weight;
5156
5157 cpi->totalp_y += y2;
5158 cpi->totalp_u += u2;
5159 cpi->totalp_v += v2;
5160 cpi->totalp += frame_psnr2;
5161 cpi->total_sq_error2 += sq_error;
5162
5163 }
5164 }
5165
5166 if (cpi->b_calculate_ssimg)
5167 {
5168 double y, u, v, frame_all;
5169 frame_all = vp8_calc_ssimg(cpi->Source, cm->frame_to_show, &y, &u, &v);
5170 cpi->total_ssimg_y += y;
5171 cpi->total_ssimg_u += u;
5172 cpi->total_ssimg_v += v;
5173 cpi->total_ssimg_all += frame_all;
5174 }
5175
5176 }
5177 }
5178
5179 #if 0
5180
5181 if (cpi->common.frame_type != 0 && cpi->common.base_qindex == cpi->oxcf.worst_allowed_q)
5182 {
5183 skiptruecount += cpi->skip_true_count;
5184 skipfalsecount += cpi->skip_false_count;
5185 }
5186
5187 #endif
5188 #if 0
5189
5190 if (cpi->pass != 1)
5191 {
5192 FILE *f = fopen("skip.stt", "a");
5193 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);
5194
5195 if (cpi->is_src_frame_alt_ref == 1)
5196 fprintf(f, "skipcount: %4d framesize: %d\n", cpi->skip_true_count , *size);
5197
5198 fclose(f);
5199 }
5200
5201 #endif
5202 #endif
5203
5204 #if HAVE_ARMV7
5205 #if CONFIG_RUNTIME_CPU_DETECT
5206 if (cm->rtcd.flags & HAS_NEON)
5207 #endif
5208 {
5209 vp8_pop_neon(store_reg);
5210 }
5211 #endif
5212
5213 return 0;
5214 }
5215
vp8_get_preview_raw_frame(VP8_PTR comp,YV12_BUFFER_CONFIG * dest,int deblock_level,int noise_level,int flags)5216 int vp8_get_preview_raw_frame(VP8_PTR comp, YV12_BUFFER_CONFIG *dest, int deblock_level, int noise_level, int flags)
5217 {
5218 VP8_COMP *cpi = (VP8_COMP *) comp;
5219
5220 if (cpi->common.refresh_alt_ref_frame)
5221 return -1;
5222 else
5223 {
5224 int ret;
5225 #if CONFIG_POSTPROC
5226 ret = vp8_post_proc_frame(&cpi->common, dest, deblock_level, noise_level, flags);
5227 #else
5228
5229 if (cpi->common.frame_to_show)
5230 {
5231 *dest = *cpi->common.frame_to_show;
5232 dest->y_width = cpi->common.Width;
5233 dest->y_height = cpi->common.Height;
5234 dest->uv_height = cpi->common.Height / 2;
5235 ret = 0;
5236 }
5237 else
5238 {
5239 ret = -1;
5240 }
5241
5242 #endif //!CONFIG_POSTPROC
5243 vp8_clear_system_state();
5244 return ret;
5245 }
5246 }
5247
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])5248 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])
5249 {
5250 VP8_COMP *cpi = (VP8_COMP *) comp;
5251 signed char feature_data[MB_LVL_MAX][MAX_MB_SEGMENTS];
5252
5253 if (cpi->common.mb_rows != rows || cpi->common.mb_cols != cols)
5254 return -1;
5255
5256 if (!map)
5257 {
5258 disable_segmentation((VP8_PTR)cpi);
5259 return 0;
5260 }
5261
5262 // Set the segmentation Map
5263 set_segmentation_map((VP8_PTR)cpi, map);
5264
5265 // Activate segmentation.
5266 enable_segmentation((VP8_PTR)cpi);
5267
5268 // Set up the quant segment data
5269 feature_data[MB_LVL_ALT_Q][0] = delta_q[0];
5270 feature_data[MB_LVL_ALT_Q][1] = delta_q[1];
5271 feature_data[MB_LVL_ALT_Q][2] = delta_q[2];
5272 feature_data[MB_LVL_ALT_Q][3] = delta_q[3];
5273
5274 // Set up the loop segment data s
5275 feature_data[MB_LVL_ALT_LF][0] = delta_lf[0];
5276 feature_data[MB_LVL_ALT_LF][1] = delta_lf[1];
5277 feature_data[MB_LVL_ALT_LF][2] = delta_lf[2];
5278 feature_data[MB_LVL_ALT_LF][3] = delta_lf[3];
5279
5280 cpi->segment_encode_breakout[0] = threshold[0];
5281 cpi->segment_encode_breakout[1] = threshold[1];
5282 cpi->segment_encode_breakout[2] = threshold[2];
5283 cpi->segment_encode_breakout[3] = threshold[3];
5284
5285 // Initialise the feature data structure
5286 // SEGMENT_DELTADATA 0, SEGMENT_ABSDATA 1
5287 set_segment_data((VP8_PTR)cpi, &feature_data[0][0], SEGMENT_DELTADATA);
5288
5289 return 0;
5290 }
5291
vp8_set_active_map(VP8_PTR comp,unsigned char * map,unsigned int rows,unsigned int cols)5292 int vp8_set_active_map(VP8_PTR comp, unsigned char *map, unsigned int rows, unsigned int cols)
5293 {
5294 VP8_COMP *cpi = (VP8_COMP *) comp;
5295
5296 if (rows == cpi->common.mb_rows && cols == cpi->common.mb_cols)
5297 {
5298 if (map)
5299 {
5300 vpx_memcpy(cpi->active_map, map, rows * cols);
5301 cpi->active_map_enabled = 1;
5302 }
5303 else
5304 cpi->active_map_enabled = 0;
5305
5306 return 0;
5307 }
5308 else
5309 {
5310 //cpi->active_map_enabled = 0;
5311 return -1 ;
5312 }
5313 }
5314
vp8_set_internal_size(VP8_PTR comp,VPX_SCALING horiz_mode,VPX_SCALING vert_mode)5315 int vp8_set_internal_size(VP8_PTR comp, VPX_SCALING horiz_mode, VPX_SCALING vert_mode)
5316 {
5317 VP8_COMP *cpi = (VP8_COMP *) comp;
5318
5319 if (horiz_mode >= NORMAL && horiz_mode <= ONETWO)
5320 cpi->common.horiz_scale = horiz_mode;
5321 else
5322 return -1;
5323
5324 if (vert_mode >= NORMAL && vert_mode <= ONETWO)
5325 cpi->common.vert_scale = vert_mode;
5326 else
5327 return -1;
5328
5329 return 0;
5330 }
5331
5332
5333
vp8_calc_ss_err(YV12_BUFFER_CONFIG * source,YV12_BUFFER_CONFIG * dest,const vp8_variance_rtcd_vtable_t * rtcd)5334 int vp8_calc_ss_err(YV12_BUFFER_CONFIG *source, YV12_BUFFER_CONFIG *dest, const vp8_variance_rtcd_vtable_t *rtcd)
5335 {
5336 int i, j;
5337 int Total = 0;
5338
5339 unsigned char *src = source->y_buffer;
5340 unsigned char *dst = dest->y_buffer;
5341 (void)rtcd;
5342
5343 // Loop through the Y plane raw and reconstruction data summing (square differences)
5344 for (i = 0; i < source->y_height; i += 16)
5345 {
5346 for (j = 0; j < source->y_width; j += 16)
5347 {
5348 unsigned int sse;
5349 Total += VARIANCE_INVOKE(rtcd, mse16x16)(src + j, source->y_stride, dst + j, dest->y_stride, &sse);
5350 }
5351
5352 src += 16 * source->y_stride;
5353 dst += 16 * dest->y_stride;
5354 }
5355
5356 return Total;
5357 }
vp8_calc_low_ss_err(YV12_BUFFER_CONFIG * source,YV12_BUFFER_CONFIG * dest,const vp8_variance_rtcd_vtable_t * rtcd)5358 int vp8_calc_low_ss_err(YV12_BUFFER_CONFIG *source, YV12_BUFFER_CONFIG *dest, const vp8_variance_rtcd_vtable_t *rtcd)
5359 {
5360 int i, j;
5361 int Total = 0;
5362
5363 unsigned char *src = source->y_buffer;
5364 unsigned char *dst = dest->y_buffer;
5365 (void)rtcd;
5366
5367 // Loop through the Y plane raw and reconstruction data summing (square differences)
5368 for (i = 0; i < source->y_height; i += 16)
5369 {
5370 for (j = 0; j < source->y_width; j += 16)
5371 {
5372 unsigned int sse;
5373 VARIANCE_INVOKE(rtcd, mse16x16)(src + j, source->y_stride, dst + j, dest->y_stride, &sse);
5374
5375 if (sse < 8096)
5376 Total += sse;
5377 }
5378
5379 src += 16 * source->y_stride;
5380 dst += 16 * dest->y_stride;
5381 }
5382
5383 return Total;
5384 }
5385
vp8_get_speed(VP8_PTR c)5386 int vp8_get_speed(VP8_PTR c)
5387 {
5388 VP8_COMP *cpi = (VP8_COMP *) c;
5389 return cpi->Speed;
5390 }
vp8_get_quantizer(VP8_PTR c)5391 int vp8_get_quantizer(VP8_PTR c)
5392 {
5393 VP8_COMP *cpi = (VP8_COMP *) c;
5394 return cpi->common.base_qindex;
5395 }
5396