1/* 2 * Copyright (c) 2010 The WebM project authors. All Rights Reserved. 3 * 4 * Use of this source code is governed by a BSD-style license 5 * that can be found in the LICENSE file in the root of the source 6 * tree. An additional intellectual property rights grant can be found 7 * in the file PATENTS. All contributing project authors may 8 * be found in the AUTHORS file in the root of the source tree. 9 */ 10 11#include <assert.h> 12#include <limits.h> 13 14#include "./vpx_scale_rtcd.h" 15 16#include "vpx_mem/vpx_mem.h" 17 18#include "vp9/common/vp9_loopfilter.h" 19#include "vp9/common/vp9_onyxc_int.h" 20#include "vp9/common/vp9_quant_common.h" 21 22#include "vp9/encoder/vp9_encoder.h" 23#include "vp9/encoder/vp9_picklpf.h" 24#include "vp9/encoder/vp9_quantize.h" 25 26static int get_max_filter_level(const VP9_COMP *cpi) { 27 if (cpi->oxcf.pass == 2) { 28 return cpi->twopass.section_intra_rating > 8 ? MAX_LOOP_FILTER * 3 / 4 29 : MAX_LOOP_FILTER; 30 } else { 31 return MAX_LOOP_FILTER; 32 } 33} 34 35 36static int try_filter_frame(const YV12_BUFFER_CONFIG *sd, VP9_COMP *const cpi, 37 int filt_level, int partial_frame) { 38 VP9_COMMON *const cm = &cpi->common; 39 int filt_err; 40 41 vp9_loop_filter_frame(cm->frame_to_show, cm, &cpi->mb.e_mbd, filt_level, 1, 42 partial_frame); 43 filt_err = vp9_get_y_sse(sd, cm->frame_to_show); 44 45 // Re-instate the unfiltered frame 46 vpx_yv12_copy_y(&cpi->last_frame_uf, cm->frame_to_show); 47 48 return filt_err; 49} 50 51static int search_filter_level(const YV12_BUFFER_CONFIG *sd, VP9_COMP *cpi, 52 int partial_frame) { 53 const VP9_COMMON *const cm = &cpi->common; 54 const struct loopfilter *const lf = &cm->lf; 55 const int min_filter_level = 0; 56 const int max_filter_level = get_max_filter_level(cpi); 57 int filt_direction = 0; 58 int best_err, filt_best; 59 60 // Start the search at the previous frame filter level unless it is now out of 61 // range. 62 int filt_mid = clamp(lf->filter_level, min_filter_level, max_filter_level); 63 int filter_step = filt_mid < 16 ? 4 : filt_mid / 4; 64 // Sum squared error at each filter level 65 int ss_err[MAX_LOOP_FILTER + 1]; 66 67 // Set each entry to -1 68 vpx_memset(ss_err, 0xFF, sizeof(ss_err)); 69 70 // Make a copy of the unfiltered / processed recon buffer 71 vpx_yv12_copy_y(cm->frame_to_show, &cpi->last_frame_uf); 72 73 best_err = try_filter_frame(sd, cpi, filt_mid, partial_frame); 74 filt_best = filt_mid; 75 ss_err[filt_mid] = best_err; 76 77 while (filter_step > 0) { 78 const int filt_high = MIN(filt_mid + filter_step, max_filter_level); 79 const int filt_low = MAX(filt_mid - filter_step, min_filter_level); 80 81 // Bias against raising loop filter in favor of lowering it. 82 int bias = (best_err >> (15 - (filt_mid / 8))) * filter_step; 83 84 if ((cpi->oxcf.pass == 2) && (cpi->twopass.section_intra_rating < 20)) 85 bias = (bias * cpi->twopass.section_intra_rating) / 20; 86 87 // yx, bias less for large block size 88 if (cm->tx_mode != ONLY_4X4) 89 bias >>= 1; 90 91 if (filt_direction <= 0 && filt_low != filt_mid) { 92 // Get Low filter error score 93 if (ss_err[filt_low] < 0) { 94 ss_err[filt_low] = try_filter_frame(sd, cpi, filt_low, partial_frame); 95 } 96 // If value is close to the best so far then bias towards a lower loop 97 // filter value. 98 if ((ss_err[filt_low] - bias) < best_err) { 99 // Was it actually better than the previous best? 100 if (ss_err[filt_low] < best_err) 101 best_err = ss_err[filt_low]; 102 103 filt_best = filt_low; 104 } 105 } 106 107 // Now look at filt_high 108 if (filt_direction >= 0 && filt_high != filt_mid) { 109 if (ss_err[filt_high] < 0) { 110 ss_err[filt_high] = try_filter_frame(sd, cpi, filt_high, partial_frame); 111 } 112 // Was it better than the previous best? 113 if (ss_err[filt_high] < (best_err - bias)) { 114 best_err = ss_err[filt_high]; 115 filt_best = filt_high; 116 } 117 } 118 119 // Half the step distance if the best filter value was the same as last time 120 if (filt_best == filt_mid) { 121 filter_step /= 2; 122 filt_direction = 0; 123 } else { 124 filt_direction = (filt_best < filt_mid) ? -1 : 1; 125 filt_mid = filt_best; 126 } 127 } 128 129 return filt_best; 130} 131 132void vp9_pick_filter_level(const YV12_BUFFER_CONFIG *sd, VP9_COMP *cpi, 133 LPF_PICK_METHOD method) { 134 VP9_COMMON *const cm = &cpi->common; 135 struct loopfilter *const lf = &cm->lf; 136 137 lf->sharpness_level = cm->frame_type == KEY_FRAME ? 0 138 : cpi->oxcf.sharpness; 139 140 if (method == LPF_PICK_MINIMAL_LPF && lf->filter_level) { 141 lf->filter_level = 0; 142 } else if (method >= LPF_PICK_FROM_Q) { 143 const int min_filter_level = 0; 144 const int max_filter_level = get_max_filter_level(cpi); 145 const int q = vp9_ac_quant(cm->base_qindex, 0, cm->bit_depth); 146 // These values were determined by linear fitting the result of the 147 // searched level, filt_guess = q * 0.316206 + 3.87252 148 int filt_guess = ROUND_POWER_OF_TWO(q * 20723 + 1015158, 18); 149 if (cm->frame_type == KEY_FRAME) 150 filt_guess -= 4; 151 lf->filter_level = clamp(filt_guess, min_filter_level, max_filter_level); 152 } else { 153 lf->filter_level = search_filter_level(sd, cpi, 154 method == LPF_PICK_FROM_SUBIMAGE); 155 } 156} 157