The Tor Browser / file comparison
comparison: media/libvpx/vp9/encoder/vp9_picklpf.c
media/libvpx/vp9/encoder/vp9_picklpf.c
- branch
- TOR_BUG_9701
- changeset 10
- ac0c01689b40
equal
deleted
inserted
replaced
| -1:000000000000 | 0:1d5bb0b16c67 |
|---|---|
| 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 #include "vp9/common/vp9_onyxc_int.h" | |
| 14 #include "vp9/encoder/vp9_onyx_int.h" | |
| 15 #include "vp9/encoder/vp9_picklpf.h" | |
| 16 #include "vp9/encoder/vp9_quantize.h" | |
| 17 #include "vpx_mem/vpx_mem.h" | |
| 18 #include "vpx_scale/vpx_scale.h" | |
| 19 #include "vp9/common/vp9_alloccommon.h" | |
| 20 #include "vp9/common/vp9_loopfilter.h" | |
| 21 #include "./vpx_scale_rtcd.h" | |
| 22 | |
| 23 void vp9_yv12_copy_partial_frame_c(YV12_BUFFER_CONFIG *src_ybc, | |
| 24 YV12_BUFFER_CONFIG *dst_ybc, int fraction) { | |
| 25 const int height = src_ybc->y_height; | |
| 26 const int stride = src_ybc->y_stride; | |
| 27 const int offset = stride * ((height >> 5) * 16 - 8); | |
| 28 const int lines_to_copy = MAX(height >> (fraction + 4), 1) << 4; | |
| 29 | |
| 30 assert(src_ybc->y_stride == dst_ybc->y_stride); | |
| 31 vpx_memcpy(dst_ybc->y_buffer + offset, src_ybc->y_buffer + offset, | |
| 32 stride * (lines_to_copy + 16)); | |
| 33 } | |
| 34 | |
| 35 static int calc_partial_ssl_err(YV12_BUFFER_CONFIG *source, | |
| 36 YV12_BUFFER_CONFIG *dest, int Fraction) { | |
| 37 int i, j; | |
| 38 int Total = 0; | |
| 39 int srcoffset, dstoffset; | |
| 40 uint8_t *src = source->y_buffer; | |
| 41 uint8_t *dst = dest->y_buffer; | |
| 42 | |
| 43 int linestocopy = (source->y_height >> (Fraction + 4)); | |
| 44 | |
| 45 if (linestocopy < 1) | |
| 46 linestocopy = 1; | |
| 47 | |
| 48 linestocopy <<= 4; | |
| 49 | |
| 50 | |
| 51 srcoffset = source->y_stride * (dest->y_height >> 5) * 16; | |
| 52 dstoffset = dest->y_stride * (dest->y_height >> 5) * 16; | |
| 53 | |
| 54 src += srcoffset; | |
| 55 dst += dstoffset; | |
| 56 | |
| 57 // Loop through the raw Y plane and reconstruction data summing the square | |
| 58 // differences. | |
| 59 for (i = 0; i < linestocopy; i += 16) { | |
| 60 for (j = 0; j < source->y_width; j += 16) { | |
| 61 unsigned int sse; | |
| 62 Total += vp9_mse16x16(src + j, source->y_stride, dst + j, dest->y_stride, | |
| 63 &sse); | |
| 64 } | |
| 65 | |
| 66 src += 16 * source->y_stride; | |
| 67 dst += 16 * dest->y_stride; | |
| 68 } | |
| 69 | |
| 70 return Total; | |
| 71 } | |
| 72 | |
| 73 // Enforce a minimum filter level based upon baseline Q | |
| 74 static int get_min_filter_level(VP9_COMP *cpi, int base_qindex) { | |
| 75 int min_filter_level; | |
| 76 min_filter_level = 0; | |
| 77 | |
| 78 return min_filter_level; | |
| 79 } | |
| 80 | |
| 81 // Enforce a maximum filter level based upon baseline Q | |
| 82 static int get_max_filter_level(VP9_COMP *cpi, int base_qindex) { | |
| 83 int max_filter_level = MAX_LOOP_FILTER; | |
| 84 (void)base_qindex; | |
| 85 | |
| 86 if (cpi->twopass.section_intra_rating > 8) | |
| 87 max_filter_level = MAX_LOOP_FILTER * 3 / 4; | |
| 88 | |
| 89 return max_filter_level; | |
| 90 } | |
| 91 | |
| 92 | |
| 93 // Stub function for now Alt LF not used | |
| 94 void vp9_set_alt_lf_level(VP9_COMP *cpi, int filt_val) { | |
| 95 } | |
| 96 | |
| 97 void vp9_pick_filter_level(YV12_BUFFER_CONFIG *sd, VP9_COMP *cpi, int partial) { | |
| 98 VP9_COMMON *const cm = &cpi->common; | |
| 99 struct loopfilter *const lf = &cm->lf; | |
| 100 | |
| 101 int best_err = 0; | |
| 102 int filt_err = 0; | |
| 103 const int min_filter_level = get_min_filter_level(cpi, cm->base_qindex); | |
| 104 const int max_filter_level = get_max_filter_level(cpi, cm->base_qindex); | |
| 105 | |
| 106 int filter_step; | |
| 107 int filt_high = 0; | |
| 108 // Start search at previous frame filter level | |
| 109 int filt_mid = lf->filter_level; | |
| 110 int filt_low = 0; | |
| 111 int filt_best; | |
| 112 int filt_direction = 0; | |
| 113 | |
| 114 int Bias = 0; // Bias against raising loop filter in favor of lowering it. | |
| 115 | |
| 116 // Make a copy of the unfiltered / processed recon buffer | |
| 117 vpx_yv12_copy_y(cm->frame_to_show, &cpi->last_frame_uf); | |
| 118 | |
| 119 lf->sharpness_level = cm->frame_type == KEY_FRAME ? 0 | |
| 120 : cpi->oxcf.Sharpness; | |
| 121 | |
| 122 // Start the search at the previous frame filter level unless it is now out of | |
| 123 // range. | |
| 124 filt_mid = clamp(lf->filter_level, min_filter_level, max_filter_level); | |
| 125 | |
| 126 // Define the initial step size | |
| 127 filter_step = filt_mid < 16 ? 4 : filt_mid / 4; | |
| 128 | |
| 129 // Get baseline error score | |
| 130 vp9_set_alt_lf_level(cpi, filt_mid); | |
| 131 vp9_loop_filter_frame(cm, &cpi->mb.e_mbd, filt_mid, 1, partial); | |
| 132 | |
| 133 best_err = vp9_calc_ss_err(sd, cm->frame_to_show); | |
| 134 filt_best = filt_mid; | |
| 135 | |
| 136 // Re-instate the unfiltered frame | |
| 137 vpx_yv12_copy_y(&cpi->last_frame_uf, cm->frame_to_show); | |
| 138 | |
| 139 while (filter_step > 0) { | |
| 140 Bias = (best_err >> (15 - (filt_mid / 8))) * filter_step; | |
| 141 | |
| 142 if (cpi->twopass.section_intra_rating < 20) | |
| 143 Bias = Bias * cpi->twopass.section_intra_rating / 20; | |
| 144 | |
| 145 // yx, bias less for large block size | |
| 146 if (cpi->common.tx_mode != ONLY_4X4) | |
| 147 Bias >>= 1; | |
| 148 | |
| 149 filt_high = ((filt_mid + filter_step) > max_filter_level) | |
| 150 ? max_filter_level | |
| 151 : (filt_mid + filter_step); | |
| 152 filt_low = ((filt_mid - filter_step) < min_filter_level) | |
| 153 ? min_filter_level | |
| 154 : (filt_mid - filter_step); | |
| 155 | |
| 156 if ((filt_direction <= 0) && (filt_low != filt_mid)) { | |
| 157 // Get Low filter error score | |
| 158 vp9_set_alt_lf_level(cpi, filt_low); | |
| 159 vp9_loop_filter_frame(cm, &cpi->mb.e_mbd, filt_low, 1, partial); | |
| 160 | |
| 161 filt_err = vp9_calc_ss_err(sd, cm->frame_to_show); | |
| 162 | |
| 163 // Re-instate the unfiltered frame | |
| 164 vpx_yv12_copy_y(&cpi->last_frame_uf, cm->frame_to_show); | |
| 165 | |
| 166 // If value is close to the best so far then bias towards a lower loop | |
| 167 // filter value. | |
| 168 if ((filt_err - Bias) < best_err) { | |
| 169 // Was it actually better than the previous best? | |
| 170 if (filt_err < best_err) | |
| 171 best_err = filt_err; | |
| 172 | |
| 173 filt_best = filt_low; | |
| 174 } | |
| 175 } | |
| 176 | |
| 177 // Now look at filt_high | |
| 178 if ((filt_direction >= 0) && (filt_high != filt_mid)) { | |
| 179 vp9_set_alt_lf_level(cpi, filt_high); | |
| 180 vp9_loop_filter_frame(cm, &cpi->mb.e_mbd, filt_high, 1, partial); | |
| 181 | |
| 182 filt_err = vp9_calc_ss_err(sd, cm->frame_to_show); | |
| 183 | |
| 184 // Re-instate the unfiltered frame | |
| 185 vpx_yv12_copy_y(&cpi->last_frame_uf, cm->frame_to_show); | |
| 186 | |
| 187 // Was it better than the previous best? | |
| 188 if (filt_err < (best_err - Bias)) { | |
| 189 best_err = filt_err; | |
| 190 filt_best = filt_high; | |
| 191 } | |
| 192 } | |
| 193 | |
| 194 // Half the step distance if the best filter value was the same as last time | |
| 195 if (filt_best == filt_mid) { | |
| 196 filter_step = filter_step / 2; | |
| 197 filt_direction = 0; | |
| 198 } else { | |
| 199 filt_direction = (filt_best < filt_mid) ? -1 : 1; | |
| 200 filt_mid = filt_best; | |
| 201 } | |
| 202 } | |
| 203 | |
| 204 lf->filter_level = filt_best; | |
| 205 } |
