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