media/libvpx/vp9/encoder/vp9_onyx_if.c@ac0c01689b40
media/libvpx/vp9/encoder/vp9_onyx_if.c
Thu, 15 Jan 2015 15:59:08 +0100
- author
- Michael Schloh von Bennewitz <michael@schloh.com>
- date
- Thu, 15 Jan 2015 15:59:08 +0100
- branch
- TOR_BUG_9701
- changeset 10
- ac0c01689b40
- permissions
- -rw-r--r--
Implement a real Private Browsing Mode condition by changing the API/ABI;
This solves Tor bug #9701, complying with disk avoidance documented in
https://www.torproject.org/projects/torbrowser/design/#disk-avoidance.
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 */
11 #include <math.h>
12 #include <stdio.h>
13 #include <limits.h>
15 #include "./vpx_config.h"
16 #include "./vpx_scale_rtcd.h"
18 #include "vp9/common/vp9_alloccommon.h"
19 #include "vp9/common/vp9_filter.h"
20 #include "vp9/common/vp9_idct.h"
21 #if CONFIG_VP9_POSTPROC
22 #include "vp9/common/vp9_postproc.h"
23 #endif
24 #include "vp9/common/vp9_reconinter.h"
25 #include "vp9/common/vp9_systemdependent.h"
26 #include "vp9/common/vp9_tile_common.h"
27 #include "vp9/encoder/vp9_firstpass.h"
28 #include "vp9/encoder/vp9_mbgraph.h"
29 #include "vp9/encoder/vp9_onyx_int.h"
30 #include "vp9/encoder/vp9_picklpf.h"
31 #include "vp9/encoder/vp9_psnr.h"
32 #include "vp9/encoder/vp9_ratectrl.h"
33 #include "vp9/encoder/vp9_rdopt.h"
34 #include "vp9/encoder/vp9_segmentation.h"
35 #include "vp9/encoder/vp9_temporal_filter.h"
36 #include "vp9/encoder/vp9_vaq.h"
38 #include "vpx_ports/vpx_timer.h"
41 extern void print_tree_update_probs();
43 static void set_default_lf_deltas(struct loopfilter *lf);
45 #define DEFAULT_INTERP_FILTER SWITCHABLE
47 #define SHARP_FILTER_QTHRESH 0 /* Q threshold for 8-tap sharp filter */
49 #define ALTREF_HIGH_PRECISION_MV 1 // Whether to use high precision mv
50 // for altref computation.
51 #define HIGH_PRECISION_MV_QTHRESH 200 // Q threshold for high precision
52 // mv. Choose a very high value for
53 // now so that HIGH_PRECISION is always
54 // chosen.
56 // Masks for partially or completely disabling split mode
57 #define DISABLE_ALL_SPLIT 0x3F
58 #define DISABLE_ALL_INTER_SPLIT 0x1F
59 #define DISABLE_COMPOUND_SPLIT 0x18
60 #define LAST_AND_INTRA_SPLIT_ONLY 0x1E
62 #if CONFIG_INTERNAL_STATS
63 extern double vp9_calc_ssim(YV12_BUFFER_CONFIG *source,
64 YV12_BUFFER_CONFIG *dest, int lumamask,
65 double *weight);
68 extern double vp9_calc_ssimg(YV12_BUFFER_CONFIG *source,
69 YV12_BUFFER_CONFIG *dest, double *ssim_y,
70 double *ssim_u, double *ssim_v);
73 #endif
75 // #define OUTPUT_YUV_REC
77 #ifdef OUTPUT_YUV_SRC
78 FILE *yuv_file;
79 #endif
80 #ifdef OUTPUT_YUV_REC
81 FILE *yuv_rec_file;
82 #endif
84 #if 0
85 FILE *framepsnr;
86 FILE *kf_list;
87 FILE *keyfile;
88 #endif
91 #ifdef ENTROPY_STATS
92 extern int intra_mode_stats[INTRA_MODES]
93 [INTRA_MODES]
94 [INTRA_MODES];
95 #endif
97 #ifdef MODE_STATS
98 extern void init_tx_count_stats();
99 extern void write_tx_count_stats();
100 extern void init_switchable_interp_stats();
101 extern void write_switchable_interp_stats();
102 #endif
104 #ifdef SPEEDSTATS
105 unsigned int frames_at_speed[16] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
106 0, 0, 0};
107 #endif
109 #if defined(SECTIONBITS_OUTPUT)
110 extern unsigned __int64 Sectionbits[500];
111 #endif
113 extern void vp9_init_quantizer(VP9_COMP *cpi);
115 // Tables relating active max Q to active min Q
116 static int kf_low_motion_minq[QINDEX_RANGE];
117 static int kf_high_motion_minq[QINDEX_RANGE];
118 static int gf_low_motion_minq[QINDEX_RANGE];
119 static int gf_high_motion_minq[QINDEX_RANGE];
120 static int inter_minq[QINDEX_RANGE];
121 static int afq_low_motion_minq[QINDEX_RANGE];
122 static int afq_high_motion_minq[QINDEX_RANGE];
124 static INLINE void Scale2Ratio(int mode, int *hr, int *hs) {
125 switch (mode) {
126 case NORMAL:
127 *hr = 1;
128 *hs = 1;
129 break;
130 case FOURFIVE:
131 *hr = 4;
132 *hs = 5;
133 break;
134 case THREEFIVE:
135 *hr = 3;
136 *hs = 5;
137 break;
138 case ONETWO:
139 *hr = 1;
140 *hs = 2;
141 break;
142 default:
143 *hr = 1;
144 *hs = 1;
145 assert(0);
146 break;
147 }
148 }
150 // Functions to compute the active minq lookup table entries based on a
151 // formulaic approach to facilitate easier adjustment of the Q tables.
152 // The formulae were derived from computing a 3rd order polynomial best
153 // fit to the original data (after plotting real maxq vs minq (not q index))
154 static int calculate_minq_index(double maxq,
155 double x3, double x2, double x1, double c) {
156 int i;
157 const double minqtarget = MIN(((x3 * maxq + x2) * maxq + x1) * maxq + c,
158 maxq);
160 // Special case handling to deal with the step from q2.0
161 // down to lossless mode represented by q 1.0.
162 if (minqtarget <= 2.0)
163 return 0;
165 for (i = 0; i < QINDEX_RANGE; i++) {
166 if (minqtarget <= vp9_convert_qindex_to_q(i))
167 return i;
168 }
170 return QINDEX_RANGE - 1;
171 }
173 static void init_minq_luts(void) {
174 int i;
176 for (i = 0; i < QINDEX_RANGE; i++) {
177 const double maxq = vp9_convert_qindex_to_q(i);
180 kf_low_motion_minq[i] = calculate_minq_index(maxq,
181 0.000001,
182 -0.0004,
183 0.15,
184 0.0);
185 kf_high_motion_minq[i] = calculate_minq_index(maxq,
186 0.000002,
187 -0.0012,
188 0.5,
189 0.0);
191 gf_low_motion_minq[i] = calculate_minq_index(maxq,
192 0.0000015,
193 -0.0009,
194 0.32,
195 0.0);
196 gf_high_motion_minq[i] = calculate_minq_index(maxq,
197 0.0000021,
198 -0.00125,
199 0.50,
200 0.0);
201 inter_minq[i] = calculate_minq_index(maxq,
202 0.00000271,
203 -0.00113,
204 0.75,
205 0.0);
206 afq_low_motion_minq[i] = calculate_minq_index(maxq,
207 0.0000015,
208 -0.0009,
209 0.33,
210 0.0);
211 afq_high_motion_minq[i] = calculate_minq_index(maxq,
212 0.0000021,
213 -0.00125,
214 0.55,
215 0.0);
216 }
217 }
219 static int get_active_quality(int q,
220 int gfu_boost,
221 int low,
222 int high,
223 int *low_motion_minq,
224 int *high_motion_minq) {
225 int active_best_quality;
226 if (gfu_boost > high) {
227 active_best_quality = low_motion_minq[q];
228 } else if (gfu_boost < low) {
229 active_best_quality = high_motion_minq[q];
230 } else {
231 const int gap = high - low;
232 const int offset = high - gfu_boost;
233 const int qdiff = high_motion_minq[q] - low_motion_minq[q];
234 const int adjustment = ((offset * qdiff) + (gap >> 1)) / gap;
235 active_best_quality = low_motion_minq[q] + adjustment;
236 }
237 return active_best_quality;
238 }
240 static void set_mvcost(VP9_COMP *cpi) {
241 MACROBLOCK *const mb = &cpi->mb;
242 if (cpi->common.allow_high_precision_mv) {
243 mb->mvcost = mb->nmvcost_hp;
244 mb->mvsadcost = mb->nmvsadcost_hp;
245 } else {
246 mb->mvcost = mb->nmvcost;
247 mb->mvsadcost = mb->nmvsadcost;
248 }
249 }
251 void vp9_initialize_enc() {
252 static int init_done = 0;
254 if (!init_done) {
255 vp9_initialize_common();
256 vp9_tokenize_initialize();
257 vp9_init_quant_tables();
258 vp9_init_me_luts();
259 init_minq_luts();
260 // init_base_skip_probs();
261 init_done = 1;
262 }
263 }
265 static void setup_features(VP9_COMMON *cm) {
266 struct loopfilter *const lf = &cm->lf;
267 struct segmentation *const seg = &cm->seg;
269 // Set up default state for MB feature flags
270 seg->enabled = 0;
272 seg->update_map = 0;
273 seg->update_data = 0;
274 vpx_memset(seg->tree_probs, 255, sizeof(seg->tree_probs));
276 vp9_clearall_segfeatures(seg);
278 lf->mode_ref_delta_enabled = 0;
279 lf->mode_ref_delta_update = 0;
280 vp9_zero(lf->ref_deltas);
281 vp9_zero(lf->mode_deltas);
282 vp9_zero(lf->last_ref_deltas);
283 vp9_zero(lf->last_mode_deltas);
285 set_default_lf_deltas(lf);
286 }
288 static void dealloc_compressor_data(VP9_COMP *cpi) {
289 // Delete sementation map
290 vpx_free(cpi->segmentation_map);
291 cpi->segmentation_map = 0;
292 vpx_free(cpi->common.last_frame_seg_map);
293 cpi->common.last_frame_seg_map = 0;
294 vpx_free(cpi->coding_context.last_frame_seg_map_copy);
295 cpi->coding_context.last_frame_seg_map_copy = 0;
297 vpx_free(cpi->active_map);
298 cpi->active_map = 0;
300 vp9_free_frame_buffers(&cpi->common);
302 vp9_free_frame_buffer(&cpi->last_frame_uf);
303 vp9_free_frame_buffer(&cpi->scaled_source);
304 vp9_free_frame_buffer(&cpi->alt_ref_buffer);
305 vp9_lookahead_destroy(cpi->lookahead);
307 vpx_free(cpi->tok);
308 cpi->tok = 0;
310 // Activity mask based per mb zbin adjustments
311 vpx_free(cpi->mb_activity_map);
312 cpi->mb_activity_map = 0;
313 vpx_free(cpi->mb_norm_activity_map);
314 cpi->mb_norm_activity_map = 0;
316 vpx_free(cpi->above_context[0]);
317 cpi->above_context[0] = NULL;
319 vpx_free(cpi->above_seg_context);
320 cpi->above_seg_context = NULL;
321 }
323 // Computes a q delta (in "q index" terms) to get from a starting q value
324 // to a target value
325 // target q value
326 int vp9_compute_qdelta(VP9_COMP *cpi, double qstart, double qtarget) {
327 int i;
328 int start_index = cpi->worst_quality;
329 int target_index = cpi->worst_quality;
331 // Convert the average q value to an index.
332 for (i = cpi->best_quality; i < cpi->worst_quality; i++) {
333 start_index = i;
334 if (vp9_convert_qindex_to_q(i) >= qstart)
335 break;
336 }
338 // Convert the q target to an index
339 for (i = cpi->best_quality; i < cpi->worst_quality; i++) {
340 target_index = i;
341 if (vp9_convert_qindex_to_q(i) >= qtarget)
342 break;
343 }
345 return target_index - start_index;
346 }
348 static void configure_static_seg_features(VP9_COMP *cpi) {
349 VP9_COMMON *cm = &cpi->common;
350 struct segmentation *seg = &cm->seg;
352 int high_q = (int)(cpi->avg_q > 48.0);
353 int qi_delta;
355 // Disable and clear down for KF
356 if (cm->frame_type == KEY_FRAME) {
357 // Clear down the global segmentation map
358 vpx_memset(cpi->segmentation_map, 0, cm->mi_rows * cm->mi_cols);
359 seg->update_map = 0;
360 seg->update_data = 0;
361 cpi->static_mb_pct = 0;
363 // Disable segmentation
364 vp9_disable_segmentation((VP9_PTR)cpi);
366 // Clear down the segment features.
367 vp9_clearall_segfeatures(seg);
368 } else if (cpi->refresh_alt_ref_frame) {
369 // If this is an alt ref frame
370 // Clear down the global segmentation map
371 vpx_memset(cpi->segmentation_map, 0, cm->mi_rows * cm->mi_cols);
372 seg->update_map = 0;
373 seg->update_data = 0;
374 cpi->static_mb_pct = 0;
376 // Disable segmentation and individual segment features by default
377 vp9_disable_segmentation((VP9_PTR)cpi);
378 vp9_clearall_segfeatures(seg);
380 // Scan frames from current to arf frame.
381 // This function re-enables segmentation if appropriate.
382 vp9_update_mbgraph_stats(cpi);
384 // If segmentation was enabled set those features needed for the
385 // arf itself.
386 if (seg->enabled) {
387 seg->update_map = 1;
388 seg->update_data = 1;
390 qi_delta = vp9_compute_qdelta(cpi, cpi->avg_q, (cpi->avg_q * 0.875));
391 vp9_set_segdata(seg, 1, SEG_LVL_ALT_Q, (qi_delta - 2));
392 vp9_set_segdata(seg, 1, SEG_LVL_ALT_LF, -2);
394 vp9_enable_segfeature(seg, 1, SEG_LVL_ALT_Q);
395 vp9_enable_segfeature(seg, 1, SEG_LVL_ALT_LF);
397 // Where relevant assume segment data is delta data
398 seg->abs_delta = SEGMENT_DELTADATA;
399 }
400 } else if (seg->enabled) {
401 // All other frames if segmentation has been enabled
403 // First normal frame in a valid gf or alt ref group
404 if (cpi->frames_since_golden == 0) {
405 // Set up segment features for normal frames in an arf group
406 if (cpi->source_alt_ref_active) {
407 seg->update_map = 0;
408 seg->update_data = 1;
409 seg->abs_delta = SEGMENT_DELTADATA;
411 qi_delta = vp9_compute_qdelta(cpi, cpi->avg_q,
412 (cpi->avg_q * 1.125));
413 vp9_set_segdata(seg, 1, SEG_LVL_ALT_Q, (qi_delta + 2));
414 vp9_enable_segfeature(seg, 1, SEG_LVL_ALT_Q);
416 vp9_set_segdata(seg, 1, SEG_LVL_ALT_LF, -2);
417 vp9_enable_segfeature(seg, 1, SEG_LVL_ALT_LF);
419 // Segment coding disabled for compred testing
420 if (high_q || (cpi->static_mb_pct == 100)) {
421 vp9_set_segdata(seg, 1, SEG_LVL_REF_FRAME, ALTREF_FRAME);
422 vp9_enable_segfeature(seg, 1, SEG_LVL_REF_FRAME);
423 vp9_enable_segfeature(seg, 1, SEG_LVL_SKIP);
424 }
425 } else {
426 // Disable segmentation and clear down features if alt ref
427 // is not active for this group
429 vp9_disable_segmentation((VP9_PTR)cpi);
431 vpx_memset(cpi->segmentation_map, 0, cm->mi_rows * cm->mi_cols);
433 seg->update_map = 0;
434 seg->update_data = 0;
436 vp9_clearall_segfeatures(seg);
437 }
438 } else if (cpi->is_src_frame_alt_ref) {
439 // Special case where we are coding over the top of a previous
440 // alt ref frame.
441 // Segment coding disabled for compred testing
443 // Enable ref frame features for segment 0 as well
444 vp9_enable_segfeature(seg, 0, SEG_LVL_REF_FRAME);
445 vp9_enable_segfeature(seg, 1, SEG_LVL_REF_FRAME);
447 // All mbs should use ALTREF_FRAME
448 vp9_clear_segdata(seg, 0, SEG_LVL_REF_FRAME);
449 vp9_set_segdata(seg, 0, SEG_LVL_REF_FRAME, ALTREF_FRAME);
450 vp9_clear_segdata(seg, 1, SEG_LVL_REF_FRAME);
451 vp9_set_segdata(seg, 1, SEG_LVL_REF_FRAME, ALTREF_FRAME);
453 // Skip all MBs if high Q (0,0 mv and skip coeffs)
454 if (high_q) {
455 vp9_enable_segfeature(seg, 0, SEG_LVL_SKIP);
456 vp9_enable_segfeature(seg, 1, SEG_LVL_SKIP);
457 }
458 // Enable data update
459 seg->update_data = 1;
460 } else {
461 // All other frames.
463 // No updates.. leave things as they are.
464 seg->update_map = 0;
465 seg->update_data = 0;
466 }
467 }
468 }
470 #ifdef ENTROPY_STATS
471 void vp9_update_mode_context_stats(VP9_COMP *cpi) {
472 VP9_COMMON *cm = &cpi->common;
473 int i, j;
474 unsigned int (*inter_mode_counts)[INTER_MODES - 1][2] =
475 cm->fc.inter_mode_counts;
476 int64_t (*mv_ref_stats)[INTER_MODES - 1][2] = cpi->mv_ref_stats;
477 FILE *f;
479 // Read the past stats counters
480 f = fopen("mode_context.bin", "rb");
481 if (!f) {
482 vpx_memset(cpi->mv_ref_stats, 0, sizeof(cpi->mv_ref_stats));
483 } else {
484 fread(cpi->mv_ref_stats, sizeof(cpi->mv_ref_stats), 1, f);
485 fclose(f);
486 }
488 // Add in the values for this frame
489 for (i = 0; i < INTER_MODE_CONTEXTS; i++) {
490 for (j = 0; j < INTER_MODES - 1; j++) {
491 mv_ref_stats[i][j][0] += (int64_t)inter_mode_counts[i][j][0];
492 mv_ref_stats[i][j][1] += (int64_t)inter_mode_counts[i][j][1];
493 }
494 }
496 // Write back the accumulated stats
497 f = fopen("mode_context.bin", "wb");
498 fwrite(cpi->mv_ref_stats, sizeof(cpi->mv_ref_stats), 1, f);
499 fclose(f);
500 }
502 void print_mode_context(VP9_COMP *cpi) {
503 FILE *f = fopen("vp9_modecont.c", "a");
504 int i, j;
506 fprintf(f, "#include \"vp9_entropy.h\"\n");
507 fprintf(
508 f,
509 "const int inter_mode_probs[INTER_MODE_CONTEXTS][INTER_MODES - 1] =");
510 fprintf(f, "{\n");
511 for (j = 0; j < INTER_MODE_CONTEXTS; j++) {
512 fprintf(f, " {/* %d */ ", j);
513 fprintf(f, " ");
514 for (i = 0; i < INTER_MODES - 1; i++) {
515 int this_prob;
516 int64_t count = cpi->mv_ref_stats[j][i][0] + cpi->mv_ref_stats[j][i][1];
517 if (count)
518 this_prob = ((cpi->mv_ref_stats[j][i][0] * 256) + (count >> 1)) / count;
519 else
520 this_prob = 128;
522 // context probs
523 fprintf(f, "%5d, ", this_prob);
524 }
525 fprintf(f, " },\n");
526 }
528 fprintf(f, "};\n");
529 fclose(f);
530 }
531 #endif // ENTROPY_STATS
533 // DEBUG: Print out the segment id of each MB in the current frame.
534 static void print_seg_map(VP9_COMP *cpi) {
535 VP9_COMMON *cm = &cpi->common;
536 int row, col;
537 int map_index = 0;
538 FILE *statsfile = fopen("segmap.stt", "a");
540 fprintf(statsfile, "%10d\n", cm->current_video_frame);
542 for (row = 0; row < cpi->common.mi_rows; row++) {
543 for (col = 0; col < cpi->common.mi_cols; col++) {
544 fprintf(statsfile, "%10d", cpi->segmentation_map[map_index]);
545 map_index++;
546 }
547 fprintf(statsfile, "\n");
548 }
549 fprintf(statsfile, "\n");
551 fclose(statsfile);
552 }
554 static void update_reference_segmentation_map(VP9_COMP *cpi) {
555 VP9_COMMON *const cm = &cpi->common;
556 int row, col;
557 MODE_INFO **mi_8x8, **mi_8x8_ptr = cm->mi_grid_visible;
558 uint8_t *cache_ptr = cm->last_frame_seg_map, *cache;
560 for (row = 0; row < cm->mi_rows; row++) {
561 mi_8x8 = mi_8x8_ptr;
562 cache = cache_ptr;
563 for (col = 0; col < cm->mi_cols; col++, mi_8x8++, cache++)
564 cache[0] = mi_8x8[0]->mbmi.segment_id;
565 mi_8x8_ptr += cm->mode_info_stride;
566 cache_ptr += cm->mi_cols;
567 }
568 }
570 static void set_default_lf_deltas(struct loopfilter *lf) {
571 lf->mode_ref_delta_enabled = 1;
572 lf->mode_ref_delta_update = 1;
574 vp9_zero(lf->ref_deltas);
575 vp9_zero(lf->mode_deltas);
577 // Test of ref frame deltas
578 lf->ref_deltas[INTRA_FRAME] = 2;
579 lf->ref_deltas[LAST_FRAME] = 0;
580 lf->ref_deltas[GOLDEN_FRAME] = -2;
581 lf->ref_deltas[ALTREF_FRAME] = -2;
583 lf->mode_deltas[0] = 0; // Zero
584 lf->mode_deltas[1] = 0; // New mv
585 }
587 static void set_rd_speed_thresholds(VP9_COMP *cpi, int mode) {
588 SPEED_FEATURES *sf = &cpi->sf;
589 int i;
591 // Set baseline threshold values
592 for (i = 0; i < MAX_MODES; ++i)
593 sf->thresh_mult[i] = mode == 0 ? -500 : 0;
595 sf->thresh_mult[THR_NEARESTMV] = 0;
596 sf->thresh_mult[THR_NEARESTG] = 0;
597 sf->thresh_mult[THR_NEARESTA] = 0;
599 sf->thresh_mult[THR_DC] += 1000;
601 sf->thresh_mult[THR_NEWMV] += 1000;
602 sf->thresh_mult[THR_NEWA] += 1000;
603 sf->thresh_mult[THR_NEWG] += 1000;
605 sf->thresh_mult[THR_NEARMV] += 1000;
606 sf->thresh_mult[THR_NEARA] += 1000;
607 sf->thresh_mult[THR_COMP_NEARESTLA] += 1000;
608 sf->thresh_mult[THR_COMP_NEARESTGA] += 1000;
610 sf->thresh_mult[THR_TM] += 1000;
612 sf->thresh_mult[THR_COMP_NEARLA] += 1500;
613 sf->thresh_mult[THR_COMP_NEWLA] += 2000;
614 sf->thresh_mult[THR_NEARG] += 1000;
615 sf->thresh_mult[THR_COMP_NEARGA] += 1500;
616 sf->thresh_mult[THR_COMP_NEWGA] += 2000;
618 sf->thresh_mult[THR_ZEROMV] += 2000;
619 sf->thresh_mult[THR_ZEROG] += 2000;
620 sf->thresh_mult[THR_ZEROA] += 2000;
621 sf->thresh_mult[THR_COMP_ZEROLA] += 2500;
622 sf->thresh_mult[THR_COMP_ZEROGA] += 2500;
624 sf->thresh_mult[THR_H_PRED] += 2000;
625 sf->thresh_mult[THR_V_PRED] += 2000;
626 sf->thresh_mult[THR_D45_PRED ] += 2500;
627 sf->thresh_mult[THR_D135_PRED] += 2500;
628 sf->thresh_mult[THR_D117_PRED] += 2500;
629 sf->thresh_mult[THR_D153_PRED] += 2500;
630 sf->thresh_mult[THR_D207_PRED] += 2500;
631 sf->thresh_mult[THR_D63_PRED] += 2500;
633 /* disable frame modes if flags not set */
634 if (!(cpi->ref_frame_flags & VP9_LAST_FLAG)) {
635 sf->thresh_mult[THR_NEWMV ] = INT_MAX;
636 sf->thresh_mult[THR_NEARESTMV] = INT_MAX;
637 sf->thresh_mult[THR_ZEROMV ] = INT_MAX;
638 sf->thresh_mult[THR_NEARMV ] = INT_MAX;
639 }
640 if (!(cpi->ref_frame_flags & VP9_GOLD_FLAG)) {
641 sf->thresh_mult[THR_NEARESTG ] = INT_MAX;
642 sf->thresh_mult[THR_ZEROG ] = INT_MAX;
643 sf->thresh_mult[THR_NEARG ] = INT_MAX;
644 sf->thresh_mult[THR_NEWG ] = INT_MAX;
645 }
646 if (!(cpi->ref_frame_flags & VP9_ALT_FLAG)) {
647 sf->thresh_mult[THR_NEARESTA ] = INT_MAX;
648 sf->thresh_mult[THR_ZEROA ] = INT_MAX;
649 sf->thresh_mult[THR_NEARA ] = INT_MAX;
650 sf->thresh_mult[THR_NEWA ] = INT_MAX;
651 }
653 if ((cpi->ref_frame_flags & (VP9_LAST_FLAG | VP9_ALT_FLAG)) !=
654 (VP9_LAST_FLAG | VP9_ALT_FLAG)) {
655 sf->thresh_mult[THR_COMP_ZEROLA ] = INT_MAX;
656 sf->thresh_mult[THR_COMP_NEARESTLA] = INT_MAX;
657 sf->thresh_mult[THR_COMP_NEARLA ] = INT_MAX;
658 sf->thresh_mult[THR_COMP_NEWLA ] = INT_MAX;
659 }
660 if ((cpi->ref_frame_flags & (VP9_GOLD_FLAG | VP9_ALT_FLAG)) !=
661 (VP9_GOLD_FLAG | VP9_ALT_FLAG)) {
662 sf->thresh_mult[THR_COMP_ZEROGA ] = INT_MAX;
663 sf->thresh_mult[THR_COMP_NEARESTGA] = INT_MAX;
664 sf->thresh_mult[THR_COMP_NEARGA ] = INT_MAX;
665 sf->thresh_mult[THR_COMP_NEWGA ] = INT_MAX;
666 }
667 }
669 static void set_rd_speed_thresholds_sub8x8(VP9_COMP *cpi, int mode) {
670 SPEED_FEATURES *sf = &cpi->sf;
671 int i;
673 for (i = 0; i < MAX_REFS; ++i)
674 sf->thresh_mult_sub8x8[i] = mode == 0 ? -500 : 0;
676 sf->thresh_mult_sub8x8[THR_LAST] += 2500;
677 sf->thresh_mult_sub8x8[THR_GOLD] += 2500;
678 sf->thresh_mult_sub8x8[THR_ALTR] += 2500;
679 sf->thresh_mult_sub8x8[THR_INTRA] += 2500;
680 sf->thresh_mult_sub8x8[THR_COMP_LA] += 4500;
681 sf->thresh_mult_sub8x8[THR_COMP_GA] += 4500;
683 // Check for masked out split cases.
684 for (i = 0; i < MAX_REFS; i++) {
685 if (sf->disable_split_mask & (1 << i))
686 sf->thresh_mult_sub8x8[i] = INT_MAX;
687 }
689 // disable mode test if frame flag is not set
690 if (!(cpi->ref_frame_flags & VP9_LAST_FLAG))
691 sf->thresh_mult_sub8x8[THR_LAST] = INT_MAX;
692 if (!(cpi->ref_frame_flags & VP9_GOLD_FLAG))
693 sf->thresh_mult_sub8x8[THR_GOLD] = INT_MAX;
694 if (!(cpi->ref_frame_flags & VP9_ALT_FLAG))
695 sf->thresh_mult_sub8x8[THR_ALTR] = INT_MAX;
696 if ((cpi->ref_frame_flags & (VP9_LAST_FLAG | VP9_ALT_FLAG)) !=
697 (VP9_LAST_FLAG | VP9_ALT_FLAG))
698 sf->thresh_mult_sub8x8[THR_COMP_LA] = INT_MAX;
699 if ((cpi->ref_frame_flags & (VP9_GOLD_FLAG | VP9_ALT_FLAG)) !=
700 (VP9_GOLD_FLAG | VP9_ALT_FLAG))
701 sf->thresh_mult_sub8x8[THR_COMP_GA] = INT_MAX;
702 }
704 void vp9_set_speed_features(VP9_COMP *cpi) {
705 SPEED_FEATURES *sf = &cpi->sf;
706 int mode = cpi->compressor_speed;
707 int speed = cpi->speed;
708 int i;
710 // Only modes 0 and 1 supported for now in experimental code basae
711 if (mode > 1)
712 mode = 1;
714 for (i = 0; i < MAX_MODES; ++i)
715 cpi->mode_chosen_counts[i] = 0;
717 // best quality defaults
718 sf->RD = 1;
719 sf->search_method = NSTEP;
720 sf->auto_filter = 1;
721 sf->recode_loop = 1;
722 sf->subpel_search_method = SUBPEL_TREE;
723 sf->subpel_iters_per_step = 2;
724 sf->optimize_coefficients = !cpi->oxcf.lossless;
725 sf->reduce_first_step_size = 0;
726 sf->auto_mv_step_size = 0;
727 sf->max_step_search_steps = MAX_MVSEARCH_STEPS;
728 sf->comp_inter_joint_search_thresh = BLOCK_4X4;
729 sf->adaptive_rd_thresh = 0;
730 sf->use_lastframe_partitioning = LAST_FRAME_PARTITION_OFF;
731 sf->tx_size_search_method = USE_FULL_RD;
732 sf->use_lp32x32fdct = 0;
733 sf->adaptive_motion_search = 0;
734 sf->use_avoid_tested_higherror = 0;
735 sf->reference_masking = 0;
736 sf->use_one_partition_size_always = 0;
737 sf->less_rectangular_check = 0;
738 sf->use_square_partition_only = 0;
739 sf->auto_min_max_partition_size = 0;
740 sf->max_partition_size = BLOCK_64X64;
741 sf->min_partition_size = BLOCK_4X4;
742 sf->adjust_partitioning_from_last_frame = 0;
743 sf->last_partitioning_redo_frequency = 4;
744 sf->disable_split_mask = 0;
745 sf->mode_search_skip_flags = 0;
746 sf->disable_split_var_thresh = 0;
747 sf->disable_filter_search_var_thresh = 0;
748 for (i = 0; i < TX_SIZES; i++) {
749 sf->intra_y_mode_mask[i] = ALL_INTRA_MODES;
750 sf->intra_uv_mode_mask[i] = ALL_INTRA_MODES;
751 }
752 sf->use_rd_breakout = 0;
753 sf->skip_encode_sb = 0;
754 sf->use_uv_intra_rd_estimate = 0;
755 sf->use_fast_lpf_pick = 0;
756 sf->use_fast_coef_updates = 0;
757 sf->using_small_partition_info = 0;
758 sf->mode_skip_start = MAX_MODES; // Mode index at which mode skip mask set
760 #if CONFIG_MULTIPLE_ARF
761 // Switch segmentation off.
762 sf->static_segmentation = 0;
763 #else
764 sf->static_segmentation = 0;
765 #endif
767 switch (mode) {
768 case 0: // This is the best quality mode.
769 break;
771 case 1:
772 #if CONFIG_MULTIPLE_ARF
773 // Switch segmentation off.
774 sf->static_segmentation = 0;
775 #else
776 sf->static_segmentation = 0;
777 #endif
778 sf->use_avoid_tested_higherror = 1;
779 sf->adaptive_rd_thresh = 1;
780 sf->recode_loop = (speed < 1);
782 if (speed == 1) {
783 sf->use_square_partition_only = !frame_is_intra_only(&cpi->common);
784 sf->less_rectangular_check = 1;
785 sf->tx_size_search_method = frame_is_intra_only(&cpi->common)
786 ? USE_FULL_RD : USE_LARGESTALL;
788 if (MIN(cpi->common.width, cpi->common.height) >= 720)
789 sf->disable_split_mask = cpi->common.show_frame ?
790 DISABLE_ALL_SPLIT : DISABLE_ALL_INTER_SPLIT;
791 else
792 sf->disable_split_mask = DISABLE_COMPOUND_SPLIT;
794 sf->use_rd_breakout = 1;
795 sf->adaptive_motion_search = 1;
796 sf->auto_mv_step_size = 1;
797 sf->adaptive_rd_thresh = 2;
798 sf->recode_loop = 2;
799 sf->intra_y_mode_mask[TX_32X32] = INTRA_DC_H_V;
800 sf->intra_uv_mode_mask[TX_32X32] = INTRA_DC_H_V;
801 sf->intra_uv_mode_mask[TX_16X16] = INTRA_DC_H_V;
802 }
803 if (speed == 2) {
804 sf->use_square_partition_only = !frame_is_intra_only(&cpi->common);
805 sf->less_rectangular_check = 1;
806 sf->tx_size_search_method = frame_is_intra_only(&cpi->common)
807 ? USE_FULL_RD : USE_LARGESTALL;
809 if (MIN(cpi->common.width, cpi->common.height) >= 720)
810 sf->disable_split_mask = cpi->common.show_frame ?
811 DISABLE_ALL_SPLIT : DISABLE_ALL_INTER_SPLIT;
812 else
813 sf->disable_split_mask = LAST_AND_INTRA_SPLIT_ONLY;
816 sf->mode_search_skip_flags = FLAG_SKIP_INTRA_DIRMISMATCH |
817 FLAG_SKIP_INTRA_BESTINTER |
818 FLAG_SKIP_COMP_BESTINTRA |
819 FLAG_SKIP_INTRA_LOWVAR;
821 sf->use_rd_breakout = 1;
822 sf->adaptive_motion_search = 1;
823 sf->auto_mv_step_size = 1;
825 sf->disable_filter_search_var_thresh = 16;
826 sf->comp_inter_joint_search_thresh = BLOCK_SIZES;
828 sf->auto_min_max_partition_size = 1;
829 sf->use_lastframe_partitioning = LAST_FRAME_PARTITION_LOW_MOTION;
830 sf->adjust_partitioning_from_last_frame = 1;
831 sf->last_partitioning_redo_frequency = 3;
833 sf->adaptive_rd_thresh = 2;
834 sf->recode_loop = 2;
835 sf->use_lp32x32fdct = 1;
836 sf->mode_skip_start = 11;
837 sf->intra_y_mode_mask[TX_32X32] = INTRA_DC_H_V;
838 sf->intra_y_mode_mask[TX_16X16] = INTRA_DC_H_V;
839 sf->intra_uv_mode_mask[TX_32X32] = INTRA_DC_H_V;
840 sf->intra_uv_mode_mask[TX_16X16] = INTRA_DC_H_V;
841 }
842 if (speed == 3) {
843 sf->use_square_partition_only = 1;
844 sf->tx_size_search_method = USE_LARGESTALL;
846 if (MIN(cpi->common.width, cpi->common.height) >= 720)
847 sf->disable_split_mask = DISABLE_ALL_SPLIT;
848 else
849 sf->disable_split_mask = DISABLE_ALL_INTER_SPLIT;
851 sf->mode_search_skip_flags = FLAG_SKIP_INTRA_DIRMISMATCH |
852 FLAG_SKIP_INTRA_BESTINTER |
853 FLAG_SKIP_COMP_BESTINTRA |
854 FLAG_SKIP_INTRA_LOWVAR;
856 sf->use_rd_breakout = 1;
857 sf->adaptive_motion_search = 1;
858 sf->auto_mv_step_size = 1;
860 sf->disable_filter_search_var_thresh = 16;
861 sf->comp_inter_joint_search_thresh = BLOCK_SIZES;
863 sf->auto_min_max_partition_size = 1;
864 sf->use_lastframe_partitioning = LAST_FRAME_PARTITION_ALL;
865 sf->adjust_partitioning_from_last_frame = 1;
866 sf->last_partitioning_redo_frequency = 3;
868 sf->use_uv_intra_rd_estimate = 1;
869 sf->skip_encode_sb = 1;
870 sf->use_lp32x32fdct = 1;
871 sf->subpel_iters_per_step = 1;
872 sf->use_fast_coef_updates = 2;
874 sf->adaptive_rd_thresh = 4;
875 sf->mode_skip_start = 6;
876 }
877 if (speed == 4) {
878 sf->use_square_partition_only = 1;
879 sf->tx_size_search_method = USE_LARGESTALL;
880 sf->disable_split_mask = DISABLE_ALL_SPLIT;
882 sf->mode_search_skip_flags = FLAG_SKIP_INTRA_DIRMISMATCH |
883 FLAG_SKIP_INTRA_BESTINTER |
884 FLAG_SKIP_COMP_BESTINTRA |
885 FLAG_SKIP_COMP_REFMISMATCH |
886 FLAG_SKIP_INTRA_LOWVAR |
887 FLAG_EARLY_TERMINATE;
889 sf->use_rd_breakout = 1;
890 sf->adaptive_motion_search = 1;
891 sf->auto_mv_step_size = 1;
893 sf->disable_filter_search_var_thresh = 16;
894 sf->comp_inter_joint_search_thresh = BLOCK_SIZES;
896 sf->auto_min_max_partition_size = 1;
897 sf->use_lastframe_partitioning = LAST_FRAME_PARTITION_ALL;
898 sf->adjust_partitioning_from_last_frame = 1;
899 sf->last_partitioning_redo_frequency = 3;
901 sf->use_uv_intra_rd_estimate = 1;
902 sf->skip_encode_sb = 1;
903 sf->use_lp32x32fdct = 1;
904 sf->subpel_iters_per_step = 1;
905 sf->use_fast_coef_updates = 2;
907 sf->adaptive_rd_thresh = 4;
908 sf->mode_skip_start = 6;
910 /* sf->intra_y_mode_mask = INTRA_DC_ONLY;
911 sf->intra_uv_mode_mask = INTRA_DC_ONLY;
912 sf->search_method = BIGDIA;
913 sf->disable_split_var_thresh = 64;
914 sf->disable_filter_search_var_thresh = 64; */
915 }
916 if (speed == 5) {
917 sf->comp_inter_joint_search_thresh = BLOCK_SIZES;
918 sf->use_one_partition_size_always = 1;
919 sf->always_this_block_size = BLOCK_16X16;
920 sf->tx_size_search_method = frame_is_intra_only(&cpi->common) ?
921 USE_FULL_RD : USE_LARGESTALL;
922 sf->mode_search_skip_flags = FLAG_SKIP_INTRA_DIRMISMATCH |
923 FLAG_SKIP_INTRA_BESTINTER |
924 FLAG_SKIP_COMP_BESTINTRA |
925 FLAG_SKIP_COMP_REFMISMATCH |
926 FLAG_SKIP_INTRA_LOWVAR |
927 FLAG_EARLY_TERMINATE;
928 sf->use_rd_breakout = 1;
929 sf->use_lp32x32fdct = 1;
930 sf->optimize_coefficients = 0;
931 sf->auto_mv_step_size = 1;
932 // sf->reduce_first_step_size = 1;
933 // sf->reference_masking = 1;
935 sf->disable_split_mask = DISABLE_ALL_SPLIT;
936 sf->search_method = HEX;
937 sf->subpel_iters_per_step = 1;
938 sf->disable_split_var_thresh = 64;
939 sf->disable_filter_search_var_thresh = 96;
940 for (i = 0; i < TX_SIZES; i++) {
941 sf->intra_y_mode_mask[i] = INTRA_DC_ONLY;
942 sf->intra_uv_mode_mask[i] = INTRA_DC_ONLY;
943 }
944 sf->use_fast_coef_updates = 2;
945 sf->adaptive_rd_thresh = 4;
946 sf->mode_skip_start = 6;
947 }
948 break;
949 }; /* switch */
951 // Set rd thresholds based on mode and speed setting
952 set_rd_speed_thresholds(cpi, mode);
953 set_rd_speed_thresholds_sub8x8(cpi, mode);
955 // Slow quant, dct and trellis not worthwhile for first pass
956 // so make sure they are always turned off.
957 if (cpi->pass == 1) {
958 sf->optimize_coefficients = 0;
959 }
961 // No recode for 1 pass.
962 if (cpi->pass == 0) {
963 sf->recode_loop = 0;
964 sf->optimize_coefficients = 0;
965 }
967 cpi->mb.fwd_txm4x4 = vp9_fdct4x4;
968 if (cpi->oxcf.lossless || cpi->mb.e_mbd.lossless) {
969 cpi->mb.fwd_txm4x4 = vp9_fwht4x4;
970 }
972 if (cpi->sf.subpel_search_method == SUBPEL_ITERATIVE) {
973 cpi->find_fractional_mv_step = vp9_find_best_sub_pixel_iterative;
974 cpi->find_fractional_mv_step_comp = vp9_find_best_sub_pixel_comp_iterative;
975 } else if (cpi->sf.subpel_search_method == SUBPEL_TREE) {
976 cpi->find_fractional_mv_step = vp9_find_best_sub_pixel_tree;
977 cpi->find_fractional_mv_step_comp = vp9_find_best_sub_pixel_comp_tree;
978 }
980 cpi->mb.optimize = cpi->sf.optimize_coefficients == 1 && cpi->pass != 1;
982 #ifdef SPEEDSTATS
983 frames_at_speed[cpi->speed]++;
984 #endif
985 }
987 static void alloc_raw_frame_buffers(VP9_COMP *cpi) {
988 VP9_COMMON *cm = &cpi->common;
990 cpi->lookahead = vp9_lookahead_init(cpi->oxcf.width, cpi->oxcf.height,
991 cm->subsampling_x, cm->subsampling_y,
992 cpi->oxcf.lag_in_frames);
993 if (!cpi->lookahead)
994 vpx_internal_error(&cpi->common.error, VPX_CODEC_MEM_ERROR,
995 "Failed to allocate lag buffers");
997 if (vp9_realloc_frame_buffer(&cpi->alt_ref_buffer,
998 cpi->oxcf.width, cpi->oxcf.height,
999 cm->subsampling_x, cm->subsampling_y,
1000 VP9BORDERINPIXELS))
1001 vpx_internal_error(&cpi->common.error, VPX_CODEC_MEM_ERROR,
1002 "Failed to allocate altref buffer");
1003 }
1005 void vp9_alloc_compressor_data(VP9_COMP *cpi) {
1006 VP9_COMMON *cm = &cpi->common;
1008 if (vp9_alloc_frame_buffers(cm, cm->width, cm->height))
1009 vpx_internal_error(&cpi->common.error, VPX_CODEC_MEM_ERROR,
1010 "Failed to allocate frame buffers");
1012 if (vp9_alloc_frame_buffer(&cpi->last_frame_uf,
1013 cm->width, cm->height,
1014 cm->subsampling_x, cm->subsampling_y,
1015 VP9BORDERINPIXELS))
1016 vpx_internal_error(&cpi->common.error, VPX_CODEC_MEM_ERROR,
1017 "Failed to allocate last frame buffer");
1019 if (vp9_alloc_frame_buffer(&cpi->scaled_source,
1020 cm->width, cm->height,
1021 cm->subsampling_x, cm->subsampling_y,
1022 VP9BORDERINPIXELS))
1023 vpx_internal_error(&cpi->common.error, VPX_CODEC_MEM_ERROR,
1024 "Failed to allocate scaled source buffer");
1026 vpx_free(cpi->tok);
1028 {
1029 unsigned int tokens = get_token_alloc(cm->mb_rows, cm->mb_cols);
1031 CHECK_MEM_ERROR(cm, cpi->tok, vpx_calloc(tokens, sizeof(*cpi->tok)));
1032 }
1034 vpx_free(cpi->mb_activity_map);
1035 CHECK_MEM_ERROR(cm, cpi->mb_activity_map,
1036 vpx_calloc(sizeof(unsigned int),
1037 cm->mb_rows * cm->mb_cols));
1039 vpx_free(cpi->mb_norm_activity_map);
1040 CHECK_MEM_ERROR(cm, cpi->mb_norm_activity_map,
1041 vpx_calloc(sizeof(unsigned int),
1042 cm->mb_rows * cm->mb_cols));
1044 // 2 contexts per 'mi unit', so that we have one context per 4x4 txfm
1045 // block where mi unit size is 8x8.
1046 vpx_free(cpi->above_context[0]);
1047 CHECK_MEM_ERROR(cm, cpi->above_context[0],
1048 vpx_calloc(2 * mi_cols_aligned_to_sb(cm->mi_cols) *
1049 MAX_MB_PLANE,
1050 sizeof(*cpi->above_context[0])));
1052 vpx_free(cpi->above_seg_context);
1053 CHECK_MEM_ERROR(cm, cpi->above_seg_context,
1054 vpx_calloc(mi_cols_aligned_to_sb(cm->mi_cols),
1055 sizeof(*cpi->above_seg_context)));
1056 }
1059 static void update_frame_size(VP9_COMP *cpi) {
1060 VP9_COMMON *cm = &cpi->common;
1062 vp9_update_frame_size(cm);
1064 // Update size of buffers local to this frame
1065 if (vp9_realloc_frame_buffer(&cpi->last_frame_uf,
1066 cm->width, cm->height,
1067 cm->subsampling_x, cm->subsampling_y,
1068 VP9BORDERINPIXELS))
1069 vpx_internal_error(&cpi->common.error, VPX_CODEC_MEM_ERROR,
1070 "Failed to reallocate last frame buffer");
1072 if (vp9_realloc_frame_buffer(&cpi->scaled_source,
1073 cm->width, cm->height,
1074 cm->subsampling_x, cm->subsampling_y,
1075 VP9BORDERINPIXELS))
1076 vpx_internal_error(&cpi->common.error, VPX_CODEC_MEM_ERROR,
1077 "Failed to reallocate scaled source buffer");
1079 {
1080 int y_stride = cpi->scaled_source.y_stride;
1082 if (cpi->sf.search_method == NSTEP) {
1083 vp9_init3smotion_compensation(&cpi->mb, y_stride);
1084 } else if (cpi->sf.search_method == DIAMOND) {
1085 vp9_init_dsmotion_compensation(&cpi->mb, y_stride);
1086 }
1087 }
1089 {
1090 int i;
1091 for (i = 1; i < MAX_MB_PLANE; ++i) {
1092 cpi->above_context[i] = cpi->above_context[0] +
1093 i * sizeof(*cpi->above_context[0]) * 2 *
1094 mi_cols_aligned_to_sb(cm->mi_cols);
1095 }
1096 }
1097 }
1100 // Table that converts 0-63 Q range values passed in outside to the Qindex
1101 // range used internally.
1102 static const int q_trans[] = {
1103 0, 4, 8, 12, 16, 20, 24, 28,
1104 32, 36, 40, 44, 48, 52, 56, 60,
1105 64, 68, 72, 76, 80, 84, 88, 92,
1106 96, 100, 104, 108, 112, 116, 120, 124,
1107 128, 132, 136, 140, 144, 148, 152, 156,
1108 160, 164, 168, 172, 176, 180, 184, 188,
1109 192, 196, 200, 204, 208, 212, 216, 220,
1110 224, 228, 232, 236, 240, 244, 249, 255,
1111 };
1113 int vp9_reverse_trans(int x) {
1114 int i;
1116 for (i = 0; i < 64; i++)
1117 if (q_trans[i] >= x)
1118 return i;
1120 return 63;
1121 };
1122 void vp9_new_framerate(VP9_COMP *cpi, double framerate) {
1123 if (framerate < 0.1)
1124 framerate = 30;
1126 cpi->oxcf.framerate = framerate;
1127 cpi->output_framerate = cpi->oxcf.framerate;
1128 cpi->per_frame_bandwidth = (int)(cpi->oxcf.target_bandwidth
1129 / cpi->output_framerate);
1130 cpi->av_per_frame_bandwidth = (int)(cpi->oxcf.target_bandwidth
1131 / cpi->output_framerate);
1132 cpi->min_frame_bandwidth = (int)(cpi->av_per_frame_bandwidth *
1133 cpi->oxcf.two_pass_vbrmin_section / 100);
1136 cpi->min_frame_bandwidth = MAX(cpi->min_frame_bandwidth, FRAME_OVERHEAD_BITS);
1138 // Set Maximum gf/arf interval
1139 cpi->max_gf_interval = 16;
1141 // Extended interval for genuinely static scenes
1142 cpi->twopass.static_scene_max_gf_interval = cpi->key_frame_frequency >> 1;
1144 // Special conditions when alt ref frame enabled in lagged compress mode
1145 if (cpi->oxcf.play_alternate && cpi->oxcf.lag_in_frames) {
1146 if (cpi->max_gf_interval > cpi->oxcf.lag_in_frames - 1)
1147 cpi->max_gf_interval = cpi->oxcf.lag_in_frames - 1;
1149 if (cpi->twopass.static_scene_max_gf_interval > cpi->oxcf.lag_in_frames - 1)
1150 cpi->twopass.static_scene_max_gf_interval = cpi->oxcf.lag_in_frames - 1;
1151 }
1153 if (cpi->max_gf_interval > cpi->twopass.static_scene_max_gf_interval)
1154 cpi->max_gf_interval = cpi->twopass.static_scene_max_gf_interval;
1155 }
1157 static int64_t rescale(int val, int64_t num, int denom) {
1158 int64_t llnum = num;
1159 int64_t llden = denom;
1160 int64_t llval = val;
1162 return (llval * llnum / llden);
1163 }
1165 static void set_tile_limits(VP9_COMP *cpi) {
1166 VP9_COMMON *const cm = &cpi->common;
1168 int min_log2_tile_cols, max_log2_tile_cols;
1169 vp9_get_tile_n_bits(cm->mi_cols, &min_log2_tile_cols, &max_log2_tile_cols);
1171 cm->log2_tile_cols = clamp(cpi->oxcf.tile_columns,
1172 min_log2_tile_cols, max_log2_tile_cols);
1173 cm->log2_tile_rows = cpi->oxcf.tile_rows;
1174 }
1176 static void init_config(VP9_PTR ptr, VP9_CONFIG *oxcf) {
1177 VP9_COMP *cpi = (VP9_COMP *)(ptr);
1178 VP9_COMMON *const cm = &cpi->common;
1179 int i;
1181 cpi->oxcf = *oxcf;
1183 cm->version = oxcf->version;
1185 cm->width = oxcf->width;
1186 cm->height = oxcf->height;
1187 cm->subsampling_x = 0;
1188 cm->subsampling_y = 0;
1189 vp9_alloc_compressor_data(cpi);
1191 // change includes all joint functionality
1192 vp9_change_config(ptr, oxcf);
1194 // Initialize active best and worst q and average q values.
1195 cpi->active_worst_quality = cpi->oxcf.worst_allowed_q;
1196 cpi->active_best_quality = cpi->oxcf.best_allowed_q;
1197 cpi->avg_frame_qindex = cpi->oxcf.worst_allowed_q;
1199 // Initialise the starting buffer levels
1200 cpi->buffer_level = cpi->oxcf.starting_buffer_level;
1201 cpi->bits_off_target = cpi->oxcf.starting_buffer_level;
1203 cpi->rolling_target_bits = cpi->av_per_frame_bandwidth;
1204 cpi->rolling_actual_bits = cpi->av_per_frame_bandwidth;
1205 cpi->long_rolling_target_bits = cpi->av_per_frame_bandwidth;
1206 cpi->long_rolling_actual_bits = cpi->av_per_frame_bandwidth;
1208 cpi->total_actual_bits = 0;
1209 cpi->total_target_vs_actual = 0;
1211 cpi->static_mb_pct = 0;
1213 cpi->lst_fb_idx = 0;
1214 cpi->gld_fb_idx = 1;
1215 cpi->alt_fb_idx = 2;
1217 cpi->current_layer = 0;
1218 cpi->use_svc = 0;
1220 set_tile_limits(cpi);
1222 cpi->fixed_divide[0] = 0;
1223 for (i = 1; i < 512; i++)
1224 cpi->fixed_divide[i] = 0x80000 / i;
1225 }
1228 void vp9_change_config(VP9_PTR ptr, VP9_CONFIG *oxcf) {
1229 VP9_COMP *cpi = (VP9_COMP *)(ptr);
1230 VP9_COMMON *const cm = &cpi->common;
1232 if (!cpi || !oxcf)
1233 return;
1235 if (cm->version != oxcf->version) {
1236 cm->version = oxcf->version;
1237 }
1239 cpi->oxcf = *oxcf;
1241 switch (cpi->oxcf.Mode) {
1242 // Real time and one pass deprecated in test code base
1243 case MODE_GOODQUALITY:
1244 cpi->pass = 0;
1245 cpi->compressor_speed = 2;
1246 cpi->oxcf.cpu_used = clamp(cpi->oxcf.cpu_used, -5, 5);
1247 break;
1249 case MODE_FIRSTPASS:
1250 cpi->pass = 1;
1251 cpi->compressor_speed = 1;
1252 break;
1254 case MODE_SECONDPASS:
1255 cpi->pass = 2;
1256 cpi->compressor_speed = 1;
1257 cpi->oxcf.cpu_used = clamp(cpi->oxcf.cpu_used, -5, 5);
1258 break;
1260 case MODE_SECONDPASS_BEST:
1261 cpi->pass = 2;
1262 cpi->compressor_speed = 0;
1263 break;
1264 }
1266 cpi->oxcf.worst_allowed_q = q_trans[oxcf->worst_allowed_q];
1267 cpi->oxcf.best_allowed_q = q_trans[oxcf->best_allowed_q];
1268 cpi->oxcf.cq_level = q_trans[cpi->oxcf.cq_level];
1270 cpi->oxcf.lossless = oxcf->lossless;
1271 cpi->mb.e_mbd.itxm_add = cpi->oxcf.lossless ? vp9_iwht4x4_add
1272 : vp9_idct4x4_add;
1273 cpi->baseline_gf_interval = DEFAULT_GF_INTERVAL;
1275 cpi->ref_frame_flags = VP9_ALT_FLAG | VP9_GOLD_FLAG | VP9_LAST_FLAG;
1277 // cpi->use_golden_frame_only = 0;
1278 // cpi->use_last_frame_only = 0;
1279 cpi->refresh_golden_frame = 0;
1280 cpi->refresh_last_frame = 1;
1281 cm->refresh_frame_context = 1;
1282 cm->reset_frame_context = 0;
1284 setup_features(cm);
1285 cpi->common.allow_high_precision_mv = 0; // Default mv precision
1286 set_mvcost(cpi);
1288 {
1289 int i;
1291 for (i = 0; i < MAX_SEGMENTS; i++)
1292 cpi->segment_encode_breakout[i] = cpi->oxcf.encode_breakout;
1293 }
1295 // At the moment the first order values may not be > MAXQ
1296 cpi->oxcf.fixed_q = MIN(cpi->oxcf.fixed_q, MAXQ);
1298 // local file playback mode == really big buffer
1299 if (cpi->oxcf.end_usage == USAGE_LOCAL_FILE_PLAYBACK) {
1300 cpi->oxcf.starting_buffer_level = 60000;
1301 cpi->oxcf.optimal_buffer_level = 60000;
1302 cpi->oxcf.maximum_buffer_size = 240000;
1303 }
1305 // Convert target bandwidth from Kbit/s to Bit/s
1306 cpi->oxcf.target_bandwidth *= 1000;
1308 cpi->oxcf.starting_buffer_level = rescale(cpi->oxcf.starting_buffer_level,
1309 cpi->oxcf.target_bandwidth, 1000);
1311 // Set or reset optimal and maximum buffer levels.
1312 if (cpi->oxcf.optimal_buffer_level == 0)
1313 cpi->oxcf.optimal_buffer_level = cpi->oxcf.target_bandwidth / 8;
1314 else
1315 cpi->oxcf.optimal_buffer_level = rescale(cpi->oxcf.optimal_buffer_level,
1316 cpi->oxcf.target_bandwidth, 1000);
1318 if (cpi->oxcf.maximum_buffer_size == 0)
1319 cpi->oxcf.maximum_buffer_size = cpi->oxcf.target_bandwidth / 8;
1320 else
1321 cpi->oxcf.maximum_buffer_size = rescale(cpi->oxcf.maximum_buffer_size,
1322 cpi->oxcf.target_bandwidth, 1000);
1324 // Set up frame rate and related parameters rate control values.
1325 vp9_new_framerate(cpi, cpi->oxcf.framerate);
1327 // Set absolute upper and lower quality limits
1328 cpi->worst_quality = cpi->oxcf.worst_allowed_q;
1329 cpi->best_quality = cpi->oxcf.best_allowed_q;
1331 // active values should only be modified if out of new range
1332 cpi->active_worst_quality = clamp(cpi->active_worst_quality,
1333 cpi->oxcf.best_allowed_q,
1334 cpi->oxcf.worst_allowed_q);
1336 cpi->active_best_quality = clamp(cpi->active_best_quality,
1337 cpi->oxcf.best_allowed_q,
1338 cpi->oxcf.worst_allowed_q);
1340 cpi->buffered_mode = cpi->oxcf.optimal_buffer_level > 0;
1342 cpi->cq_target_quality = cpi->oxcf.cq_level;
1344 cm->mcomp_filter_type = DEFAULT_INTERP_FILTER;
1346 cpi->target_bandwidth = cpi->oxcf.target_bandwidth;
1348 cm->display_width = cpi->oxcf.width;
1349 cm->display_height = cpi->oxcf.height;
1351 // VP8 sharpness level mapping 0-7 (vs 0-10 in general VPx dialogs)
1352 cpi->oxcf.Sharpness = MIN(7, cpi->oxcf.Sharpness);
1354 cpi->common.lf.sharpness_level = cpi->oxcf.Sharpness;
1356 if (cpi->initial_width) {
1357 // Increasing the size of the frame beyond the first seen frame, or some
1358 // otherwise signalled maximum size, is not supported.
1359 // TODO(jkoleszar): exit gracefully.
1360 assert(cm->width <= cpi->initial_width);
1361 assert(cm->height <= cpi->initial_height);
1362 }
1363 update_frame_size(cpi);
1365 if (cpi->oxcf.fixed_q >= 0) {
1366 cpi->last_q[0] = cpi->oxcf.fixed_q;
1367 cpi->last_q[1] = cpi->oxcf.fixed_q;
1368 cpi->last_boosted_qindex = cpi->oxcf.fixed_q;
1369 }
1371 cpi->speed = cpi->oxcf.cpu_used;
1373 if (cpi->oxcf.lag_in_frames == 0) {
1374 // force to allowlag to 0 if lag_in_frames is 0;
1375 cpi->oxcf.allow_lag = 0;
1376 } else if (cpi->oxcf.lag_in_frames > MAX_LAG_BUFFERS) {
1377 // Limit on lag buffers as these are not currently dynamically allocated
1378 cpi->oxcf.lag_in_frames = MAX_LAG_BUFFERS;
1379 }
1381 // YX Temp
1382 #if CONFIG_MULTIPLE_ARF
1383 vp9_zero(cpi->alt_ref_source);
1384 #else
1385 cpi->alt_ref_source = NULL;
1386 #endif
1387 cpi->is_src_frame_alt_ref = 0;
1389 #if 0
1390 // Experimental RD Code
1391 cpi->frame_distortion = 0;
1392 cpi->last_frame_distortion = 0;
1393 #endif
1395 set_tile_limits(cpi);
1396 }
1398 #define M_LOG2_E 0.693147180559945309417
1399 #define log2f(x) (log (x) / (float) M_LOG2_E)
1401 static void cal_nmvjointsadcost(int *mvjointsadcost) {
1402 mvjointsadcost[0] = 600;
1403 mvjointsadcost[1] = 300;
1404 mvjointsadcost[2] = 300;
1405 mvjointsadcost[0] = 300;
1406 }
1408 static void cal_nmvsadcosts(int *mvsadcost[2]) {
1409 int i = 1;
1411 mvsadcost[0][0] = 0;
1412 mvsadcost[1][0] = 0;
1414 do {
1415 double z = 256 * (2 * (log2f(8 * i) + .6));
1416 mvsadcost[0][i] = (int)z;
1417 mvsadcost[1][i] = (int)z;
1418 mvsadcost[0][-i] = (int)z;
1419 mvsadcost[1][-i] = (int)z;
1420 } while (++i <= MV_MAX);
1421 }
1423 static void cal_nmvsadcosts_hp(int *mvsadcost[2]) {
1424 int i = 1;
1426 mvsadcost[0][0] = 0;
1427 mvsadcost[1][0] = 0;
1429 do {
1430 double z = 256 * (2 * (log2f(8 * i) + .6));
1431 mvsadcost[0][i] = (int)z;
1432 mvsadcost[1][i] = (int)z;
1433 mvsadcost[0][-i] = (int)z;
1434 mvsadcost[1][-i] = (int)z;
1435 } while (++i <= MV_MAX);
1436 }
1438 static void alloc_mode_context(VP9_COMMON *cm, int num_4x4_blk,
1439 PICK_MODE_CONTEXT *ctx) {
1440 int num_pix = num_4x4_blk << 4;
1441 int i, k;
1442 ctx->num_4x4_blk = num_4x4_blk;
1443 CHECK_MEM_ERROR(cm, ctx->zcoeff_blk,
1444 vpx_calloc(num_4x4_blk, sizeof(uint8_t)));
1445 for (i = 0; i < MAX_MB_PLANE; ++i) {
1446 for (k = 0; k < 3; ++k) {
1447 CHECK_MEM_ERROR(cm, ctx->coeff[i][k],
1448 vpx_memalign(16, num_pix * sizeof(int16_t)));
1449 CHECK_MEM_ERROR(cm, ctx->qcoeff[i][k],
1450 vpx_memalign(16, num_pix * sizeof(int16_t)));
1451 CHECK_MEM_ERROR(cm, ctx->dqcoeff[i][k],
1452 vpx_memalign(16, num_pix * sizeof(int16_t)));
1453 CHECK_MEM_ERROR(cm, ctx->eobs[i][k],
1454 vpx_memalign(16, num_pix * sizeof(uint16_t)));
1455 ctx->coeff_pbuf[i][k] = ctx->coeff[i][k];
1456 ctx->qcoeff_pbuf[i][k] = ctx->qcoeff[i][k];
1457 ctx->dqcoeff_pbuf[i][k] = ctx->dqcoeff[i][k];
1458 ctx->eobs_pbuf[i][k] = ctx->eobs[i][k];
1459 }
1460 }
1461 }
1463 static void free_mode_context(PICK_MODE_CONTEXT *ctx) {
1464 int i, k;
1465 vpx_free(ctx->zcoeff_blk);
1466 ctx->zcoeff_blk = 0;
1467 for (i = 0; i < MAX_MB_PLANE; ++i) {
1468 for (k = 0; k < 3; ++k) {
1469 vpx_free(ctx->coeff[i][k]);
1470 ctx->coeff[i][k] = 0;
1471 vpx_free(ctx->qcoeff[i][k]);
1472 ctx->qcoeff[i][k] = 0;
1473 vpx_free(ctx->dqcoeff[i][k]);
1474 ctx->dqcoeff[i][k] = 0;
1475 vpx_free(ctx->eobs[i][k]);
1476 ctx->eobs[i][k] = 0;
1477 }
1478 }
1479 }
1481 static void init_pick_mode_context(VP9_COMP *cpi) {
1482 int i;
1483 VP9_COMMON *const cm = &cpi->common;
1484 MACROBLOCK *const x = &cpi->mb;
1487 for (i = 0; i < BLOCK_SIZES; ++i) {
1488 const int num_4x4_w = num_4x4_blocks_wide_lookup[i];
1489 const int num_4x4_h = num_4x4_blocks_high_lookup[i];
1490 const int num_4x4_blk = MAX(4, num_4x4_w * num_4x4_h);
1491 if (i < BLOCK_16X16) {
1492 for (x->sb_index = 0; x->sb_index < 4; ++x->sb_index) {
1493 for (x->mb_index = 0; x->mb_index < 4; ++x->mb_index) {
1494 for (x->b_index = 0; x->b_index < 16 / num_4x4_blk; ++x->b_index) {
1495 PICK_MODE_CONTEXT *ctx = get_block_context(x, i);
1496 alloc_mode_context(cm, num_4x4_blk, ctx);
1497 }
1498 }
1499 }
1500 } else if (i < BLOCK_32X32) {
1501 for (x->sb_index = 0; x->sb_index < 4; ++x->sb_index) {
1502 for (x->mb_index = 0; x->mb_index < 64 / num_4x4_blk; ++x->mb_index) {
1503 PICK_MODE_CONTEXT *ctx = get_block_context(x, i);
1504 ctx->num_4x4_blk = num_4x4_blk;
1505 alloc_mode_context(cm, num_4x4_blk, ctx);
1506 }
1507 }
1508 } else if (i < BLOCK_64X64) {
1509 for (x->sb_index = 0; x->sb_index < 256 / num_4x4_blk; ++x->sb_index) {
1510 PICK_MODE_CONTEXT *ctx = get_block_context(x, i);
1511 ctx->num_4x4_blk = num_4x4_blk;
1512 alloc_mode_context(cm, num_4x4_blk, ctx);
1513 }
1514 } else {
1515 PICK_MODE_CONTEXT *ctx = get_block_context(x, i);
1516 ctx->num_4x4_blk = num_4x4_blk;
1517 alloc_mode_context(cm, num_4x4_blk, ctx);
1518 }
1519 }
1520 }
1522 static void free_pick_mode_context(MACROBLOCK *x) {
1523 int i;
1525 for (i = 0; i < BLOCK_SIZES; ++i) {
1526 const int num_4x4_w = num_4x4_blocks_wide_lookup[i];
1527 const int num_4x4_h = num_4x4_blocks_high_lookup[i];
1528 const int num_4x4_blk = MAX(4, num_4x4_w * num_4x4_h);
1529 if (i < BLOCK_16X16) {
1530 for (x->sb_index = 0; x->sb_index < 4; ++x->sb_index) {
1531 for (x->mb_index = 0; x->mb_index < 4; ++x->mb_index) {
1532 for (x->b_index = 0; x->b_index < 16 / num_4x4_blk; ++x->b_index) {
1533 PICK_MODE_CONTEXT *ctx = get_block_context(x, i);
1534 free_mode_context(ctx);
1535 }
1536 }
1537 }
1538 } else if (i < BLOCK_32X32) {
1539 for (x->sb_index = 0; x->sb_index < 4; ++x->sb_index) {
1540 for (x->mb_index = 0; x->mb_index < 64 / num_4x4_blk; ++x->mb_index) {
1541 PICK_MODE_CONTEXT *ctx = get_block_context(x, i);
1542 free_mode_context(ctx);
1543 }
1544 }
1545 } else if (i < BLOCK_64X64) {
1546 for (x->sb_index = 0; x->sb_index < 256 / num_4x4_blk; ++x->sb_index) {
1547 PICK_MODE_CONTEXT *ctx = get_block_context(x, i);
1548 free_mode_context(ctx);
1549 }
1550 } else {
1551 PICK_MODE_CONTEXT *ctx = get_block_context(x, i);
1552 free_mode_context(ctx);
1553 }
1554 }
1555 }
1557 VP9_PTR vp9_create_compressor(VP9_CONFIG *oxcf) {
1558 int i, j;
1559 volatile union {
1560 VP9_COMP *cpi;
1561 VP9_PTR ptr;
1562 } ctx;
1564 VP9_COMP *cpi;
1565 VP9_COMMON *cm;
1567 cpi = ctx.cpi = vpx_memalign(32, sizeof(VP9_COMP));
1568 // Check that the CPI instance is valid
1569 if (!cpi)
1570 return 0;
1572 cm = &cpi->common;
1574 vp9_zero(*cpi);
1576 if (setjmp(cm->error.jmp)) {
1577 VP9_PTR ptr = ctx.ptr;
1579 ctx.cpi->common.error.setjmp = 0;
1580 vp9_remove_compressor(&ptr);
1581 return 0;
1582 }
1584 cm->error.setjmp = 1;
1586 CHECK_MEM_ERROR(cm, cpi->mb.ss, vpx_calloc(sizeof(search_site),
1587 (MAX_MVSEARCH_STEPS * 8) + 1));
1589 vp9_create_common(cm);
1591 init_config((VP9_PTR)cpi, oxcf);
1593 init_pick_mode_context(cpi);
1595 cm->current_video_frame = 0;
1596 cpi->kf_overspend_bits = 0;
1597 cpi->kf_bitrate_adjustment = 0;
1598 cpi->frames_till_gf_update_due = 0;
1599 cpi->gf_overspend_bits = 0;
1600 cpi->non_gf_bitrate_adjustment = 0;
1602 // Set reference frame sign bias for ALTREF frame to 1 (for now)
1603 cm->ref_frame_sign_bias[ALTREF_FRAME] = 1;
1605 cpi->baseline_gf_interval = DEFAULT_GF_INTERVAL;
1607 cpi->gold_is_last = 0;
1608 cpi->alt_is_last = 0;
1609 cpi->gold_is_alt = 0;
1611 // Spatial scalability
1612 cpi->number_spatial_layers = oxcf->ss_number_layers;
1614 // Create the encoder segmentation map and set all entries to 0
1615 CHECK_MEM_ERROR(cm, cpi->segmentation_map,
1616 vpx_calloc(cm->mi_rows * cm->mi_cols, 1));
1618 // And a place holder structure is the coding context
1619 // for use if we want to save and restore it
1620 CHECK_MEM_ERROR(cm, cpi->coding_context.last_frame_seg_map_copy,
1621 vpx_calloc(cm->mi_rows * cm->mi_cols, 1));
1623 CHECK_MEM_ERROR(cm, cpi->active_map, vpx_calloc(cm->MBs, 1));
1624 vpx_memset(cpi->active_map, 1, cm->MBs);
1625 cpi->active_map_enabled = 0;
1627 for (i = 0; i < (sizeof(cpi->mbgraph_stats) /
1628 sizeof(cpi->mbgraph_stats[0])); i++) {
1629 CHECK_MEM_ERROR(cm, cpi->mbgraph_stats[i].mb_stats,
1630 vpx_calloc(cm->MBs *
1631 sizeof(*cpi->mbgraph_stats[i].mb_stats), 1));
1632 }
1634 #ifdef ENTROPY_STATS
1635 if (cpi->pass != 1)
1636 init_context_counters();
1637 #endif
1639 #ifdef MODE_STATS
1640 init_tx_count_stats();
1641 init_switchable_interp_stats();
1642 #endif
1644 /*Initialize the feed-forward activity masking.*/
1645 cpi->activity_avg = 90 << 12;
1647 cpi->frames_since_key = 8; // Sensible default for first frame.
1648 cpi->key_frame_frequency = cpi->oxcf.key_freq;
1649 cpi->this_key_frame_forced = 0;
1650 cpi->next_key_frame_forced = 0;
1652 cpi->source_alt_ref_pending = 0;
1653 cpi->source_alt_ref_active = 0;
1654 cpi->refresh_alt_ref_frame = 0;
1656 #if CONFIG_MULTIPLE_ARF
1657 // Turn multiple ARF usage on/off. This is a quick hack for the initial test
1658 // version. It should eventually be set via the codec API.
1659 cpi->multi_arf_enabled = 1;
1661 if (cpi->multi_arf_enabled) {
1662 cpi->sequence_number = 0;
1663 cpi->frame_coding_order_period = 0;
1664 vp9_zero(cpi->frame_coding_order);
1665 vp9_zero(cpi->arf_buffer_idx);
1666 }
1667 #endif
1669 cpi->b_calculate_psnr = CONFIG_INTERNAL_STATS;
1670 #if CONFIG_INTERNAL_STATS
1671 cpi->b_calculate_ssimg = 0;
1673 cpi->count = 0;
1674 cpi->bytes = 0;
1676 if (cpi->b_calculate_psnr) {
1677 cpi->total_sq_error = 0.0;
1678 cpi->total_sq_error2 = 0.0;
1679 cpi->total_y = 0.0;
1680 cpi->total_u = 0.0;
1681 cpi->total_v = 0.0;
1682 cpi->total = 0.0;
1683 cpi->totalp_y = 0.0;
1684 cpi->totalp_u = 0.0;
1685 cpi->totalp_v = 0.0;
1686 cpi->totalp = 0.0;
1687 cpi->tot_recode_hits = 0;
1688 cpi->summed_quality = 0;
1689 cpi->summed_weights = 0;
1690 cpi->summedp_quality = 0;
1691 cpi->summedp_weights = 0;
1692 }
1694 if (cpi->b_calculate_ssimg) {
1695 cpi->total_ssimg_y = 0;
1696 cpi->total_ssimg_u = 0;
1697 cpi->total_ssimg_v = 0;
1698 cpi->total_ssimg_all = 0;
1699 }
1701 #endif
1703 cpi->first_time_stamp_ever = INT64_MAX;
1705 cpi->frames_till_gf_update_due = 0;
1706 cpi->key_frame_count = 1;
1708 cpi->ni_av_qi = cpi->oxcf.worst_allowed_q;
1709 cpi->ni_tot_qi = 0;
1710 cpi->ni_frames = 0;
1711 cpi->tot_q = 0.0;
1712 cpi->avg_q = vp9_convert_qindex_to_q(cpi->oxcf.worst_allowed_q);
1713 cpi->total_byte_count = 0;
1715 cpi->rate_correction_factor = 1.0;
1716 cpi->key_frame_rate_correction_factor = 1.0;
1717 cpi->gf_rate_correction_factor = 1.0;
1718 cpi->twopass.est_max_qcorrection_factor = 1.0;
1720 cal_nmvjointsadcost(cpi->mb.nmvjointsadcost);
1721 cpi->mb.nmvcost[0] = &cpi->mb.nmvcosts[0][MV_MAX];
1722 cpi->mb.nmvcost[1] = &cpi->mb.nmvcosts[1][MV_MAX];
1723 cpi->mb.nmvsadcost[0] = &cpi->mb.nmvsadcosts[0][MV_MAX];
1724 cpi->mb.nmvsadcost[1] = &cpi->mb.nmvsadcosts[1][MV_MAX];
1725 cal_nmvsadcosts(cpi->mb.nmvsadcost);
1727 cpi->mb.nmvcost_hp[0] = &cpi->mb.nmvcosts_hp[0][MV_MAX];
1728 cpi->mb.nmvcost_hp[1] = &cpi->mb.nmvcosts_hp[1][MV_MAX];
1729 cpi->mb.nmvsadcost_hp[0] = &cpi->mb.nmvsadcosts_hp[0][MV_MAX];
1730 cpi->mb.nmvsadcost_hp[1] = &cpi->mb.nmvsadcosts_hp[1][MV_MAX];
1731 cal_nmvsadcosts_hp(cpi->mb.nmvsadcost_hp);
1733 for (i = 0; i < KEY_FRAME_CONTEXT; i++)
1734 cpi->prior_key_frame_distance[i] = (int)cpi->output_framerate;
1736 #ifdef OUTPUT_YUV_SRC
1737 yuv_file = fopen("bd.yuv", "ab");
1738 #endif
1739 #ifdef OUTPUT_YUV_REC
1740 yuv_rec_file = fopen("rec.yuv", "wb");
1741 #endif
1743 #if 0
1744 framepsnr = fopen("framepsnr.stt", "a");
1745 kf_list = fopen("kf_list.stt", "w");
1746 #endif
1748 cpi->output_pkt_list = oxcf->output_pkt_list;
1750 cpi->enable_encode_breakout = 1;
1752 if (cpi->pass == 1) {
1753 vp9_init_first_pass(cpi);
1754 } else if (cpi->pass == 2) {
1755 size_t packet_sz = sizeof(FIRSTPASS_STATS);
1756 int packets = (int)(oxcf->two_pass_stats_in.sz / packet_sz);
1758 cpi->twopass.stats_in_start = oxcf->two_pass_stats_in.buf;
1759 cpi->twopass.stats_in = cpi->twopass.stats_in_start;
1760 cpi->twopass.stats_in_end = (void *)((char *)cpi->twopass.stats_in
1761 + (packets - 1) * packet_sz);
1762 vp9_init_second_pass(cpi);
1763 }
1765 vp9_set_speed_features(cpi);
1767 // Default rd threshold factors for mode selection
1768 for (i = 0; i < BLOCK_SIZES; ++i) {
1769 for (j = 0; j < MAX_MODES; ++j)
1770 cpi->rd_thresh_freq_fact[i][j] = 32;
1771 for (j = 0; j < MAX_REFS; ++j)
1772 cpi->rd_thresh_freq_sub8x8[i][j] = 32;
1773 }
1775 #define BFP(BT, SDF, SDAF, VF, SVF, SVAF, SVFHH, SVFHV, SVFHHV, \
1776 SDX3F, SDX8F, SDX4DF)\
1777 cpi->fn_ptr[BT].sdf = SDF; \
1778 cpi->fn_ptr[BT].sdaf = SDAF; \
1779 cpi->fn_ptr[BT].vf = VF; \
1780 cpi->fn_ptr[BT].svf = SVF; \
1781 cpi->fn_ptr[BT].svaf = SVAF; \
1782 cpi->fn_ptr[BT].svf_halfpix_h = SVFHH; \
1783 cpi->fn_ptr[BT].svf_halfpix_v = SVFHV; \
1784 cpi->fn_ptr[BT].svf_halfpix_hv = SVFHHV; \
1785 cpi->fn_ptr[BT].sdx3f = SDX3F; \
1786 cpi->fn_ptr[BT].sdx8f = SDX8F; \
1787 cpi->fn_ptr[BT].sdx4df = SDX4DF;
1789 BFP(BLOCK_32X16, vp9_sad32x16, vp9_sad32x16_avg,
1790 vp9_variance32x16, vp9_sub_pixel_variance32x16,
1791 vp9_sub_pixel_avg_variance32x16, NULL, NULL,
1792 NULL, NULL, NULL,
1793 vp9_sad32x16x4d)
1795 BFP(BLOCK_16X32, vp9_sad16x32, vp9_sad16x32_avg,
1796 vp9_variance16x32, vp9_sub_pixel_variance16x32,
1797 vp9_sub_pixel_avg_variance16x32, NULL, NULL,
1798 NULL, NULL, NULL,
1799 vp9_sad16x32x4d)
1801 BFP(BLOCK_64X32, vp9_sad64x32, vp9_sad64x32_avg,
1802 vp9_variance64x32, vp9_sub_pixel_variance64x32,
1803 vp9_sub_pixel_avg_variance64x32, NULL, NULL,
1804 NULL, NULL, NULL,
1805 vp9_sad64x32x4d)
1807 BFP(BLOCK_32X64, vp9_sad32x64, vp9_sad32x64_avg,
1808 vp9_variance32x64, vp9_sub_pixel_variance32x64,
1809 vp9_sub_pixel_avg_variance32x64, NULL, NULL,
1810 NULL, NULL, NULL,
1811 vp9_sad32x64x4d)
1813 BFP(BLOCK_32X32, vp9_sad32x32, vp9_sad32x32_avg,
1814 vp9_variance32x32, vp9_sub_pixel_variance32x32,
1815 vp9_sub_pixel_avg_variance32x32, vp9_variance_halfpixvar32x32_h,
1816 vp9_variance_halfpixvar32x32_v,
1817 vp9_variance_halfpixvar32x32_hv, vp9_sad32x32x3, vp9_sad32x32x8,
1818 vp9_sad32x32x4d)
1820 BFP(BLOCK_64X64, vp9_sad64x64, vp9_sad64x64_avg,
1821 vp9_variance64x64, vp9_sub_pixel_variance64x64,
1822 vp9_sub_pixel_avg_variance64x64, vp9_variance_halfpixvar64x64_h,
1823 vp9_variance_halfpixvar64x64_v,
1824 vp9_variance_halfpixvar64x64_hv, vp9_sad64x64x3, vp9_sad64x64x8,
1825 vp9_sad64x64x4d)
1827 BFP(BLOCK_16X16, vp9_sad16x16, vp9_sad16x16_avg,
1828 vp9_variance16x16, vp9_sub_pixel_variance16x16,
1829 vp9_sub_pixel_avg_variance16x16, vp9_variance_halfpixvar16x16_h,
1830 vp9_variance_halfpixvar16x16_v,
1831 vp9_variance_halfpixvar16x16_hv, vp9_sad16x16x3, vp9_sad16x16x8,
1832 vp9_sad16x16x4d)
1834 BFP(BLOCK_16X8, vp9_sad16x8, vp9_sad16x8_avg,
1835 vp9_variance16x8, vp9_sub_pixel_variance16x8,
1836 vp9_sub_pixel_avg_variance16x8, NULL, NULL, NULL,
1837 vp9_sad16x8x3, vp9_sad16x8x8, vp9_sad16x8x4d)
1839 BFP(BLOCK_8X16, vp9_sad8x16, vp9_sad8x16_avg,
1840 vp9_variance8x16, vp9_sub_pixel_variance8x16,
1841 vp9_sub_pixel_avg_variance8x16, NULL, NULL, NULL,
1842 vp9_sad8x16x3, vp9_sad8x16x8, vp9_sad8x16x4d)
1844 BFP(BLOCK_8X8, vp9_sad8x8, vp9_sad8x8_avg,
1845 vp9_variance8x8, vp9_sub_pixel_variance8x8,
1846 vp9_sub_pixel_avg_variance8x8, NULL, NULL, NULL,
1847 vp9_sad8x8x3, vp9_sad8x8x8, vp9_sad8x8x4d)
1849 BFP(BLOCK_8X4, vp9_sad8x4, vp9_sad8x4_avg,
1850 vp9_variance8x4, vp9_sub_pixel_variance8x4,
1851 vp9_sub_pixel_avg_variance8x4, NULL, NULL,
1852 NULL, NULL, vp9_sad8x4x8,
1853 vp9_sad8x4x4d)
1855 BFP(BLOCK_4X8, vp9_sad4x8, vp9_sad4x8_avg,
1856 vp9_variance4x8, vp9_sub_pixel_variance4x8,
1857 vp9_sub_pixel_avg_variance4x8, NULL, NULL,
1858 NULL, NULL, vp9_sad4x8x8,
1859 vp9_sad4x8x4d)
1861 BFP(BLOCK_4X4, vp9_sad4x4, vp9_sad4x4_avg,
1862 vp9_variance4x4, vp9_sub_pixel_variance4x4,
1863 vp9_sub_pixel_avg_variance4x4, NULL, NULL, NULL,
1864 vp9_sad4x4x3, vp9_sad4x4x8, vp9_sad4x4x4d)
1866 cpi->full_search_sad = vp9_full_search_sad;
1867 cpi->diamond_search_sad = vp9_diamond_search_sad;
1868 cpi->refining_search_sad = vp9_refining_search_sad;
1870 // make sure frame 1 is okay
1871 cpi->error_bins[0] = cpi->common.MBs;
1873 /* vp9_init_quantizer() is first called here. Add check in
1874 * vp9_frame_init_quantizer() so that vp9_init_quantizer is only
1875 * called later when needed. This will avoid unnecessary calls of
1876 * vp9_init_quantizer() for every frame.
1877 */
1878 vp9_init_quantizer(cpi);
1880 vp9_loop_filter_init(cm);
1882 cpi->common.error.setjmp = 0;
1884 vp9_zero(cpi->y_uv_mode_count);
1886 #ifdef MODE_TEST_HIT_STATS
1887 vp9_zero(cpi->mode_test_hits);
1888 #endif
1890 return (VP9_PTR) cpi;
1891 }
1893 void vp9_remove_compressor(VP9_PTR *ptr) {
1894 VP9_COMP *cpi = (VP9_COMP *)(*ptr);
1895 int i;
1897 if (!cpi)
1898 return;
1900 if (cpi && (cpi->common.current_video_frame > 0)) {
1901 if (cpi->pass == 2) {
1902 vp9_end_second_pass(cpi);
1903 }
1905 #ifdef ENTROPY_STATS
1906 if (cpi->pass != 1) {
1907 print_context_counters();
1908 print_tree_update_probs();
1909 print_mode_context(cpi);
1910 }
1911 #endif
1913 #ifdef MODE_STATS
1914 if (cpi->pass != 1) {
1915 write_tx_count_stats();
1916 write_switchable_interp_stats();
1917 }
1918 #endif
1920 #if CONFIG_INTERNAL_STATS
1922 vp9_clear_system_state();
1924 // printf("\n8x8-4x4:%d-%d\n", cpi->t8x8_count, cpi->t4x4_count);
1925 if (cpi->pass != 1) {
1926 FILE *f = fopen("opsnr.stt", "a");
1927 double time_encoded = (cpi->last_end_time_stamp_seen
1928 - cpi->first_time_stamp_ever) / 10000000.000;
1929 double total_encode_time = (cpi->time_receive_data +
1930 cpi->time_compress_data) / 1000.000;
1931 double dr = (double)cpi->bytes * (double) 8 / (double)1000
1932 / time_encoded;
1934 if (cpi->b_calculate_psnr) {
1935 YV12_BUFFER_CONFIG *lst_yv12 =
1936 &cpi->common.yv12_fb[cpi->common.ref_frame_map[cpi->lst_fb_idx]];
1937 double samples = 3.0 / 2 * cpi->count *
1938 lst_yv12->y_width * lst_yv12->y_height;
1939 double total_psnr = vp9_mse2psnr(samples, 255.0, cpi->total_sq_error);
1940 double total_psnr2 = vp9_mse2psnr(samples, 255.0, cpi->total_sq_error2);
1941 double total_ssim = 100 * pow(cpi->summed_quality /
1942 cpi->summed_weights, 8.0);
1943 double total_ssimp = 100 * pow(cpi->summedp_quality /
1944 cpi->summedp_weights, 8.0);
1946 fprintf(f, "Bitrate\tAVGPsnr\tGLBPsnr\tAVPsnrP\tGLPsnrP\t"
1947 "VPXSSIM\tVPSSIMP\t Time(ms)\n");
1948 fprintf(f, "%7.2f\t%7.3f\t%7.3f\t%7.3f\t%7.3f\t%7.3f\t%7.3f\t%8.0f\n",
1949 dr, cpi->total / cpi->count, total_psnr,
1950 cpi->totalp / cpi->count, total_psnr2, total_ssim, total_ssimp,
1951 total_encode_time);
1952 }
1954 if (cpi->b_calculate_ssimg) {
1955 fprintf(f, "BitRate\tSSIM_Y\tSSIM_U\tSSIM_V\tSSIM_A\t Time(ms)\n");
1956 fprintf(f, "%7.2f\t%6.4f\t%6.4f\t%6.4f\t%6.4f\t%8.0f\n", dr,
1957 cpi->total_ssimg_y / cpi->count,
1958 cpi->total_ssimg_u / cpi->count,
1959 cpi->total_ssimg_v / cpi->count,
1960 cpi->total_ssimg_all / cpi->count, total_encode_time);
1961 }
1963 fclose(f);
1964 }
1966 #endif
1968 #ifdef MODE_TEST_HIT_STATS
1969 if (cpi->pass != 1) {
1970 double norm_per_pixel_mode_tests = 0;
1971 double norm_counts[BLOCK_SIZES];
1972 int i;
1973 int sb64_per_frame;
1974 int norm_factors[BLOCK_SIZES] =
1975 {256, 128, 128, 64, 32, 32, 16, 8, 8, 4, 2, 2, 1};
1976 FILE *f = fopen("mode_hit_stats.stt", "a");
1978 // On average, how many mode tests do we do
1979 for (i = 0; i < BLOCK_SIZES; ++i) {
1980 norm_counts[i] = (double)cpi->mode_test_hits[i] /
1981 (double)norm_factors[i];
1982 norm_per_pixel_mode_tests += norm_counts[i];
1983 }
1984 // Convert to a number per 64x64 and per frame
1985 sb64_per_frame = ((cpi->common.height + 63) / 64) *
1986 ((cpi->common.width + 63) / 64);
1987 norm_per_pixel_mode_tests =
1988 norm_per_pixel_mode_tests /
1989 (double)(cpi->common.current_video_frame * sb64_per_frame);
1991 fprintf(f, "%6.4f\n", norm_per_pixel_mode_tests);
1992 fclose(f);
1993 }
1994 #endif
1996 #ifdef ENTROPY_STATS
1997 {
1998 int i, j, k;
1999 FILE *fmode = fopen("vp9_modecontext.c", "w");
2001 fprintf(fmode, "\n#include \"vp9_entropymode.h\"\n\n");
2002 fprintf(fmode, "const unsigned int vp9_kf_default_bmode_counts ");
2003 fprintf(fmode, "[INTRA_MODES][INTRA_MODES]"
2004 "[INTRA_MODES] =\n{\n");
2006 for (i = 0; i < INTRA_MODES; i++) {
2007 fprintf(fmode, " { // Above Mode : %d\n", i);
2009 for (j = 0; j < INTRA_MODES; j++) {
2010 fprintf(fmode, " {");
2012 for (k = 0; k < INTRA_MODES; k++) {
2013 if (!intra_mode_stats[i][j][k])
2014 fprintf(fmode, " %5d, ", 1);
2015 else
2016 fprintf(fmode, " %5d, ", intra_mode_stats[i][j][k]);
2017 }
2019 fprintf(fmode, "}, // left_mode %d\n", j);
2020 }
2022 fprintf(fmode, " },\n");
2023 }
2025 fprintf(fmode, "};\n");
2026 fclose(fmode);
2027 }
2028 #endif
2031 #if defined(SECTIONBITS_OUTPUT)
2033 if (0) {
2034 int i;
2035 FILE *f = fopen("tokenbits.stt", "a");
2037 for (i = 0; i < 28; i++)
2038 fprintf(f, "%8d", (int)(Sectionbits[i] / 256));
2040 fprintf(f, "\n");
2041 fclose(f);
2042 }
2044 #endif
2046 #if 0
2047 {
2048 printf("\n_pick_loop_filter_level:%d\n", cpi->time_pick_lpf / 1000);
2049 printf("\n_frames recive_data encod_mb_row compress_frame Total\n");
2050 printf("%6d %10ld %10ld %10ld %10ld\n", cpi->common.current_video_frame,
2051 cpi->time_receive_data / 1000, cpi->time_encode_sb_row / 1000,
2052 cpi->time_compress_data / 1000,
2053 (cpi->time_receive_data + cpi->time_compress_data) / 1000);
2054 }
2055 #endif
2056 }
2058 free_pick_mode_context(&cpi->mb);
2059 dealloc_compressor_data(cpi);
2060 vpx_free(cpi->mb.ss);
2061 vpx_free(cpi->tok);
2063 for (i = 0; i < sizeof(cpi->mbgraph_stats) /
2064 sizeof(cpi->mbgraph_stats[0]); ++i) {
2065 vpx_free(cpi->mbgraph_stats[i].mb_stats);
2066 }
2068 vp9_remove_common(&cpi->common);
2069 vpx_free(cpi);
2070 *ptr = 0;
2072 #ifdef OUTPUT_YUV_SRC
2073 fclose(yuv_file);
2074 #endif
2075 #ifdef OUTPUT_YUV_REC
2076 fclose(yuv_rec_file);
2077 #endif
2079 #if 0
2081 if (keyfile)
2082 fclose(keyfile);
2084 if (framepsnr)
2085 fclose(framepsnr);
2087 if (kf_list)
2088 fclose(kf_list);
2090 #endif
2091 }
2094 static uint64_t calc_plane_error(uint8_t *orig, int orig_stride,
2095 uint8_t *recon, int recon_stride,
2096 unsigned int cols, unsigned int rows) {
2097 unsigned int row, col;
2098 uint64_t total_sse = 0;
2099 int diff;
2101 for (row = 0; row + 16 <= rows; row += 16) {
2102 for (col = 0; col + 16 <= cols; col += 16) {
2103 unsigned int sse;
2105 vp9_mse16x16(orig + col, orig_stride, recon + col, recon_stride, &sse);
2106 total_sse += sse;
2107 }
2109 /* Handle odd-sized width */
2110 if (col < cols) {
2111 unsigned int border_row, border_col;
2112 uint8_t *border_orig = orig;
2113 uint8_t *border_recon = recon;
2115 for (border_row = 0; border_row < 16; border_row++) {
2116 for (border_col = col; border_col < cols; border_col++) {
2117 diff = border_orig[border_col] - border_recon[border_col];
2118 total_sse += diff * diff;
2119 }
2121 border_orig += orig_stride;
2122 border_recon += recon_stride;
2123 }
2124 }
2126 orig += orig_stride * 16;
2127 recon += recon_stride * 16;
2128 }
2130 /* Handle odd-sized height */
2131 for (; row < rows; row++) {
2132 for (col = 0; col < cols; col++) {
2133 diff = orig[col] - recon[col];
2134 total_sse += diff * diff;
2135 }
2137 orig += orig_stride;
2138 recon += recon_stride;
2139 }
2141 return total_sse;
2142 }
2145 static void generate_psnr_packet(VP9_COMP *cpi) {
2146 YV12_BUFFER_CONFIG *orig = cpi->Source;
2147 YV12_BUFFER_CONFIG *recon = cpi->common.frame_to_show;
2148 struct vpx_codec_cx_pkt pkt;
2149 uint64_t sse;
2150 int i;
2151 unsigned int width = orig->y_crop_width;
2152 unsigned int height = orig->y_crop_height;
2154 pkt.kind = VPX_CODEC_PSNR_PKT;
2155 sse = calc_plane_error(orig->y_buffer, orig->y_stride,
2156 recon->y_buffer, recon->y_stride,
2157 width, height);
2158 pkt.data.psnr.sse[0] = sse;
2159 pkt.data.psnr.sse[1] = sse;
2160 pkt.data.psnr.samples[0] = width * height;
2161 pkt.data.psnr.samples[1] = width * height;
2163 width = orig->uv_crop_width;
2164 height = orig->uv_crop_height;
2166 sse = calc_plane_error(orig->u_buffer, orig->uv_stride,
2167 recon->u_buffer, recon->uv_stride,
2168 width, height);
2169 pkt.data.psnr.sse[0] += sse;
2170 pkt.data.psnr.sse[2] = sse;
2171 pkt.data.psnr.samples[0] += width * height;
2172 pkt.data.psnr.samples[2] = width * height;
2174 sse = calc_plane_error(orig->v_buffer, orig->uv_stride,
2175 recon->v_buffer, recon->uv_stride,
2176 width, height);
2177 pkt.data.psnr.sse[0] += sse;
2178 pkt.data.psnr.sse[3] = sse;
2179 pkt.data.psnr.samples[0] += width * height;
2180 pkt.data.psnr.samples[3] = width * height;
2182 for (i = 0; i < 4; i++)
2183 pkt.data.psnr.psnr[i] = vp9_mse2psnr(pkt.data.psnr.samples[i], 255.0,
2184 (double)pkt.data.psnr.sse[i]);
2186 vpx_codec_pkt_list_add(cpi->output_pkt_list, &pkt);
2187 }
2190 int vp9_use_as_reference(VP9_PTR ptr, int ref_frame_flags) {
2191 VP9_COMP *cpi = (VP9_COMP *)(ptr);
2193 if (ref_frame_flags > 7)
2194 return -1;
2196 cpi->ref_frame_flags = ref_frame_flags;
2197 return 0;
2198 }
2199 int vp9_update_reference(VP9_PTR ptr, int ref_frame_flags) {
2200 VP9_COMP *cpi = (VP9_COMP *)(ptr);
2202 if (ref_frame_flags > 7)
2203 return -1;
2205 cpi->refresh_golden_frame = 0;
2206 cpi->refresh_alt_ref_frame = 0;
2207 cpi->refresh_last_frame = 0;
2209 if (ref_frame_flags & VP9_LAST_FLAG)
2210 cpi->refresh_last_frame = 1;
2212 if (ref_frame_flags & VP9_GOLD_FLAG)
2213 cpi->refresh_golden_frame = 1;
2215 if (ref_frame_flags & VP9_ALT_FLAG)
2216 cpi->refresh_alt_ref_frame = 1;
2218 return 0;
2219 }
2221 int vp9_copy_reference_enc(VP9_PTR ptr, VP9_REFFRAME ref_frame_flag,
2222 YV12_BUFFER_CONFIG *sd) {
2223 VP9_COMP *cpi = (VP9_COMP *)(ptr);
2224 VP9_COMMON *cm = &cpi->common;
2225 int ref_fb_idx;
2227 if (ref_frame_flag == VP9_LAST_FLAG)
2228 ref_fb_idx = cm->ref_frame_map[cpi->lst_fb_idx];
2229 else if (ref_frame_flag == VP9_GOLD_FLAG)
2230 ref_fb_idx = cm->ref_frame_map[cpi->gld_fb_idx];
2231 else if (ref_frame_flag == VP9_ALT_FLAG)
2232 ref_fb_idx = cm->ref_frame_map[cpi->alt_fb_idx];
2233 else
2234 return -1;
2236 vp8_yv12_copy_frame(&cm->yv12_fb[ref_fb_idx], sd);
2238 return 0;
2239 }
2241 int vp9_get_reference_enc(VP9_PTR ptr, int index, YV12_BUFFER_CONFIG **fb) {
2242 VP9_COMP *cpi = (VP9_COMP *)(ptr);
2243 VP9_COMMON *cm = &cpi->common;
2245 if (index < 0 || index >= NUM_REF_FRAMES)
2246 return -1;
2248 *fb = &cm->yv12_fb[cm->ref_frame_map[index]];
2249 return 0;
2250 }
2252 int vp9_set_reference_enc(VP9_PTR ptr, VP9_REFFRAME ref_frame_flag,
2253 YV12_BUFFER_CONFIG *sd) {
2254 VP9_COMP *cpi = (VP9_COMP *)(ptr);
2255 VP9_COMMON *cm = &cpi->common;
2257 int ref_fb_idx;
2259 if (ref_frame_flag == VP9_LAST_FLAG)
2260 ref_fb_idx = cm->ref_frame_map[cpi->lst_fb_idx];
2261 else if (ref_frame_flag == VP9_GOLD_FLAG)
2262 ref_fb_idx = cm->ref_frame_map[cpi->gld_fb_idx];
2263 else if (ref_frame_flag == VP9_ALT_FLAG)
2264 ref_fb_idx = cm->ref_frame_map[cpi->alt_fb_idx];
2265 else
2266 return -1;
2268 vp8_yv12_copy_frame(sd, &cm->yv12_fb[ref_fb_idx]);
2270 return 0;
2271 }
2272 int vp9_update_entropy(VP9_PTR comp, int update) {
2273 ((VP9_COMP *)comp)->common.refresh_frame_context = update;
2274 return 0;
2275 }
2278 #ifdef OUTPUT_YUV_SRC
2279 void vp9_write_yuv_frame(YV12_BUFFER_CONFIG *s) {
2280 uint8_t *src = s->y_buffer;
2281 int h = s->y_height;
2283 do {
2284 fwrite(src, s->y_width, 1, yuv_file);
2285 src += s->y_stride;
2286 } while (--h);
2288 src = s->u_buffer;
2289 h = s->uv_height;
2291 do {
2292 fwrite(src, s->uv_width, 1, yuv_file);
2293 src += s->uv_stride;
2294 } while (--h);
2296 src = s->v_buffer;
2297 h = s->uv_height;
2299 do {
2300 fwrite(src, s->uv_width, 1, yuv_file);
2301 src += s->uv_stride;
2302 } while (--h);
2303 }
2304 #endif
2306 #ifdef OUTPUT_YUV_REC
2307 void vp9_write_yuv_rec_frame(VP9_COMMON *cm) {
2308 YV12_BUFFER_CONFIG *s = cm->frame_to_show;
2309 uint8_t *src = s->y_buffer;
2310 int h = cm->height;
2312 do {
2313 fwrite(src, s->y_width, 1, yuv_rec_file);
2314 src += s->y_stride;
2315 } while (--h);
2317 src = s->u_buffer;
2318 h = s->uv_height;
2320 do {
2321 fwrite(src, s->uv_width, 1, yuv_rec_file);
2322 src += s->uv_stride;
2323 } while (--h);
2325 src = s->v_buffer;
2326 h = s->uv_height;
2328 do {
2329 fwrite(src, s->uv_width, 1, yuv_rec_file);
2330 src += s->uv_stride;
2331 } while (--h);
2333 #if CONFIG_ALPHA
2334 if (s->alpha_buffer) {
2335 src = s->alpha_buffer;
2336 h = s->alpha_height;
2337 do {
2338 fwrite(src, s->alpha_width, 1, yuv_rec_file);
2339 src += s->alpha_stride;
2340 } while (--h);
2341 }
2342 #endif
2344 fflush(yuv_rec_file);
2345 }
2346 #endif
2348 static void scale_and_extend_frame(YV12_BUFFER_CONFIG *src_fb,
2349 YV12_BUFFER_CONFIG *dst_fb) {
2350 const int in_w = src_fb->y_crop_width;
2351 const int in_h = src_fb->y_crop_height;
2352 const int out_w = dst_fb->y_crop_width;
2353 const int out_h = dst_fb->y_crop_height;
2354 int x, y, i;
2356 uint8_t *srcs[4] = {src_fb->y_buffer, src_fb->u_buffer, src_fb->v_buffer,
2357 src_fb->alpha_buffer};
2358 int src_strides[4] = {src_fb->y_stride, src_fb->uv_stride, src_fb->uv_stride,
2359 src_fb->alpha_stride};
2361 uint8_t *dsts[4] = {dst_fb->y_buffer, dst_fb->u_buffer, dst_fb->v_buffer,
2362 dst_fb->alpha_buffer};
2363 int dst_strides[4] = {dst_fb->y_stride, dst_fb->uv_stride, dst_fb->uv_stride,
2364 dst_fb->alpha_stride};
2366 for (y = 0; y < out_h; y += 16) {
2367 for (x = 0; x < out_w; x += 16) {
2368 for (i = 0; i < MAX_MB_PLANE; ++i) {
2369 const int factor = i == 0 ? 1 : 2;
2370 const int x_q4 = x * (16 / factor) * in_w / out_w;
2371 const int y_q4 = y * (16 / factor) * in_h / out_h;
2372 const int src_stride = src_strides[i];
2373 const int dst_stride = dst_strides[i];
2374 uint8_t *src = srcs[i] + y / factor * in_h / out_h * src_stride +
2375 x / factor * in_w / out_w;
2376 uint8_t *dst = dsts[i] + y / factor * dst_stride + x / factor;
2378 vp9_convolve8(src, src_stride, dst, dst_stride,
2379 vp9_sub_pel_filters_8[x_q4 & 0xf], 16 * in_w / out_w,
2380 vp9_sub_pel_filters_8[y_q4 & 0xf], 16 * in_h / out_h,
2381 16 / factor, 16 / factor);
2382 }
2383 }
2384 }
2386 vp8_yv12_extend_frame_borders(dst_fb);
2387 }
2390 static void update_alt_ref_frame_stats(VP9_COMP *cpi) {
2391 // this frame refreshes means next frames don't unless specified by user
2392 cpi->frames_since_golden = 0;
2394 #if CONFIG_MULTIPLE_ARF
2395 if (!cpi->multi_arf_enabled)
2396 #endif
2397 // Clear the alternate reference update pending flag.
2398 cpi->source_alt_ref_pending = 0;
2400 // Set the alternate reference frame active flag
2401 cpi->source_alt_ref_active = 1;
2402 }
2403 static void update_golden_frame_stats(VP9_COMP *cpi) {
2404 // Update the Golden frame usage counts.
2405 if (cpi->refresh_golden_frame) {
2406 // this frame refreshes means next frames don't unless specified by user
2407 cpi->refresh_golden_frame = 0;
2408 cpi->frames_since_golden = 0;
2410 // ******** Fixed Q test code only ************
2411 // If we are going to use the ALT reference for the next group of frames
2412 // set a flag to say so.
2413 if (cpi->oxcf.fixed_q >= 0 &&
2414 cpi->oxcf.play_alternate && !cpi->refresh_alt_ref_frame) {
2415 cpi->source_alt_ref_pending = 1;
2416 cpi->frames_till_gf_update_due = cpi->baseline_gf_interval;
2418 // TODO(ivan): For SVC encoder, GF automatic update is disabled by using
2419 // a large GF_interval.
2420 if (cpi->use_svc) {
2421 cpi->frames_till_gf_update_due = INT_MAX;
2422 }
2423 }
2425 if (!cpi->source_alt_ref_pending)
2426 cpi->source_alt_ref_active = 0;
2428 // Decrement count down till next gf
2429 if (cpi->frames_till_gf_update_due > 0)
2430 cpi->frames_till_gf_update_due--;
2432 } else if (!cpi->refresh_alt_ref_frame) {
2433 // Decrement count down till next gf
2434 if (cpi->frames_till_gf_update_due > 0)
2435 cpi->frames_till_gf_update_due--;
2437 if (cpi->frames_till_alt_ref_frame)
2438 cpi->frames_till_alt_ref_frame--;
2440 cpi->frames_since_golden++;
2441 }
2442 }
2444 static int find_fp_qindex() {
2445 int i;
2447 for (i = 0; i < QINDEX_RANGE; i++) {
2448 if (vp9_convert_qindex_to_q(i) >= 30.0) {
2449 break;
2450 }
2451 }
2453 if (i == QINDEX_RANGE)
2454 i--;
2456 return i;
2457 }
2459 static void Pass1Encode(VP9_COMP *cpi, unsigned long *size, unsigned char *dest,
2460 unsigned int *frame_flags) {
2461 (void) size;
2462 (void) dest;
2463 (void) frame_flags;
2465 vp9_set_quantizer(cpi, find_fp_qindex());
2466 vp9_first_pass(cpi);
2467 }
2469 #define WRITE_RECON_BUFFER 0
2470 #if WRITE_RECON_BUFFER
2471 void write_cx_frame_to_file(YV12_BUFFER_CONFIG *frame, int this_frame) {
2472 FILE *yframe;
2473 int i;
2474 char filename[255];
2476 snprintf(filename, sizeof(filename), "cx\\y%04d.raw", this_frame);
2477 yframe = fopen(filename, "wb");
2479 for (i = 0; i < frame->y_height; i++)
2480 fwrite(frame->y_buffer + i * frame->y_stride,
2481 frame->y_width, 1, yframe);
2483 fclose(yframe);
2484 snprintf(filename, sizeof(filename), "cx\\u%04d.raw", this_frame);
2485 yframe = fopen(filename, "wb");
2487 for (i = 0; i < frame->uv_height; i++)
2488 fwrite(frame->u_buffer + i * frame->uv_stride,
2489 frame->uv_width, 1, yframe);
2491 fclose(yframe);
2492 snprintf(filename, sizeof(filename), "cx\\v%04d.raw", this_frame);
2493 yframe = fopen(filename, "wb");
2495 for (i = 0; i < frame->uv_height; i++)
2496 fwrite(frame->v_buffer + i * frame->uv_stride,
2497 frame->uv_width, 1, yframe);
2499 fclose(yframe);
2500 }
2501 #endif
2503 static double compute_edge_pixel_proportion(YV12_BUFFER_CONFIG *frame) {
2504 #define EDGE_THRESH 128
2505 int i, j;
2506 int num_edge_pels = 0;
2507 int num_pels = (frame->y_height - 2) * (frame->y_width - 2);
2508 uint8_t *prev = frame->y_buffer + 1;
2509 uint8_t *curr = frame->y_buffer + 1 + frame->y_stride;
2510 uint8_t *next = frame->y_buffer + 1 + 2 * frame->y_stride;
2511 for (i = 1; i < frame->y_height - 1; i++) {
2512 for (j = 1; j < frame->y_width - 1; j++) {
2513 /* Sobel hor and ver gradients */
2514 int v = 2 * (curr[1] - curr[-1]) + (prev[1] - prev[-1]) +
2515 (next[1] - next[-1]);
2516 int h = 2 * (prev[0] - next[0]) + (prev[1] - next[1]) +
2517 (prev[-1] - next[-1]);
2518 h = (h < 0 ? -h : h);
2519 v = (v < 0 ? -v : v);
2520 if (h > EDGE_THRESH || v > EDGE_THRESH)
2521 num_edge_pels++;
2522 curr++;
2523 prev++;
2524 next++;
2525 }
2526 curr += frame->y_stride - frame->y_width + 2;
2527 prev += frame->y_stride - frame->y_width + 2;
2528 next += frame->y_stride - frame->y_width + 2;
2529 }
2530 return (double)num_edge_pels / num_pels;
2531 }
2533 // Function to test for conditions that indicate we should loop
2534 // back and recode a frame.
2535 static int recode_loop_test(VP9_COMP *cpi,
2536 int high_limit, int low_limit,
2537 int q, int maxq, int minq) {
2538 int force_recode = 0;
2539 VP9_COMMON *cm = &cpi->common;
2541 // Is frame recode allowed at all
2542 // Yes if either recode mode 1 is selected or mode two is selected
2543 // and the frame is a key frame. golden frame or alt_ref_frame
2544 if ((cpi->sf.recode_loop == 1) ||
2545 ((cpi->sf.recode_loop == 2) &&
2546 ((cm->frame_type == KEY_FRAME) ||
2547 cpi->refresh_golden_frame ||
2548 cpi->refresh_alt_ref_frame))) {
2549 // General over and under shoot tests
2550 if (((cpi->projected_frame_size > high_limit) && (q < maxq)) ||
2551 ((cpi->projected_frame_size < low_limit) && (q > minq))) {
2552 force_recode = 1;
2553 } else if (cpi->oxcf.end_usage == USAGE_CONSTRAINED_QUALITY) {
2554 // Deal with frame undershoot and whether or not we are
2555 // below the automatically set cq level.
2556 if (q > cpi->cq_target_quality &&
2557 cpi->projected_frame_size < ((cpi->this_frame_target * 7) >> 3)) {
2558 force_recode = 1;
2559 } else if (q > cpi->oxcf.cq_level &&
2560 cpi->projected_frame_size < cpi->min_frame_bandwidth &&
2561 cpi->active_best_quality > cpi->oxcf.cq_level) {
2562 // Severe undershoot and between auto and user cq level
2563 force_recode = 1;
2564 cpi->active_best_quality = cpi->oxcf.cq_level;
2565 }
2566 }
2567 }
2569 return force_recode;
2570 }
2572 static void update_reference_frames(VP9_COMP * const cpi) {
2573 VP9_COMMON * const cm = &cpi->common;
2575 // At this point the new frame has been encoded.
2576 // If any buffer copy / swapping is signaled it should be done here.
2577 if (cm->frame_type == KEY_FRAME) {
2578 ref_cnt_fb(cm->fb_idx_ref_cnt,
2579 &cm->ref_frame_map[cpi->gld_fb_idx], cm->new_fb_idx);
2580 ref_cnt_fb(cm->fb_idx_ref_cnt,
2581 &cm->ref_frame_map[cpi->alt_fb_idx], cm->new_fb_idx);
2582 }
2583 #if CONFIG_MULTIPLE_ARF
2584 else if (!cpi->multi_arf_enabled && cpi->refresh_golden_frame &&
2585 !cpi->refresh_alt_ref_frame) {
2586 #else
2587 else if (cpi->refresh_golden_frame && !cpi->refresh_alt_ref_frame &&
2588 !cpi->use_svc) {
2589 #endif
2590 /* Preserve the previously existing golden frame and update the frame in
2591 * the alt ref slot instead. This is highly specific to the current use of
2592 * alt-ref as a forward reference, and this needs to be generalized as
2593 * other uses are implemented (like RTC/temporal scaling)
2594 *
2595 * The update to the buffer in the alt ref slot was signaled in
2596 * vp9_pack_bitstream(), now swap the buffer pointers so that it's treated
2597 * as the golden frame next time.
2598 */
2599 int tmp;
2601 ref_cnt_fb(cm->fb_idx_ref_cnt,
2602 &cm->ref_frame_map[cpi->alt_fb_idx], cm->new_fb_idx);
2604 tmp = cpi->alt_fb_idx;
2605 cpi->alt_fb_idx = cpi->gld_fb_idx;
2606 cpi->gld_fb_idx = tmp;
2607 } else { /* For non key/golden frames */
2608 if (cpi->refresh_alt_ref_frame) {
2609 int arf_idx = cpi->alt_fb_idx;
2610 #if CONFIG_MULTIPLE_ARF
2611 if (cpi->multi_arf_enabled) {
2612 arf_idx = cpi->arf_buffer_idx[cpi->sequence_number + 1];
2613 }
2614 #endif
2615 ref_cnt_fb(cm->fb_idx_ref_cnt,
2616 &cm->ref_frame_map[arf_idx], cm->new_fb_idx);
2617 }
2619 if (cpi->refresh_golden_frame) {
2620 ref_cnt_fb(cm->fb_idx_ref_cnt,
2621 &cm->ref_frame_map[cpi->gld_fb_idx], cm->new_fb_idx);
2622 }
2623 }
2625 if (cpi->refresh_last_frame) {
2626 ref_cnt_fb(cm->fb_idx_ref_cnt,
2627 &cm->ref_frame_map[cpi->lst_fb_idx], cm->new_fb_idx);
2628 }
2629 }
2631 static void loopfilter_frame(VP9_COMP *cpi, VP9_COMMON *cm) {
2632 MACROBLOCKD *xd = &cpi->mb.e_mbd;
2633 struct loopfilter *lf = &cm->lf;
2634 if (xd->lossless) {
2635 lf->filter_level = 0;
2636 } else {
2637 struct vpx_usec_timer timer;
2639 vp9_clear_system_state();
2641 vpx_usec_timer_start(&timer);
2643 vp9_pick_filter_level(cpi->Source, cpi, cpi->sf.use_fast_lpf_pick);
2645 vpx_usec_timer_mark(&timer);
2646 cpi->time_pick_lpf += vpx_usec_timer_elapsed(&timer);
2647 }
2649 if (lf->filter_level > 0) {
2650 vp9_set_alt_lf_level(cpi, lf->filter_level);
2651 vp9_loop_filter_frame(cm, xd, lf->filter_level, 0, 0);
2652 }
2654 vp9_extend_frame_inner_borders(cm->frame_to_show,
2655 cm->subsampling_x, cm->subsampling_y);
2656 }
2658 static void scale_references(VP9_COMP *cpi) {
2659 VP9_COMMON *cm = &cpi->common;
2660 int i;
2661 int refs[ALLOWED_REFS_PER_FRAME] = {cpi->lst_fb_idx, cpi->gld_fb_idx,
2662 cpi->alt_fb_idx};
2664 for (i = 0; i < 3; i++) {
2665 YV12_BUFFER_CONFIG *ref = &cm->yv12_fb[cm->ref_frame_map[refs[i]]];
2667 if (ref->y_crop_width != cm->width ||
2668 ref->y_crop_height != cm->height) {
2669 int new_fb = get_free_fb(cm);
2671 vp9_realloc_frame_buffer(&cm->yv12_fb[new_fb],
2672 cm->width, cm->height,
2673 cm->subsampling_x, cm->subsampling_y,
2674 VP9BORDERINPIXELS);
2675 scale_and_extend_frame(ref, &cm->yv12_fb[new_fb]);
2676 cpi->scaled_ref_idx[i] = new_fb;
2677 } else {
2678 cpi->scaled_ref_idx[i] = cm->ref_frame_map[refs[i]];
2679 cm->fb_idx_ref_cnt[cm->ref_frame_map[refs[i]]]++;
2680 }
2681 }
2682 }
2684 static void release_scaled_references(VP9_COMP *cpi) {
2685 VP9_COMMON *cm = &cpi->common;
2686 int i;
2688 for (i = 0; i < 3; i++)
2689 cm->fb_idx_ref_cnt[cpi->scaled_ref_idx[i]]--;
2690 }
2692 static void full_to_model_count(unsigned int *model_count,
2693 unsigned int *full_count) {
2694 int n;
2695 model_count[ZERO_TOKEN] = full_count[ZERO_TOKEN];
2696 model_count[ONE_TOKEN] = full_count[ONE_TOKEN];
2697 model_count[TWO_TOKEN] = full_count[TWO_TOKEN];
2698 for (n = THREE_TOKEN; n < DCT_EOB_TOKEN; ++n)
2699 model_count[TWO_TOKEN] += full_count[n];
2700 model_count[DCT_EOB_MODEL_TOKEN] = full_count[DCT_EOB_TOKEN];
2701 }
2703 static void full_to_model_counts(
2704 vp9_coeff_count_model *model_count, vp9_coeff_count *full_count) {
2705 int i, j, k, l;
2706 for (i = 0; i < BLOCK_TYPES; ++i)
2707 for (j = 0; j < REF_TYPES; ++j)
2708 for (k = 0; k < COEF_BANDS; ++k)
2709 for (l = 0; l < PREV_COEF_CONTEXTS; ++l) {
2710 if (l >= 3 && k == 0)
2711 continue;
2712 full_to_model_count(model_count[i][j][k][l], full_count[i][j][k][l]);
2713 }
2714 }
2716 #if 0 && CONFIG_INTERNAL_STATS
2717 static void output_frame_level_debug_stats(VP9_COMP *cpi) {
2718 VP9_COMMON *const cm = &cpi->common;
2719 FILE *const f = fopen("tmp.stt", cm->current_video_frame ? "a" : "w");
2720 int recon_err;
2722 vp9_clear_system_state(); // __asm emms;
2724 recon_err = vp9_calc_ss_err(cpi->Source, get_frame_new_buffer(cm));
2726 if (cpi->twopass.total_left_stats.coded_error != 0.0)
2727 fprintf(f, "%10d %10d %10d %10d %10d %10d %10d %10d %10d"
2728 "%7.2f %7.2f %7.2f %7.2f %7.2f %7.2f %7.2f"
2729 "%6d %6d %5d %5d %5d %8.2f %10d %10.3f"
2730 "%10.3f %8d %10d %10d %10d\n",
2731 cpi->common.current_video_frame, cpi->this_frame_target,
2732 cpi->projected_frame_size, 0,
2733 (cpi->projected_frame_size - cpi->this_frame_target),
2734 (int)cpi->total_target_vs_actual,
2735 (int)(cpi->oxcf.starting_buffer_level - cpi->bits_off_target),
2736 (int)cpi->total_actual_bits, cm->base_qindex,
2737 vp9_convert_qindex_to_q(cm->base_qindex),
2738 (double)vp9_dc_quant(cm->base_qindex, 0) / 4.0,
2739 vp9_convert_qindex_to_q(cpi->active_best_quality),
2740 vp9_convert_qindex_to_q(cpi->active_worst_quality), cpi->avg_q,
2741 vp9_convert_qindex_to_q(cpi->ni_av_qi),
2742 vp9_convert_qindex_to_q(cpi->cq_target_quality),
2743 cpi->refresh_last_frame, cpi->refresh_golden_frame,
2744 cpi->refresh_alt_ref_frame, cm->frame_type, cpi->gfu_boost,
2745 cpi->twopass.est_max_qcorrection_factor, (int)cpi->twopass.bits_left,
2746 cpi->twopass.total_left_stats.coded_error,
2747 (double)cpi->twopass.bits_left /
2748 (1 + cpi->twopass.total_left_stats.coded_error),
2749 cpi->tot_recode_hits, recon_err, cpi->kf_boost, cpi->kf_zeromotion_pct);
2751 fclose(f);
2753 if (0) {
2754 FILE *const fmodes = fopen("Modes.stt", "a");
2755 int i;
2757 fprintf(fmodes, "%6d:%1d:%1d:%1d ", cpi->common.current_video_frame,
2758 cm->frame_type, cpi->refresh_golden_frame,
2759 cpi->refresh_alt_ref_frame);
2761 for (i = 0; i < MAX_MODES; ++i)
2762 fprintf(fmodes, "%5d ", cpi->mode_chosen_counts[i]);
2763 for (i = 0; i < MAX_REFS; ++i)
2764 fprintf(fmodes, "%5d ", cpi->sub8x8_mode_chosen_counts[i]);
2766 fprintf(fmodes, "\n");
2768 fclose(fmodes);
2769 }
2770 }
2771 #endif
2773 static int pick_q_and_adjust_q_bounds(VP9_COMP *cpi,
2774 int * bottom_index, int * top_index) {
2775 // Set an active best quality and if necessary active worst quality
2776 int q = cpi->active_worst_quality;
2777 VP9_COMMON *const cm = &cpi->common;
2779 if (frame_is_intra_only(cm)) {
2780 #if !CONFIG_MULTIPLE_ARF
2781 // Handle the special case for key frames forced when we have75 reached
2782 // the maximum key frame interval. Here force the Q to a range
2783 // based on the ambient Q to reduce the risk of popping.
2784 if (cpi->this_key_frame_forced) {
2785 int delta_qindex;
2786 int qindex = cpi->last_boosted_qindex;
2787 double last_boosted_q = vp9_convert_qindex_to_q(qindex);
2789 delta_qindex = vp9_compute_qdelta(cpi, last_boosted_q,
2790 (last_boosted_q * 0.75));
2792 cpi->active_best_quality = MAX(qindex + delta_qindex,
2793 cpi->best_quality);
2794 } else {
2795 int high = 5000;
2796 int low = 400;
2797 double q_adj_factor = 1.0;
2798 double q_val;
2800 // Baseline value derived from cpi->active_worst_quality and kf boost
2801 cpi->active_best_quality = get_active_quality(q, cpi->kf_boost,
2802 low, high,
2803 kf_low_motion_minq,
2804 kf_high_motion_minq);
2806 // Allow somewhat lower kf minq with small image formats.
2807 if ((cm->width * cm->height) <= (352 * 288)) {
2808 q_adj_factor -= 0.25;
2809 }
2811 // Make a further adjustment based on the kf zero motion measure.
2812 q_adj_factor += 0.05 - (0.001 * (double)cpi->kf_zeromotion_pct);
2814 // Convert the adjustment factor to a qindex delta
2815 // on active_best_quality.
2816 q_val = vp9_convert_qindex_to_q(cpi->active_best_quality);
2817 cpi->active_best_quality +=
2818 vp9_compute_qdelta(cpi, q_val, (q_val * q_adj_factor));
2819 }
2820 #else
2821 double current_q;
2822 // Force the KF quantizer to be 30% of the active_worst_quality.
2823 current_q = vp9_convert_qindex_to_q(cpi->active_worst_quality);
2824 cpi->active_best_quality = cpi->active_worst_quality
2825 + vp9_compute_qdelta(cpi, current_q, current_q * 0.3);
2826 #endif
2827 } else if (!cpi->is_src_frame_alt_ref &&
2828 (cpi->refresh_golden_frame || cpi->refresh_alt_ref_frame)) {
2829 int high = 2000;
2830 int low = 400;
2832 // Use the lower of cpi->active_worst_quality and recent
2833 // average Q as basis for GF/ARF best Q limit unless last frame was
2834 // a key frame.
2835 if (cpi->frames_since_key > 1 &&
2836 cpi->avg_frame_qindex < cpi->active_worst_quality) {
2837 q = cpi->avg_frame_qindex;
2838 }
2839 // For constrained quality dont allow Q less than the cq level
2840 if (cpi->oxcf.end_usage == USAGE_CONSTRAINED_QUALITY) {
2841 if (q < cpi->cq_target_quality)
2842 q = cpi->cq_target_quality;
2843 if (cpi->frames_since_key > 1) {
2844 cpi->active_best_quality = get_active_quality(q, cpi->gfu_boost,
2845 low, high,
2846 afq_low_motion_minq,
2847 afq_high_motion_minq);
2848 } else {
2849 cpi->active_best_quality = get_active_quality(q, cpi->gfu_boost,
2850 low, high,
2851 gf_low_motion_minq,
2852 gf_high_motion_minq);
2853 }
2854 // Constrained quality use slightly lower active best.
2855 cpi->active_best_quality = cpi->active_best_quality * 15 / 16;
2857 } else if (cpi->oxcf.end_usage == USAGE_CONSTANT_QUALITY) {
2858 if (!cpi->refresh_alt_ref_frame) {
2859 cpi->active_best_quality = cpi->cq_target_quality;
2860 } else {
2861 if (cpi->frames_since_key > 1) {
2862 cpi->active_best_quality = get_active_quality(q, cpi->gfu_boost,
2863 low, high,
2864 afq_low_motion_minq,
2865 afq_high_motion_minq);
2866 } else {
2867 cpi->active_best_quality = get_active_quality(q, cpi->gfu_boost,
2868 low, high,
2869 gf_low_motion_minq,
2870 gf_high_motion_minq);
2871 }
2872 }
2873 } else {
2874 cpi->active_best_quality = get_active_quality(q, cpi->gfu_boost,
2875 low, high,
2876 gf_low_motion_minq,
2877 gf_high_motion_minq);
2878 }
2879 } else {
2880 if (cpi->oxcf.end_usage == USAGE_CONSTANT_QUALITY) {
2881 cpi->active_best_quality = cpi->cq_target_quality;
2882 } else {
2883 cpi->active_best_quality = inter_minq[q];
2884 // 1-pass: for now, use the average Q for the active_best, if its lower
2885 // than active_worst.
2886 if (cpi->pass == 0 && (cpi->avg_frame_qindex < q))
2887 cpi->active_best_quality = inter_minq[cpi->avg_frame_qindex];
2889 // For the constrained quality mode we don't want
2890 // q to fall below the cq level.
2891 if ((cpi->oxcf.end_usage == USAGE_CONSTRAINED_QUALITY) &&
2892 (cpi->active_best_quality < cpi->cq_target_quality)) {
2893 // If we are strongly undershooting the target rate in the last
2894 // frames then use the user passed in cq value not the auto
2895 // cq value.
2896 if (cpi->rolling_actual_bits < cpi->min_frame_bandwidth)
2897 cpi->active_best_quality = cpi->oxcf.cq_level;
2898 else
2899 cpi->active_best_quality = cpi->cq_target_quality;
2900 }
2901 }
2902 }
2904 // Clip the active best and worst quality values to limits
2905 if (cpi->active_worst_quality > cpi->worst_quality)
2906 cpi->active_worst_quality = cpi->worst_quality;
2908 if (cpi->active_best_quality < cpi->best_quality)
2909 cpi->active_best_quality = cpi->best_quality;
2911 if (cpi->active_best_quality > cpi->worst_quality)
2912 cpi->active_best_quality = cpi->worst_quality;
2914 if (cpi->active_worst_quality < cpi->active_best_quality)
2915 cpi->active_worst_quality = cpi->active_best_quality;
2917 // Limit Q range for the adaptive loop.
2918 if (cm->frame_type == KEY_FRAME && !cpi->this_key_frame_forced) {
2919 *top_index =
2920 (cpi->active_worst_quality + cpi->active_best_quality * 3) / 4;
2921 // If this is the first (key) frame in 1-pass, active best is the user
2922 // best-allowed, and leave the top_index to active_worst.
2923 if (cpi->pass == 0 && cpi->common.current_video_frame == 0) {
2924 cpi->active_best_quality = cpi->oxcf.best_allowed_q;
2925 *top_index = cpi->oxcf.worst_allowed_q;
2926 }
2927 } else if (!cpi->is_src_frame_alt_ref &&
2928 (cpi->oxcf.end_usage != USAGE_STREAM_FROM_SERVER) &&
2929 (cpi->refresh_golden_frame || cpi->refresh_alt_ref_frame)) {
2930 *top_index =
2931 (cpi->active_worst_quality + cpi->active_best_quality) / 2;
2932 } else {
2933 *top_index = cpi->active_worst_quality;
2934 }
2935 *bottom_index = cpi->active_best_quality;
2937 if (cpi->oxcf.end_usage == USAGE_CONSTANT_QUALITY) {
2938 q = cpi->active_best_quality;
2939 // Special case code to try and match quality with forced key frames
2940 } else if ((cm->frame_type == KEY_FRAME) && cpi->this_key_frame_forced) {
2941 q = cpi->last_boosted_qindex;
2942 } else {
2943 // Determine initial Q to try.
2944 if (cpi->pass == 0) {
2945 // 1-pass: for now, use per-frame-bw for target size of frame, scaled
2946 // by |x| for key frame.
2947 int scale = (cm->frame_type == KEY_FRAME) ? 5 : 1;
2948 q = vp9_regulate_q(cpi, scale * cpi->av_per_frame_bandwidth);
2949 } else {
2950 q = vp9_regulate_q(cpi, cpi->this_frame_target);
2951 }
2952 if (q > *top_index)
2953 q = *top_index;
2954 }
2956 return q;
2957 }
2958 static void encode_frame_to_data_rate(VP9_COMP *cpi,
2959 unsigned long *size,
2960 unsigned char *dest,
2961 unsigned int *frame_flags) {
2962 VP9_COMMON *const cm = &cpi->common;
2963 TX_SIZE t;
2964 int q;
2965 int frame_over_shoot_limit;
2966 int frame_under_shoot_limit;
2968 int loop = 0;
2969 int loop_count;
2971 int q_low;
2972 int q_high;
2974 int top_index;
2975 int bottom_index;
2976 int active_worst_qchanged = 0;
2978 int overshoot_seen = 0;
2979 int undershoot_seen = 0;
2981 SPEED_FEATURES *const sf = &cpi->sf;
2982 unsigned int max_mv_def = MIN(cpi->common.width, cpi->common.height);
2983 struct segmentation *const seg = &cm->seg;
2985 /* Scale the source buffer, if required. */
2986 if (cm->mi_cols * 8 != cpi->un_scaled_source->y_width ||
2987 cm->mi_rows * 8 != cpi->un_scaled_source->y_height) {
2988 scale_and_extend_frame(cpi->un_scaled_source, &cpi->scaled_source);
2989 cpi->Source = &cpi->scaled_source;
2990 } else {
2991 cpi->Source = cpi->un_scaled_source;
2992 }
2993 scale_references(cpi);
2995 // Clear down mmx registers to allow floating point in what follows.
2996 vp9_clear_system_state();
2998 // For an alt ref frame in 2 pass we skip the call to the second
2999 // pass function that sets the target bandwidth so we must set it here.
3000 if (cpi->refresh_alt_ref_frame) {
3001 // Set a per frame bit target for the alt ref frame.
3002 cpi->per_frame_bandwidth = cpi->twopass.gf_bits;
3003 // Set a per second target bitrate.
3004 cpi->target_bandwidth = (int)(cpi->twopass.gf_bits * cpi->output_framerate);
3005 }
3007 // Clear zbin over-quant value and mode boost values.
3008 cpi->zbin_mode_boost = 0;
3010 // Enable or disable mode based tweaking of the zbin.
3011 // For 2 pass only used where GF/ARF prediction quality
3012 // is above a threshold.
3013 cpi->zbin_mode_boost = 0;
3014 cpi->zbin_mode_boost_enabled = 0;
3016 // Current default encoder behavior for the altref sign bias.
3017 cpi->common.ref_frame_sign_bias[ALTREF_FRAME] = cpi->source_alt_ref_active;
3019 // Check to see if a key frame is signaled.
3020 // For two pass with auto key frame enabled cm->frame_type may already be
3021 // set, but not for one pass.
3022 if ((cm->current_video_frame == 0) ||
3023 (cm->frame_flags & FRAMEFLAGS_KEY) ||
3024 (cpi->oxcf.auto_key && (cpi->frames_since_key %
3025 cpi->key_frame_frequency == 0))) {
3026 // Set frame type to key frame for the force key frame, if we exceed the
3027 // maximum distance in an automatic keyframe selection or for the first
3028 // frame.
3029 cm->frame_type = KEY_FRAME;
3030 }
3032 // Set default state for segment based loop filter update flags.
3033 cm->lf.mode_ref_delta_update = 0;
3035 // Initialize cpi->mv_step_param to default based on max resolution.
3036 cpi->mv_step_param = vp9_init_search_range(cpi, max_mv_def);
3037 // Initialize cpi->max_mv_magnitude and cpi->mv_step_param if appropriate.
3038 if (sf->auto_mv_step_size) {
3039 if (frame_is_intra_only(&cpi->common)) {
3040 // Initialize max_mv_magnitude for use in the first INTER frame
3041 // after a key/intra-only frame.
3042 cpi->max_mv_magnitude = max_mv_def;
3043 } else {
3044 if (cm->show_frame)
3045 // Allow mv_steps to correspond to twice the max mv magnitude found
3046 // in the previous frame, capped by the default max_mv_magnitude based
3047 // on resolution.
3048 cpi->mv_step_param = vp9_init_search_range(
3049 cpi, MIN(max_mv_def, 2 * cpi->max_mv_magnitude));
3050 cpi->max_mv_magnitude = 0;
3051 }
3052 }
3054 // Set various flags etc to special state if it is a key frame.
3055 if (frame_is_intra_only(cm)) {
3056 vp9_setup_key_frame(cpi);
3057 // Reset the loop filter deltas and segmentation map.
3058 setup_features(cm);
3060 // If segmentation is enabled force a map update for key frames.
3061 if (seg->enabled) {
3062 seg->update_map = 1;
3063 seg->update_data = 1;
3064 }
3066 // The alternate reference frame cannot be active for a key frame.
3067 cpi->source_alt_ref_active = 0;
3069 cm->error_resilient_mode = (cpi->oxcf.error_resilient_mode != 0);
3070 cm->frame_parallel_decoding_mode =
3071 (cpi->oxcf.frame_parallel_decoding_mode != 0);
3072 if (cm->error_resilient_mode) {
3073 cm->frame_parallel_decoding_mode = 1;
3074 cm->reset_frame_context = 0;
3075 cm->refresh_frame_context = 0;
3076 } else if (cm->intra_only) {
3077 // Only reset the current context.
3078 cm->reset_frame_context = 2;
3079 }
3080 }
3082 // Configure experimental use of segmentation for enhanced coding of
3083 // static regions if indicated.
3084 // Only allowed in second pass of two pass (as requires lagged coding)
3085 // and if the relevant speed feature flag is set.
3086 if ((cpi->pass == 2) && (cpi->sf.static_segmentation)) {
3087 configure_static_seg_features(cpi);
3088 }
3090 // Decide how big to make the frame.
3091 vp9_pick_frame_size(cpi);
3093 vp9_clear_system_state();
3095 q = pick_q_and_adjust_q_bounds(cpi, &bottom_index, &top_index);
3097 q_high = top_index;
3098 q_low = bottom_index;
3100 vp9_compute_frame_size_bounds(cpi, &frame_under_shoot_limit,
3101 &frame_over_shoot_limit);
3103 #if CONFIG_MULTIPLE_ARF
3104 // Force the quantizer determined by the coding order pattern.
3105 if (cpi->multi_arf_enabled && (cm->frame_type != KEY_FRAME) &&
3106 cpi->oxcf.end_usage != USAGE_CONSTANT_QUALITY) {
3107 double new_q;
3108 double current_q = vp9_convert_qindex_to_q(cpi->active_worst_quality);
3109 int level = cpi->this_frame_weight;
3110 assert(level >= 0);
3112 // Set quantizer steps at 10% increments.
3113 new_q = current_q * (1.0 - (0.2 * (cpi->max_arf_level - level)));
3114 q = cpi->active_worst_quality + vp9_compute_qdelta(cpi, current_q, new_q);
3116 bottom_index = q;
3117 top_index = q;
3118 q_low = q;
3119 q_high = q;
3121 printf("frame:%d q:%d\n", cm->current_video_frame, q);
3122 }
3123 #endif
3125 loop_count = 0;
3126 vp9_zero(cpi->rd_tx_select_threshes);
3128 if (!frame_is_intra_only(cm)) {
3129 cm->mcomp_filter_type = DEFAULT_INTERP_FILTER;
3130 /* TODO: Decide this more intelligently */
3131 cm->allow_high_precision_mv = q < HIGH_PRECISION_MV_QTHRESH;
3132 set_mvcost(cpi);
3133 }
3135 #if CONFIG_VP9_POSTPROC
3137 if (cpi->oxcf.noise_sensitivity > 0) {
3138 int l = 0;
3140 switch (cpi->oxcf.noise_sensitivity) {
3141 case 1:
3142 l = 20;
3143 break;
3144 case 2:
3145 l = 40;
3146 break;
3147 case 3:
3148 l = 60;
3149 break;
3150 case 4:
3151 case 5:
3152 l = 100;
3153 break;
3154 case 6:
3155 l = 150;
3156 break;
3157 }
3159 vp9_denoise(cpi->Source, cpi->Source, l);
3160 }
3162 #endif
3164 #ifdef OUTPUT_YUV_SRC
3165 vp9_write_yuv_frame(cpi->Source);
3166 #endif
3168 do {
3169 vp9_clear_system_state(); // __asm emms;
3171 vp9_set_quantizer(cpi, q);
3173 if (loop_count == 0) {
3174 // Set up entropy context depending on frame type. The decoder mandates
3175 // the use of the default context, index 0, for keyframes and inter
3176 // frames where the error_resilient_mode or intra_only flag is set. For
3177 // other inter-frames the encoder currently uses only two contexts;
3178 // context 1 for ALTREF frames and context 0 for the others.
3179 if (cm->frame_type == KEY_FRAME) {
3180 vp9_setup_key_frame(cpi);
3181 } else {
3182 if (!cm->intra_only && !cm->error_resilient_mode) {
3183 cpi->common.frame_context_idx = cpi->refresh_alt_ref_frame;
3184 }
3185 vp9_setup_inter_frame(cpi);
3186 }
3187 }
3189 if (cpi->oxcf.aq_mode == VARIANCE_AQ) {
3190 vp9_vaq_frame_setup(cpi);
3191 }
3193 // transform / motion compensation build reconstruction frame
3195 vp9_encode_frame(cpi);
3197 // Update the skip mb flag probabilities based on the distribution
3198 // seen in the last encoder iteration.
3199 // update_base_skip_probs(cpi);
3201 vp9_clear_system_state(); // __asm emms;
3203 // Dummy pack of the bitstream using up to date stats to get an
3204 // accurate estimate of output frame size to determine if we need
3205 // to recode.
3206 vp9_save_coding_context(cpi);
3207 cpi->dummy_packing = 1;
3208 vp9_pack_bitstream(cpi, dest, size);
3209 cpi->projected_frame_size = (*size) << 3;
3210 vp9_restore_coding_context(cpi);
3212 if (frame_over_shoot_limit == 0)
3213 frame_over_shoot_limit = 1;
3214 active_worst_qchanged = 0;
3216 if (cpi->oxcf.end_usage == USAGE_CONSTANT_QUALITY) {
3217 loop = 0;
3218 } else {
3219 // Special case handling for forced key frames
3220 if ((cm->frame_type == KEY_FRAME) && cpi->this_key_frame_forced) {
3221 int last_q = q;
3222 int kf_err = vp9_calc_ss_err(cpi->Source, get_frame_new_buffer(cm));
3224 int high_err_target = cpi->ambient_err;
3225 int low_err_target = cpi->ambient_err >> 1;
3227 // Prevent possible divide by zero error below for perfect KF
3228 kf_err += !kf_err;
3230 // The key frame is not good enough or we can afford
3231 // to make it better without undue risk of popping.
3232 if ((kf_err > high_err_target &&
3233 cpi->projected_frame_size <= frame_over_shoot_limit) ||
3234 (kf_err > low_err_target &&
3235 cpi->projected_frame_size <= frame_under_shoot_limit)) {
3236 // Lower q_high
3237 q_high = q > q_low ? q - 1 : q_low;
3239 // Adjust Q
3240 q = (q * high_err_target) / kf_err;
3241 q = MIN(q, (q_high + q_low) >> 1);
3242 } else if (kf_err < low_err_target &&
3243 cpi->projected_frame_size >= frame_under_shoot_limit) {
3244 // The key frame is much better than the previous frame
3245 // Raise q_low
3246 q_low = q < q_high ? q + 1 : q_high;
3248 // Adjust Q
3249 q = (q * low_err_target) / kf_err;
3250 q = MIN(q, (q_high + q_low + 1) >> 1);
3251 }
3253 // Clamp Q to upper and lower limits:
3254 q = clamp(q, q_low, q_high);
3256 loop = q != last_q;
3257 } else if (recode_loop_test(
3258 cpi, frame_over_shoot_limit, frame_under_shoot_limit,
3259 q, top_index, bottom_index)) {
3260 // Is the projected frame size out of range and are we allowed
3261 // to attempt to recode.
3262 int last_q = q;
3263 int retries = 0;
3265 // Frame size out of permitted range:
3266 // Update correction factor & compute new Q to try...
3268 // Frame is too large
3269 if (cpi->projected_frame_size > cpi->this_frame_target) {
3270 // Raise Qlow as to at least the current value
3271 q_low = q < q_high ? q + 1 : q_high;
3273 if (undershoot_seen || loop_count > 1) {
3274 // Update rate_correction_factor unless
3275 // cpi->active_worst_quality has changed.
3276 if (!active_worst_qchanged)
3277 vp9_update_rate_correction_factors(cpi, 1);
3279 q = (q_high + q_low + 1) / 2;
3280 } else {
3281 // Update rate_correction_factor unless
3282 // cpi->active_worst_quality has changed.
3283 if (!active_worst_qchanged)
3284 vp9_update_rate_correction_factors(cpi, 0);
3286 q = vp9_regulate_q(cpi, cpi->this_frame_target);
3288 while (q < q_low && retries < 10) {
3289 vp9_update_rate_correction_factors(cpi, 0);
3290 q = vp9_regulate_q(cpi, cpi->this_frame_target);
3291 retries++;
3292 }
3293 }
3295 overshoot_seen = 1;
3296 } else {
3297 // Frame is too small
3298 q_high = q > q_low ? q - 1 : q_low;
3300 if (overshoot_seen || loop_count > 1) {
3301 // Update rate_correction_factor unless
3302 // cpi->active_worst_quality has changed.
3303 if (!active_worst_qchanged)
3304 vp9_update_rate_correction_factors(cpi, 1);
3306 q = (q_high + q_low) / 2;
3307 } else {
3308 // Update rate_correction_factor unless
3309 // cpi->active_worst_quality has changed.
3310 if (!active_worst_qchanged)
3311 vp9_update_rate_correction_factors(cpi, 0);
3313 q = vp9_regulate_q(cpi, cpi->this_frame_target);
3315 // Special case reset for qlow for constrained quality.
3316 // This should only trigger where there is very substantial
3317 // undershoot on a frame and the auto cq level is above
3318 // the user passsed in value.
3319 if (cpi->oxcf.end_usage == USAGE_CONSTRAINED_QUALITY && q < q_low) {
3320 q_low = q;
3321 }
3323 while (q > q_high && retries < 10) {
3324 vp9_update_rate_correction_factors(cpi, 0);
3325 q = vp9_regulate_q(cpi, cpi->this_frame_target);
3326 retries++;
3327 }
3328 }
3330 undershoot_seen = 1;
3331 }
3333 // Clamp Q to upper and lower limits:
3334 q = clamp(q, q_low, q_high);
3336 loop = q != last_q;
3337 } else {
3338 loop = 0;
3339 }
3340 }
3342 if (cpi->is_src_frame_alt_ref)
3343 loop = 0;
3345 if (loop) {
3346 loop_count++;
3348 #if CONFIG_INTERNAL_STATS
3349 cpi->tot_recode_hits++;
3350 #endif
3351 }
3352 } while (loop);
3354 // Special case code to reduce pulsing when key frames are forced at a
3355 // fixed interval. Note the reconstruction error if it is the frame before
3356 // the force key frame
3357 if (cpi->next_key_frame_forced && (cpi->twopass.frames_to_key == 0)) {
3358 cpi->ambient_err = vp9_calc_ss_err(cpi->Source, get_frame_new_buffer(cm));
3359 }
3361 if (cm->frame_type == KEY_FRAME)
3362 cpi->refresh_last_frame = 1;
3364 cm->frame_to_show = get_frame_new_buffer(cm);
3366 #if WRITE_RECON_BUFFER
3367 if (cm->show_frame)
3368 write_cx_frame_to_file(cm->frame_to_show,
3369 cm->current_video_frame);
3370 else
3371 write_cx_frame_to_file(cm->frame_to_show,
3372 cm->current_video_frame + 1000);
3373 #endif
3375 // Pick the loop filter level for the frame.
3376 loopfilter_frame(cpi, cm);
3378 #if WRITE_RECON_BUFFER
3379 if (cm->show_frame)
3380 write_cx_frame_to_file(cm->frame_to_show,
3381 cm->current_video_frame + 2000);
3382 else
3383 write_cx_frame_to_file(cm->frame_to_show,
3384 cm->current_video_frame + 3000);
3385 #endif
3387 // build the bitstream
3388 cpi->dummy_packing = 0;
3389 vp9_pack_bitstream(cpi, dest, size);
3391 if (cm->seg.update_map)
3392 update_reference_segmentation_map(cpi);
3394 release_scaled_references(cpi);
3395 update_reference_frames(cpi);
3397 for (t = TX_4X4; t <= TX_32X32; t++)
3398 full_to_model_counts(cpi->common.counts.coef[t],
3399 cpi->coef_counts[t]);
3400 if (!cpi->common.error_resilient_mode &&
3401 !cpi->common.frame_parallel_decoding_mode) {
3402 vp9_adapt_coef_probs(&cpi->common);
3403 }
3405 if (!frame_is_intra_only(&cpi->common)) {
3406 FRAME_COUNTS *counts = &cpi->common.counts;
3408 vp9_copy(counts->y_mode, cpi->y_mode_count);
3409 vp9_copy(counts->uv_mode, cpi->y_uv_mode_count);
3410 vp9_copy(counts->partition, cpi->partition_count);
3411 vp9_copy(counts->intra_inter, cpi->intra_inter_count);
3412 vp9_copy(counts->comp_inter, cpi->comp_inter_count);
3413 vp9_copy(counts->single_ref, cpi->single_ref_count);
3414 vp9_copy(counts->comp_ref, cpi->comp_ref_count);
3415 counts->mv = cpi->NMVcount;
3416 if (!cpi->common.error_resilient_mode &&
3417 !cpi->common.frame_parallel_decoding_mode) {
3418 vp9_adapt_mode_probs(&cpi->common);
3419 vp9_adapt_mv_probs(&cpi->common, cpi->common.allow_high_precision_mv);
3420 }
3421 }
3423 #ifdef ENTROPY_STATS
3424 vp9_update_mode_context_stats(cpi);
3425 #endif
3427 /* Move storing frame_type out of the above loop since it is also
3428 * needed in motion search besides loopfilter */
3429 cm->last_frame_type = cm->frame_type;
3431 // Update rate control heuristics
3432 cpi->total_byte_count += (*size);
3433 cpi->projected_frame_size = (*size) << 3;
3435 // Post encode loop adjustment of Q prediction.
3436 if (!active_worst_qchanged)
3437 vp9_update_rate_correction_factors(cpi, (cpi->sf.recode_loop ||
3438 cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER) ? 2 : 0);
3441 cpi->last_q[cm->frame_type] = cm->base_qindex;
3443 // Keep record of last boosted (KF/KF/ARF) Q value.
3444 // If the current frame is coded at a lower Q then we also update it.
3445 // If all mbs in this group are skipped only update if the Q value is
3446 // better than that already stored.
3447 // This is used to help set quality in forced key frames to reduce popping
3448 if ((cm->base_qindex < cpi->last_boosted_qindex) ||
3449 ((cpi->static_mb_pct < 100) &&
3450 ((cm->frame_type == KEY_FRAME) ||
3451 cpi->refresh_alt_ref_frame ||
3452 (cpi->refresh_golden_frame && !cpi->is_src_frame_alt_ref)))) {
3453 cpi->last_boosted_qindex = cm->base_qindex;
3454 }
3456 if (cm->frame_type == KEY_FRAME) {
3457 vp9_adjust_key_frame_context(cpi);
3458 }
3460 // Keep a record of ambient average Q.
3461 if (cm->frame_type != KEY_FRAME)
3462 cpi->avg_frame_qindex = (2 + 3 * cpi->avg_frame_qindex +
3463 cm->base_qindex) >> 2;
3465 // Keep a record from which we can calculate the average Q excluding GF
3466 // updates and key frames.
3467 if (cm->frame_type != KEY_FRAME &&
3468 !cpi->refresh_golden_frame &&
3469 !cpi->refresh_alt_ref_frame) {
3470 cpi->ni_frames++;
3471 cpi->tot_q += vp9_convert_qindex_to_q(q);
3472 cpi->avg_q = cpi->tot_q / (double)cpi->ni_frames;
3474 // Calculate the average Q for normal inter frames (not key or GFU frames).
3475 cpi->ni_tot_qi += q;
3476 cpi->ni_av_qi = cpi->ni_tot_qi / cpi->ni_frames;
3477 }
3479 // Update the buffer level variable.
3480 // Non-viewable frames are a special case and are treated as pure overhead.
3481 if (!cm->show_frame)
3482 cpi->bits_off_target -= cpi->projected_frame_size;
3483 else
3484 cpi->bits_off_target += cpi->av_per_frame_bandwidth -
3485 cpi->projected_frame_size;
3487 // Clip the buffer level at the maximum buffer size
3488 if (cpi->bits_off_target > cpi->oxcf.maximum_buffer_size)
3489 cpi->bits_off_target = cpi->oxcf.maximum_buffer_size;
3491 // Rolling monitors of whether we are over or underspending used to help
3492 // regulate min and Max Q in two pass.
3493 if (cm->frame_type != KEY_FRAME) {
3494 cpi->rolling_target_bits =
3495 ((cpi->rolling_target_bits * 3) + cpi->this_frame_target + 2) / 4;
3496 cpi->rolling_actual_bits =
3497 ((cpi->rolling_actual_bits * 3) + cpi->projected_frame_size + 2) / 4;
3498 cpi->long_rolling_target_bits =
3499 ((cpi->long_rolling_target_bits * 31) + cpi->this_frame_target + 16) / 32;
3500 cpi->long_rolling_actual_bits =
3501 ((cpi->long_rolling_actual_bits * 31) +
3502 cpi->projected_frame_size + 16) / 32;
3503 }
3505 // Actual bits spent
3506 cpi->total_actual_bits += cpi->projected_frame_size;
3508 // Debug stats
3509 cpi->total_target_vs_actual += (cpi->this_frame_target -
3510 cpi->projected_frame_size);
3512 cpi->buffer_level = cpi->bits_off_target;
3514 #ifndef DISABLE_RC_LONG_TERM_MEM
3515 // Update bits left to the kf and gf groups to account for overshoot or
3516 // undershoot on these frames
3517 if (cm->frame_type == KEY_FRAME) {
3518 cpi->twopass.kf_group_bits += cpi->this_frame_target -
3519 cpi->projected_frame_size;
3521 cpi->twopass.kf_group_bits = MAX(cpi->twopass.kf_group_bits, 0);
3522 } else if (cpi->refresh_golden_frame || cpi->refresh_alt_ref_frame) {
3523 cpi->twopass.gf_group_bits += cpi->this_frame_target -
3524 cpi->projected_frame_size;
3526 cpi->twopass.gf_group_bits = MAX(cpi->twopass.gf_group_bits, 0);
3527 }
3528 #endif
3530 #if 0
3531 output_frame_level_debug_stats(cpi);
3532 #endif
3533 if (cpi->refresh_golden_frame == 1)
3534 cm->frame_flags = cm->frame_flags | FRAMEFLAGS_GOLDEN;
3535 else
3536 cm->frame_flags = cm->frame_flags&~FRAMEFLAGS_GOLDEN;
3538 if (cpi->refresh_alt_ref_frame == 1)
3539 cm->frame_flags = cm->frame_flags | FRAMEFLAGS_ALTREF;
3540 else
3541 cm->frame_flags = cm->frame_flags&~FRAMEFLAGS_ALTREF;
3544 if (cpi->refresh_last_frame & cpi->refresh_golden_frame)
3545 cpi->gold_is_last = 1;
3546 else if (cpi->refresh_last_frame ^ cpi->refresh_golden_frame)
3547 cpi->gold_is_last = 0;
3549 if (cpi->refresh_last_frame & cpi->refresh_alt_ref_frame)
3550 cpi->alt_is_last = 1;
3551 else if (cpi->refresh_last_frame ^ cpi->refresh_alt_ref_frame)
3552 cpi->alt_is_last = 0;
3554 if (cpi->refresh_alt_ref_frame & cpi->refresh_golden_frame)
3555 cpi->gold_is_alt = 1;
3556 else if (cpi->refresh_alt_ref_frame ^ cpi->refresh_golden_frame)
3557 cpi->gold_is_alt = 0;
3559 cpi->ref_frame_flags = VP9_ALT_FLAG | VP9_GOLD_FLAG | VP9_LAST_FLAG;
3561 if (cpi->gold_is_last)
3562 cpi->ref_frame_flags &= ~VP9_GOLD_FLAG;
3564 if (cpi->alt_is_last)
3565 cpi->ref_frame_flags &= ~VP9_ALT_FLAG;
3567 if (cpi->gold_is_alt)
3568 cpi->ref_frame_flags &= ~VP9_ALT_FLAG;
3570 if (cpi->oxcf.play_alternate && cpi->refresh_alt_ref_frame
3571 && (cm->frame_type != KEY_FRAME))
3572 // Update the alternate reference frame stats as appropriate.
3573 update_alt_ref_frame_stats(cpi);
3574 else
3575 // Update the Golden frame stats as appropriate.
3576 update_golden_frame_stats(cpi);
3578 if (cm->frame_type == KEY_FRAME) {
3579 // Tell the caller that the frame was coded as a key frame
3580 *frame_flags = cm->frame_flags | FRAMEFLAGS_KEY;
3582 #if CONFIG_MULTIPLE_ARF
3583 // Reset the sequence number.
3584 if (cpi->multi_arf_enabled) {
3585 cpi->sequence_number = 0;
3586 cpi->frame_coding_order_period = cpi->new_frame_coding_order_period;
3587 cpi->new_frame_coding_order_period = -1;
3588 }
3589 #endif
3591 // As this frame is a key frame the next defaults to an inter frame.
3592 cm->frame_type = INTER_FRAME;
3593 } else {
3594 *frame_flags = cm->frame_flags&~FRAMEFLAGS_KEY;
3596 #if CONFIG_MULTIPLE_ARF
3597 /* Increment position in the coded frame sequence. */
3598 if (cpi->multi_arf_enabled) {
3599 ++cpi->sequence_number;
3600 if (cpi->sequence_number >= cpi->frame_coding_order_period) {
3601 cpi->sequence_number = 0;
3602 cpi->frame_coding_order_period = cpi->new_frame_coding_order_period;
3603 cpi->new_frame_coding_order_period = -1;
3604 }
3605 cpi->this_frame_weight = cpi->arf_weight[cpi->sequence_number];
3606 assert(cpi->this_frame_weight >= 0);
3607 }
3608 #endif
3609 }
3611 // Clear the one shot update flags for segmentation map and mode/ref loop
3612 // filter deltas.
3613 cm->seg.update_map = 0;
3614 cm->seg.update_data = 0;
3615 cm->lf.mode_ref_delta_update = 0;
3617 // keep track of the last coded dimensions
3618 cm->last_width = cm->width;
3619 cm->last_height = cm->height;
3621 // reset to normal state now that we are done.
3622 cm->last_show_frame = cm->show_frame;
3623 if (cm->show_frame) {
3624 // current mip will be the prev_mip for the next frame
3625 MODE_INFO *temp = cm->prev_mip;
3626 MODE_INFO **temp2 = cm->prev_mi_grid_base;
3627 cm->prev_mip = cm->mip;
3628 cm->mip = temp;
3629 cm->prev_mi_grid_base = cm->mi_grid_base;
3630 cm->mi_grid_base = temp2;
3632 // update the upper left visible macroblock ptrs
3633 cm->mi = cm->mip + cm->mode_info_stride + 1;
3634 cm->mi_grid_visible = cm->mi_grid_base + cm->mode_info_stride + 1;
3636 cpi->mb.e_mbd.mi_8x8 = cm->mi_grid_visible;
3637 cpi->mb.e_mbd.mi_8x8[0] = cm->mi;
3639 // Don't increment frame counters if this was an altref buffer
3640 // update not a real frame
3641 ++cm->current_video_frame;
3642 ++cpi->frames_since_key;
3643 }
3644 // restore prev_mi
3645 cm->prev_mi = cm->prev_mip + cm->mode_info_stride + 1;
3646 cm->prev_mi_grid_visible = cm->prev_mi_grid_base + cm->mode_info_stride + 1;
3647 }
3649 static void Pass2Encode(VP9_COMP *cpi, unsigned long *size,
3650 unsigned char *dest, unsigned int *frame_flags) {
3651 cpi->enable_encode_breakout = 1;
3653 if (!cpi->refresh_alt_ref_frame)
3654 vp9_second_pass(cpi);
3656 encode_frame_to_data_rate(cpi, size, dest, frame_flags);
3657 // vp9_print_modes_and_motion_vectors(&cpi->common, "encode.stt");
3658 #ifdef DISABLE_RC_LONG_TERM_MEM
3659 cpi->twopass.bits_left -= cpi->this_frame_target;
3660 #else
3661 cpi->twopass.bits_left -= 8 * *size;
3662 #endif
3664 if (!cpi->refresh_alt_ref_frame) {
3665 double lower_bounds_min_rate = FRAME_OVERHEAD_BITS * cpi->oxcf.framerate;
3666 double two_pass_min_rate = (double)(cpi->oxcf.target_bandwidth
3667 * cpi->oxcf.two_pass_vbrmin_section
3668 / 100);
3670 if (two_pass_min_rate < lower_bounds_min_rate)
3671 two_pass_min_rate = lower_bounds_min_rate;
3673 cpi->twopass.bits_left += (int64_t)(two_pass_min_rate
3674 / cpi->oxcf.framerate);
3675 }
3676 }
3678 static void check_initial_width(VP9_COMP *cpi, YV12_BUFFER_CONFIG *sd) {
3679 VP9_COMMON *cm = &cpi->common;
3680 if (!cpi->initial_width) {
3681 // TODO(jkoleszar): Support 1/4 subsampling?
3682 cm->subsampling_x = (sd != NULL) && sd->uv_width < sd->y_width;
3683 cm->subsampling_y = (sd != NULL) && sd->uv_height < sd->y_height;
3684 alloc_raw_frame_buffers(cpi);
3686 cpi->initial_width = cm->width;
3687 cpi->initial_height = cm->height;
3688 }
3689 }
3692 int vp9_receive_raw_frame(VP9_PTR ptr, unsigned int frame_flags,
3693 YV12_BUFFER_CONFIG *sd, int64_t time_stamp,
3694 int64_t end_time) {
3695 VP9_COMP *cpi = (VP9_COMP *) ptr;
3696 struct vpx_usec_timer timer;
3697 int res = 0;
3699 check_initial_width(cpi, sd);
3700 vpx_usec_timer_start(&timer);
3701 if (vp9_lookahead_push(cpi->lookahead, sd, time_stamp, end_time, frame_flags,
3702 cpi->active_map_enabled ? cpi->active_map : NULL))
3703 res = -1;
3704 vpx_usec_timer_mark(&timer);
3705 cpi->time_receive_data += vpx_usec_timer_elapsed(&timer);
3707 return res;
3708 }
3711 static int frame_is_reference(const VP9_COMP *cpi) {
3712 const VP9_COMMON *cm = &cpi->common;
3714 return cm->frame_type == KEY_FRAME ||
3715 cpi->refresh_last_frame ||
3716 cpi->refresh_golden_frame ||
3717 cpi->refresh_alt_ref_frame ||
3718 cm->refresh_frame_context ||
3719 cm->lf.mode_ref_delta_update ||
3720 cm->seg.update_map ||
3721 cm->seg.update_data;
3722 }
3724 #if CONFIG_MULTIPLE_ARF
3725 int is_next_frame_arf(VP9_COMP *cpi) {
3726 // Negative entry in frame_coding_order indicates an ARF at this position.
3727 return cpi->frame_coding_order[cpi->sequence_number + 1] < 0 ? 1 : 0;
3728 }
3729 #endif
3731 int vp9_get_compressed_data(VP9_PTR ptr, unsigned int *frame_flags,
3732 unsigned long *size, unsigned char *dest,
3733 int64_t *time_stamp, int64_t *time_end, int flush) {
3734 VP9_COMP *cpi = (VP9_COMP *) ptr;
3735 VP9_COMMON *cm = &cpi->common;
3736 struct vpx_usec_timer cmptimer;
3737 YV12_BUFFER_CONFIG *force_src_buffer = NULL;
3738 int i;
3739 // FILE *fp_out = fopen("enc_frame_type.txt", "a");
3741 if (!cpi)
3742 return -1;
3744 vpx_usec_timer_start(&cmptimer);
3746 cpi->source = NULL;
3748 cpi->common.allow_high_precision_mv = ALTREF_HIGH_PRECISION_MV;
3749 set_mvcost(cpi);
3751 // Should we code an alternate reference frame.
3752 if (cpi->oxcf.play_alternate && cpi->source_alt_ref_pending) {
3753 int frames_to_arf;
3755 #if CONFIG_MULTIPLE_ARF
3756 assert(!cpi->multi_arf_enabled ||
3757 cpi->frame_coding_order[cpi->sequence_number] < 0);
3759 if (cpi->multi_arf_enabled && (cpi->pass == 2))
3760 frames_to_arf = (-cpi->frame_coding_order[cpi->sequence_number])
3761 - cpi->next_frame_in_order;
3762 else
3763 #endif
3764 frames_to_arf = cpi->frames_till_gf_update_due;
3766 assert(frames_to_arf < cpi->twopass.frames_to_key);
3768 if ((cpi->source = vp9_lookahead_peek(cpi->lookahead, frames_to_arf))) {
3769 #if CONFIG_MULTIPLE_ARF
3770 cpi->alt_ref_source[cpi->arf_buffered] = cpi->source;
3771 #else
3772 cpi->alt_ref_source = cpi->source;
3773 #endif
3775 if (cpi->oxcf.arnr_max_frames > 0) {
3776 // Produce the filtered ARF frame.
3777 // TODO(agrange) merge these two functions.
3778 configure_arnr_filter(cpi, cm->current_video_frame + frames_to_arf,
3779 cpi->gfu_boost);
3780 vp9_temporal_filter_prepare(cpi, frames_to_arf);
3781 vp9_extend_frame_borders(&cpi->alt_ref_buffer,
3782 cm->subsampling_x, cm->subsampling_y);
3783 force_src_buffer = &cpi->alt_ref_buffer;
3784 }
3786 cm->show_frame = 0;
3787 cpi->refresh_alt_ref_frame = 1;
3788 cpi->refresh_golden_frame = 0;
3789 cpi->refresh_last_frame = 0;
3790 cpi->is_src_frame_alt_ref = 0;
3792 // TODO(agrange) This needs to vary depending on where the next ARF is.
3793 cpi->frames_till_alt_ref_frame = frames_to_arf;
3795 #if CONFIG_MULTIPLE_ARF
3796 if (!cpi->multi_arf_enabled)
3797 #endif
3798 cpi->source_alt_ref_pending = 0; // Clear Pending altf Ref flag.
3799 }
3800 }
3802 if (!cpi->source) {
3803 #if CONFIG_MULTIPLE_ARF
3804 int i;
3805 #endif
3806 if ((cpi->source = vp9_lookahead_pop(cpi->lookahead, flush))) {
3807 cm->show_frame = 1;
3808 cm->intra_only = 0;
3810 #if CONFIG_MULTIPLE_ARF
3811 // Is this frame the ARF overlay.
3812 cpi->is_src_frame_alt_ref = 0;
3813 for (i = 0; i < cpi->arf_buffered; ++i) {
3814 if (cpi->source == cpi->alt_ref_source[i]) {
3815 cpi->is_src_frame_alt_ref = 1;
3816 cpi->refresh_golden_frame = 1;
3817 break;
3818 }
3819 }
3820 #else
3821 cpi->is_src_frame_alt_ref = cpi->alt_ref_source
3822 && (cpi->source == cpi->alt_ref_source);
3823 #endif
3824 if (cpi->is_src_frame_alt_ref) {
3825 // Current frame is an ARF overlay frame.
3826 #if CONFIG_MULTIPLE_ARF
3827 cpi->alt_ref_source[i] = NULL;
3828 #else
3829 cpi->alt_ref_source = NULL;
3830 #endif
3831 // Don't refresh the last buffer for an ARF overlay frame. It will
3832 // become the GF so preserve last as an alternative prediction option.
3833 cpi->refresh_last_frame = 0;
3834 }
3835 #if CONFIG_MULTIPLE_ARF
3836 ++cpi->next_frame_in_order;
3837 #endif
3838 }
3839 }
3841 if (cpi->source) {
3842 cpi->un_scaled_source = cpi->Source = force_src_buffer ? force_src_buffer
3843 : &cpi->source->img;
3844 *time_stamp = cpi->source->ts_start;
3845 *time_end = cpi->source->ts_end;
3846 *frame_flags = cpi->source->flags;
3848 // fprintf(fp_out, " Frame:%d", cm->current_video_frame);
3849 #if CONFIG_MULTIPLE_ARF
3850 if (cpi->multi_arf_enabled) {
3851 // fprintf(fp_out, " seq_no:%d this_frame_weight:%d",
3852 // cpi->sequence_number, cpi->this_frame_weight);
3853 } else {
3854 // fprintf(fp_out, "\n");
3855 }
3856 #else
3857 // fprintf(fp_out, "\n");
3858 #endif
3860 #if CONFIG_MULTIPLE_ARF
3861 if ((cm->frame_type != KEY_FRAME) && (cpi->pass == 2))
3862 cpi->source_alt_ref_pending = is_next_frame_arf(cpi);
3863 #endif
3864 } else {
3865 *size = 0;
3866 if (flush && cpi->pass == 1 && !cpi->twopass.first_pass_done) {
3867 vp9_end_first_pass(cpi); /* get last stats packet */
3868 cpi->twopass.first_pass_done = 1;
3869 }
3871 // fclose(fp_out);
3872 return -1;
3873 }
3875 if (cpi->source->ts_start < cpi->first_time_stamp_ever) {
3876 cpi->first_time_stamp_ever = cpi->source->ts_start;
3877 cpi->last_end_time_stamp_seen = cpi->source->ts_start;
3878 }
3880 // adjust frame rates based on timestamps given
3881 if (!cpi->refresh_alt_ref_frame) {
3882 int64_t this_duration;
3883 int step = 0;
3885 if (cpi->source->ts_start == cpi->first_time_stamp_ever) {
3886 this_duration = cpi->source->ts_end - cpi->source->ts_start;
3887 step = 1;
3888 } else {
3889 int64_t last_duration = cpi->last_end_time_stamp_seen
3890 - cpi->last_time_stamp_seen;
3892 this_duration = cpi->source->ts_end - cpi->last_end_time_stamp_seen;
3894 // do a step update if the duration changes by 10%
3895 if (last_duration)
3896 step = (int)((this_duration - last_duration) * 10 / last_duration);
3897 }
3899 if (this_duration) {
3900 if (step) {
3901 vp9_new_framerate(cpi, 10000000.0 / this_duration);
3902 } else {
3903 // Average this frame's rate into the last second's average
3904 // frame rate. If we haven't seen 1 second yet, then average
3905 // over the whole interval seen.
3906 const double interval = MIN((double)(cpi->source->ts_end
3907 - cpi->first_time_stamp_ever), 10000000.0);
3908 double avg_duration = 10000000.0 / cpi->oxcf.framerate;
3909 avg_duration *= (interval - avg_duration + this_duration);
3910 avg_duration /= interval;
3912 vp9_new_framerate(cpi, 10000000.0 / avg_duration);
3913 }
3914 }
3916 cpi->last_time_stamp_seen = cpi->source->ts_start;
3917 cpi->last_end_time_stamp_seen = cpi->source->ts_end;
3918 }
3920 // start with a 0 size frame
3921 *size = 0;
3923 // Clear down mmx registers
3924 vp9_clear_system_state(); // __asm emms;
3926 /* find a free buffer for the new frame, releasing the reference previously
3927 * held.
3928 */
3929 cm->fb_idx_ref_cnt[cm->new_fb_idx]--;
3930 cm->new_fb_idx = get_free_fb(cm);
3932 #if CONFIG_MULTIPLE_ARF
3933 /* Set up the correct ARF frame. */
3934 if (cpi->refresh_alt_ref_frame) {
3935 ++cpi->arf_buffered;
3936 }
3937 if (cpi->multi_arf_enabled && (cm->frame_type != KEY_FRAME) &&
3938 (cpi->pass == 2)) {
3939 cpi->alt_fb_idx = cpi->arf_buffer_idx[cpi->sequence_number];
3940 }
3941 #endif
3943 /* Get the mapping of L/G/A to the reference buffer pool */
3944 cm->active_ref_idx[0] = cm->ref_frame_map[cpi->lst_fb_idx];
3945 cm->active_ref_idx[1] = cm->ref_frame_map[cpi->gld_fb_idx];
3946 cm->active_ref_idx[2] = cm->ref_frame_map[cpi->alt_fb_idx];
3948 #if 0 // CONFIG_MULTIPLE_ARF
3949 if (cpi->multi_arf_enabled) {
3950 fprintf(fp_out, " idx(%d, %d, %d, %d) active(%d, %d, %d)",
3951 cpi->lst_fb_idx, cpi->gld_fb_idx, cpi->alt_fb_idx, cm->new_fb_idx,
3952 cm->active_ref_idx[0], cm->active_ref_idx[1], cm->active_ref_idx[2]);
3953 if (cpi->refresh_alt_ref_frame)
3954 fprintf(fp_out, " type:ARF");
3955 if (cpi->is_src_frame_alt_ref)
3956 fprintf(fp_out, " type:OVERLAY[%d]", cpi->alt_fb_idx);
3957 fprintf(fp_out, "\n");
3958 }
3959 #endif
3961 cm->frame_type = INTER_FRAME;
3962 cm->frame_flags = *frame_flags;
3964 // Reset the frame pointers to the current frame size
3965 vp9_realloc_frame_buffer(get_frame_new_buffer(cm),
3966 cm->width, cm->height,
3967 cm->subsampling_x, cm->subsampling_y,
3968 VP9BORDERINPIXELS);
3970 // Calculate scaling factors for each of the 3 available references
3971 for (i = 0; i < ALLOWED_REFS_PER_FRAME; ++i)
3972 vp9_setup_scale_factors(cm, i);
3974 vp9_setup_interp_filters(&cpi->mb.e_mbd, DEFAULT_INTERP_FILTER, cm);
3976 if (cpi->oxcf.aq_mode == VARIANCE_AQ) {
3977 vp9_vaq_init();
3978 }
3980 if (cpi->pass == 1) {
3981 Pass1Encode(cpi, size, dest, frame_flags);
3982 } else if (cpi->pass == 2) {
3983 Pass2Encode(cpi, size, dest, frame_flags);
3984 } else {
3985 encode_frame_to_data_rate(cpi, size, dest, frame_flags);
3986 }
3988 if (cm->refresh_frame_context)
3989 cm->frame_contexts[cm->frame_context_idx] = cm->fc;
3991 if (*size > 0) {
3992 // if its a dropped frame honor the requests on subsequent frames
3993 cpi->droppable = !frame_is_reference(cpi);
3995 // return to normal state
3996 cm->reset_frame_context = 0;
3997 cm->refresh_frame_context = 1;
3998 cpi->refresh_alt_ref_frame = 0;
3999 cpi->refresh_golden_frame = 0;
4000 cpi->refresh_last_frame = 1;
4001 cm->frame_type = INTER_FRAME;
4002 }
4004 vpx_usec_timer_mark(&cmptimer);
4005 cpi->time_compress_data += vpx_usec_timer_elapsed(&cmptimer);
4007 if (cpi->b_calculate_psnr && cpi->pass != 1 && cm->show_frame)
4008 generate_psnr_packet(cpi);
4010 #if CONFIG_INTERNAL_STATS
4012 if (cpi->pass != 1) {
4013 cpi->bytes += *size;
4015 if (cm->show_frame) {
4016 cpi->count++;
4018 if (cpi->b_calculate_psnr) {
4019 double ye, ue, ve;
4020 double frame_psnr;
4021 YV12_BUFFER_CONFIG *orig = cpi->Source;
4022 YV12_BUFFER_CONFIG *recon = cpi->common.frame_to_show;
4023 YV12_BUFFER_CONFIG *pp = &cm->post_proc_buffer;
4024 int y_samples = orig->y_height * orig->y_width;
4025 int uv_samples = orig->uv_height * orig->uv_width;
4026 int t_samples = y_samples + 2 * uv_samples;
4027 double sq_error;
4029 ye = (double)calc_plane_error(orig->y_buffer, orig->y_stride,
4030 recon->y_buffer, recon->y_stride,
4031 orig->y_crop_width, orig->y_crop_height);
4033 ue = (double)calc_plane_error(orig->u_buffer, orig->uv_stride,
4034 recon->u_buffer, recon->uv_stride,
4035 orig->uv_crop_width, orig->uv_crop_height);
4037 ve = (double)calc_plane_error(orig->v_buffer, orig->uv_stride,
4038 recon->v_buffer, recon->uv_stride,
4039 orig->uv_crop_width, orig->uv_crop_height);
4041 sq_error = ye + ue + ve;
4043 frame_psnr = vp9_mse2psnr(t_samples, 255.0, sq_error);
4045 cpi->total_y += vp9_mse2psnr(y_samples, 255.0, ye);
4046 cpi->total_u += vp9_mse2psnr(uv_samples, 255.0, ue);
4047 cpi->total_v += vp9_mse2psnr(uv_samples, 255.0, ve);
4048 cpi->total_sq_error += sq_error;
4049 cpi->total += frame_psnr;
4050 {
4051 double frame_psnr2, frame_ssim2 = 0;
4052 double weight = 0;
4053 #if CONFIG_VP9_POSTPROC
4054 vp9_deblock(cm->frame_to_show, &cm->post_proc_buffer,
4055 cm->lf.filter_level * 10 / 6);
4056 #endif
4057 vp9_clear_system_state();
4059 ye = (double)calc_plane_error(orig->y_buffer, orig->y_stride,
4060 pp->y_buffer, pp->y_stride,
4061 orig->y_crop_width, orig->y_crop_height);
4063 ue = (double)calc_plane_error(orig->u_buffer, orig->uv_stride,
4064 pp->u_buffer, pp->uv_stride,
4065 orig->uv_crop_width, orig->uv_crop_height);
4067 ve = (double)calc_plane_error(orig->v_buffer, orig->uv_stride,
4068 pp->v_buffer, pp->uv_stride,
4069 orig->uv_crop_width, orig->uv_crop_height);
4071 sq_error = ye + ue + ve;
4073 frame_psnr2 = vp9_mse2psnr(t_samples, 255.0, sq_error);
4075 cpi->totalp_y += vp9_mse2psnr(y_samples, 255.0, ye);
4076 cpi->totalp_u += vp9_mse2psnr(uv_samples, 255.0, ue);
4077 cpi->totalp_v += vp9_mse2psnr(uv_samples, 255.0, ve);
4078 cpi->total_sq_error2 += sq_error;
4079 cpi->totalp += frame_psnr2;
4081 frame_ssim2 = vp9_calc_ssim(cpi->Source,
4082 recon, 1, &weight);
4084 cpi->summed_quality += frame_ssim2 * weight;
4085 cpi->summed_weights += weight;
4087 frame_ssim2 = vp9_calc_ssim(cpi->Source,
4088 &cm->post_proc_buffer, 1, &weight);
4090 cpi->summedp_quality += frame_ssim2 * weight;
4091 cpi->summedp_weights += weight;
4092 #if 0
4093 {
4094 FILE *f = fopen("q_used.stt", "a");
4095 fprintf(f, "%5d : Y%f7.3:U%f7.3:V%f7.3:F%f7.3:S%7.3f\n",
4096 cpi->common.current_video_frame, y2, u2, v2,
4097 frame_psnr2, frame_ssim2);
4098 fclose(f);
4099 }
4100 #endif
4101 }
4102 }
4104 if (cpi->b_calculate_ssimg) {
4105 double y, u, v, frame_all;
4106 frame_all = vp9_calc_ssimg(cpi->Source, cm->frame_to_show,
4107 &y, &u, &v);
4108 cpi->total_ssimg_y += y;
4109 cpi->total_ssimg_u += u;
4110 cpi->total_ssimg_v += v;
4111 cpi->total_ssimg_all += frame_all;
4112 }
4113 }
4114 }
4116 #endif
4117 // fclose(fp_out);
4118 return 0;
4119 }
4121 int vp9_get_preview_raw_frame(VP9_PTR comp, YV12_BUFFER_CONFIG *dest,
4122 vp9_ppflags_t *flags) {
4123 VP9_COMP *cpi = (VP9_COMP *) comp;
4125 if (!cpi->common.show_frame) {
4126 return -1;
4127 } else {
4128 int ret;
4129 #if CONFIG_VP9_POSTPROC
4130 ret = vp9_post_proc_frame(&cpi->common, dest, flags);
4131 #else
4133 if (cpi->common.frame_to_show) {
4134 *dest = *cpi->common.frame_to_show;
4135 dest->y_width = cpi->common.width;
4136 dest->y_height = cpi->common.height;
4137 dest->uv_height = cpi->common.height / 2;
4138 ret = 0;
4139 } else {
4140 ret = -1;
4141 }
4143 #endif // !CONFIG_VP9_POSTPROC
4144 vp9_clear_system_state();
4145 return ret;
4146 }
4147 }
4149 int vp9_set_roimap(VP9_PTR comp, unsigned char *map, unsigned int rows,
4150 unsigned int cols, int delta_q[MAX_SEGMENTS],
4151 int delta_lf[MAX_SEGMENTS],
4152 unsigned int threshold[MAX_SEGMENTS]) {
4153 VP9_COMP *cpi = (VP9_COMP *) comp;
4154 signed char feature_data[SEG_LVL_MAX][MAX_SEGMENTS];
4155 struct segmentation *seg = &cpi->common.seg;
4156 int i;
4158 if (cpi->common.mb_rows != rows || cpi->common.mb_cols != cols)
4159 return -1;
4161 if (!map) {
4162 vp9_disable_segmentation((VP9_PTR)cpi);
4163 return 0;
4164 }
4166 // Set the segmentation Map
4167 vp9_set_segmentation_map((VP9_PTR)cpi, map);
4169 // Activate segmentation.
4170 vp9_enable_segmentation((VP9_PTR)cpi);
4172 // Set up the quant, LF and breakout threshold segment data
4173 for (i = 0; i < MAX_SEGMENTS; i++) {
4174 feature_data[SEG_LVL_ALT_Q][i] = delta_q[i];
4175 feature_data[SEG_LVL_ALT_LF][i] = delta_lf[i];
4176 cpi->segment_encode_breakout[i] = threshold[i];
4177 }
4179 // Enable the loop and quant changes in the feature mask
4180 for (i = 0; i < MAX_SEGMENTS; i++) {
4181 if (delta_q[i])
4182 vp9_enable_segfeature(seg, i, SEG_LVL_ALT_Q);
4183 else
4184 vp9_disable_segfeature(seg, i, SEG_LVL_ALT_Q);
4186 if (delta_lf[i])
4187 vp9_enable_segfeature(seg, i, SEG_LVL_ALT_LF);
4188 else
4189 vp9_disable_segfeature(seg, i, SEG_LVL_ALT_LF);
4190 }
4192 // Initialize the feature data structure
4193 // SEGMENT_DELTADATA 0, SEGMENT_ABSDATA 1
4194 vp9_set_segment_data((VP9_PTR)cpi, &feature_data[0][0], SEGMENT_DELTADATA);
4196 return 0;
4197 }
4199 int vp9_set_active_map(VP9_PTR comp, unsigned char *map,
4200 unsigned int rows, unsigned int cols) {
4201 VP9_COMP *cpi = (VP9_COMP *) comp;
4203 if (rows == cpi->common.mb_rows && cols == cpi->common.mb_cols) {
4204 if (map) {
4205 vpx_memcpy(cpi->active_map, map, rows * cols);
4206 cpi->active_map_enabled = 1;
4207 } else {
4208 cpi->active_map_enabled = 0;
4209 }
4211 return 0;
4212 } else {
4213 // cpi->active_map_enabled = 0;
4214 return -1;
4215 }
4216 }
4218 int vp9_set_internal_size(VP9_PTR comp,
4219 VPX_SCALING horiz_mode, VPX_SCALING vert_mode) {
4220 VP9_COMP *cpi = (VP9_COMP *) comp;
4221 VP9_COMMON *cm = &cpi->common;
4222 int hr = 0, hs = 0, vr = 0, vs = 0;
4224 if (horiz_mode > ONETWO || vert_mode > ONETWO)
4225 return -1;
4227 Scale2Ratio(horiz_mode, &hr, &hs);
4228 Scale2Ratio(vert_mode, &vr, &vs);
4230 // always go to the next whole number
4231 cm->width = (hs - 1 + cpi->oxcf.width * hr) / hs;
4232 cm->height = (vs - 1 + cpi->oxcf.height * vr) / vs;
4234 assert(cm->width <= cpi->initial_width);
4235 assert(cm->height <= cpi->initial_height);
4236 update_frame_size(cpi);
4237 return 0;
4238 }
4240 int vp9_set_size_literal(VP9_PTR comp, unsigned int width,
4241 unsigned int height) {
4242 VP9_COMP *cpi = (VP9_COMP *)comp;
4243 VP9_COMMON *cm = &cpi->common;
4245 check_initial_width(cpi, NULL);
4247 if (width) {
4248 cm->width = width;
4249 if (cm->width * 5 < cpi->initial_width) {
4250 cm->width = cpi->initial_width / 5 + 1;
4251 printf("Warning: Desired width too small, changed to %d \n", cm->width);
4252 }
4253 if (cm->width > cpi->initial_width) {
4254 cm->width = cpi->initial_width;
4255 printf("Warning: Desired width too large, changed to %d \n", cm->width);
4256 }
4257 }
4259 if (height) {
4260 cm->height = height;
4261 if (cm->height * 5 < cpi->initial_height) {
4262 cm->height = cpi->initial_height / 5 + 1;
4263 printf("Warning: Desired height too small, changed to %d \n", cm->height);
4264 }
4265 if (cm->height > cpi->initial_height) {
4266 cm->height = cpi->initial_height;
4267 printf("Warning: Desired height too large, changed to %d \n", cm->height);
4268 }
4269 }
4271 assert(cm->width <= cpi->initial_width);
4272 assert(cm->height <= cpi->initial_height);
4273 update_frame_size(cpi);
4274 return 0;
4275 }
4277 void vp9_set_svc(VP9_PTR comp, int use_svc) {
4278 VP9_COMP *cpi = (VP9_COMP *)comp;
4279 cpi->use_svc = use_svc;
4280 return;
4281 }
4283 int vp9_calc_ss_err(YV12_BUFFER_CONFIG *source, YV12_BUFFER_CONFIG *dest) {
4284 int i, j;
4285 int total = 0;
4287 uint8_t *src = source->y_buffer;
4288 uint8_t *dst = dest->y_buffer;
4290 // Loop through the Y plane raw and reconstruction data summing
4291 // (square differences)
4292 for (i = 0; i < source->y_height; i += 16) {
4293 for (j = 0; j < source->y_width; j += 16) {
4294 unsigned int sse;
4295 total += vp9_mse16x16(src + j, source->y_stride, dst + j, dest->y_stride,
4296 &sse);
4297 }
4299 src += 16 * source->y_stride;
4300 dst += 16 * dest->y_stride;
4301 }
4303 return total;
4304 }
4307 int vp9_get_quantizer(VP9_PTR c) {
4308 return ((VP9_COMP *)c)->common.base_qindex;
4309 }
