The Tor Browser / file comparison
comparison: media/libvpx/vp9/encoder/vp9_quantize.c
media/libvpx/vp9/encoder/vp9_quantize.c
- branch
- TOR_BUG_9701
- changeset 10
- ac0c01689b40
equal
deleted
inserted
replaced
| -1:000000000000 | 0:a80158efb120 |
|---|---|
| 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 <math.h> | |
| 12 #include "vpx_mem/vpx_mem.h" | |
| 13 | |
| 14 #include "vp9/encoder/vp9_onyx_int.h" | |
| 15 #include "vp9/encoder/vp9_rdopt.h" | |
| 16 #include "vp9/encoder/vp9_quantize.h" | |
| 17 #include "vp9/common/vp9_quant_common.h" | |
| 18 | |
| 19 #include "vp9/common/vp9_seg_common.h" | |
| 20 | |
| 21 #ifdef ENC_DEBUG | |
| 22 extern int enc_debug; | |
| 23 #endif | |
| 24 | |
| 25 void vp9_quantize_b_c(const int16_t *coeff_ptr, intptr_t count, | |
| 26 int skip_block, | |
| 27 const int16_t *zbin_ptr, const int16_t *round_ptr, | |
| 28 const int16_t *quant_ptr, const int16_t *quant_shift_ptr, | |
| 29 int16_t *qcoeff_ptr, int16_t *dqcoeff_ptr, | |
| 30 const int16_t *dequant_ptr, | |
| 31 int zbin_oq_value, uint16_t *eob_ptr, | |
| 32 const int16_t *scan, const int16_t *iscan) { | |
| 33 int i, non_zero_count = count, eob = -1; | |
| 34 const int zbins[2] = { zbin_ptr[0] + zbin_oq_value, | |
| 35 zbin_ptr[1] + zbin_oq_value }; | |
| 36 const int nzbins[2] = { zbins[0] * -1, | |
| 37 zbins[1] * -1 }; | |
| 38 | |
| 39 vpx_memset(qcoeff_ptr, 0, count * sizeof(int16_t)); | |
| 40 vpx_memset(dqcoeff_ptr, 0, count * sizeof(int16_t)); | |
| 41 | |
| 42 if (!skip_block) { | |
| 43 // Pre-scan pass | |
| 44 for (i = count - 1; i >= 0; i--) { | |
| 45 const int rc = scan[i]; | |
| 46 const int coeff = coeff_ptr[rc]; | |
| 47 | |
| 48 if (coeff < zbins[rc != 0] && coeff > nzbins[rc != 0]) | |
| 49 non_zero_count--; | |
| 50 else | |
| 51 break; | |
| 52 } | |
| 53 | |
| 54 // Quantization pass: All coefficients with index >= zero_flag are | |
| 55 // skippable. Note: zero_flag can be zero. | |
| 56 for (i = 0; i < non_zero_count; i++) { | |
| 57 const int rc = scan[i]; | |
| 58 const int coeff = coeff_ptr[rc]; | |
| 59 const int coeff_sign = (coeff >> 31); | |
| 60 const int abs_coeff = (coeff ^ coeff_sign) - coeff_sign; | |
| 61 | |
| 62 if (abs_coeff >= zbins[rc != 0]) { | |
| 63 int tmp = clamp(abs_coeff + round_ptr[rc != 0], INT16_MIN, INT16_MAX); | |
| 64 tmp = ((((tmp * quant_ptr[rc != 0]) >> 16) + tmp) * | |
| 65 quant_shift_ptr[rc != 0]) >> 16; // quantization | |
| 66 qcoeff_ptr[rc] = (tmp ^ coeff_sign) - coeff_sign; | |
| 67 dqcoeff_ptr[rc] = qcoeff_ptr[rc] * dequant_ptr[rc != 0]; | |
| 68 | |
| 69 if (tmp) | |
| 70 eob = i; | |
| 71 } | |
| 72 } | |
| 73 } | |
| 74 *eob_ptr = eob + 1; | |
| 75 } | |
| 76 | |
| 77 void vp9_quantize_b_32x32_c(const int16_t *coeff_ptr, intptr_t n_coeffs, | |
| 78 int skip_block, | |
| 79 const int16_t *zbin_ptr, const int16_t *round_ptr, | |
| 80 const int16_t *quant_ptr, | |
| 81 const int16_t *quant_shift_ptr, | |
| 82 int16_t *qcoeff_ptr, int16_t *dqcoeff_ptr, | |
| 83 const int16_t *dequant_ptr, | |
| 84 int zbin_oq_value, uint16_t *eob_ptr, | |
| 85 const int16_t *scan, const int16_t *iscan) { | |
| 86 int i, rc, eob; | |
| 87 int zbins[2], nzbins[2]; | |
| 88 int x, y, z, sz; | |
| 89 int idx = 0; | |
| 90 int idx_arr[1024]; | |
| 91 | |
| 92 vpx_memset(qcoeff_ptr, 0, n_coeffs*sizeof(int16_t)); | |
| 93 vpx_memset(dqcoeff_ptr, 0, n_coeffs*sizeof(int16_t)); | |
| 94 | |
| 95 eob = -1; | |
| 96 | |
| 97 // Base ZBIN | |
| 98 zbins[0] = ROUND_POWER_OF_TWO(zbin_ptr[0] + zbin_oq_value, 1); | |
| 99 zbins[1] = ROUND_POWER_OF_TWO(zbin_ptr[1] + zbin_oq_value, 1); | |
| 100 nzbins[0] = zbins[0] * -1; | |
| 101 nzbins[1] = zbins[1] * -1; | |
| 102 | |
| 103 if (!skip_block) { | |
| 104 // Pre-scan pass | |
| 105 for (i = 0; i < n_coeffs; i++) { | |
| 106 rc = scan[i]; | |
| 107 z = coeff_ptr[rc]; | |
| 108 | |
| 109 // If the coefficient is out of the base ZBIN range, keep it for | |
| 110 // quantization. | |
| 111 if (z >= zbins[rc != 0] || z <= nzbins[rc != 0]) | |
| 112 idx_arr[idx++] = i; | |
| 113 } | |
| 114 | |
| 115 // Quantization pass: only process the coefficients selected in | |
| 116 // pre-scan pass. Note: idx can be zero. | |
| 117 for (i = 0; i < idx; i++) { | |
| 118 rc = scan[idx_arr[i]]; | |
| 119 | |
| 120 z = coeff_ptr[rc]; | |
| 121 sz = (z >> 31); // sign of z | |
| 122 x = (z ^ sz) - sz; // x = abs(z) | |
| 123 | |
| 124 x += ROUND_POWER_OF_TWO(round_ptr[rc != 0], 1); | |
| 125 x = clamp(x, INT16_MIN, INT16_MAX); | |
| 126 y = ((((x * quant_ptr[rc != 0]) >> 16) + x) * | |
| 127 quant_shift_ptr[rc != 0]) >> 15; // quantize (x) | |
| 128 | |
| 129 x = (y ^ sz) - sz; // get the sign back | |
| 130 qcoeff_ptr[rc] = x; // write to destination | |
| 131 dqcoeff_ptr[rc] = x * dequant_ptr[rc != 0] / 2; // dequantized value | |
| 132 | |
| 133 if (y) | |
| 134 eob = idx_arr[i]; // last nonzero coeffs | |
| 135 } | |
| 136 } | |
| 137 *eob_ptr = eob + 1; | |
| 138 } | |
| 139 | |
| 140 struct plane_block_idx { | |
| 141 int plane; | |
| 142 int block; | |
| 143 }; | |
| 144 | |
| 145 // TODO(jkoleszar): returning a struct so it can be used in a const context, | |
| 146 // expect to refactor this further later. | |
| 147 static INLINE struct plane_block_idx plane_block_idx(int y_blocks, | |
| 148 int b_idx) { | |
| 149 const int v_offset = y_blocks * 5 / 4; | |
| 150 struct plane_block_idx res; | |
| 151 | |
| 152 if (b_idx < y_blocks) { | |
| 153 res.plane = 0; | |
| 154 res.block = b_idx; | |
| 155 } else if (b_idx < v_offset) { | |
| 156 res.plane = 1; | |
| 157 res.block = b_idx - y_blocks; | |
| 158 } else { | |
| 159 assert(b_idx < y_blocks * 3 / 2); | |
| 160 res.plane = 2; | |
| 161 res.block = b_idx - v_offset; | |
| 162 } | |
| 163 return res; | |
| 164 } | |
| 165 | |
| 166 void vp9_regular_quantize_b_4x4(MACROBLOCK *x, int y_blocks, int b_idx, | |
| 167 const int16_t *scan, const int16_t *iscan) { | |
| 168 MACROBLOCKD *const xd = &x->e_mbd; | |
| 169 const struct plane_block_idx pb_idx = plane_block_idx(y_blocks, b_idx); | |
| 170 struct macroblock_plane* p = &x->plane[pb_idx.plane]; | |
| 171 struct macroblockd_plane* pd = &xd->plane[pb_idx.plane]; | |
| 172 | |
| 173 vp9_quantize_b(BLOCK_OFFSET(p->coeff, pb_idx.block), | |
| 174 16, x->skip_block, | |
| 175 p->zbin, p->round, p->quant, p->quant_shift, | |
| 176 BLOCK_OFFSET(pd->qcoeff, pb_idx.block), | |
| 177 BLOCK_OFFSET(pd->dqcoeff, pb_idx.block), | |
| 178 pd->dequant, p->zbin_extra, &pd->eobs[pb_idx.block], scan, iscan); | |
| 179 } | |
| 180 | |
| 181 static void invert_quant(int16_t *quant, int16_t *shift, int d) { | |
| 182 unsigned t; | |
| 183 int l; | |
| 184 t = d; | |
| 185 for (l = 0; t > 1; l++) | |
| 186 t >>= 1; | |
| 187 t = 1 + (1 << (16 + l)) / d; | |
| 188 *quant = (int16_t)(t - (1 << 16)); | |
| 189 *shift = 1 << (16 - l); | |
| 190 } | |
| 191 | |
| 192 void vp9_init_quantizer(VP9_COMP *cpi) { | |
| 193 int i, q; | |
| 194 VP9_COMMON *const cm = &cpi->common; | |
| 195 | |
| 196 for (q = 0; q < QINDEX_RANGE; q++) { | |
| 197 const int qzbin_factor = q == 0 ? 64 : (vp9_dc_quant(q, 0) < 148 ? 84 : 80); | |
| 198 const int qrounding_factor = q == 0 ? 64 : 48; | |
| 199 | |
| 200 // y | |
| 201 for (i = 0; i < 2; ++i) { | |
| 202 const int quant = i == 0 ? vp9_dc_quant(q, cm->y_dc_delta_q) | |
| 203 : vp9_ac_quant(q, 0); | |
| 204 invert_quant(&cpi->y_quant[q][i], &cpi->y_quant_shift[q][i], quant); | |
| 205 cpi->y_zbin[q][i] = ROUND_POWER_OF_TWO(qzbin_factor * quant, 7); | |
| 206 cpi->y_round[q][i] = (qrounding_factor * quant) >> 7; | |
| 207 cm->y_dequant[q][i] = quant; | |
| 208 } | |
| 209 | |
| 210 // uv | |
| 211 for (i = 0; i < 2; ++i) { | |
| 212 const int quant = i == 0 ? vp9_dc_quant(q, cm->uv_dc_delta_q) | |
| 213 : vp9_ac_quant(q, cm->uv_ac_delta_q); | |
| 214 invert_quant(&cpi->uv_quant[q][i], &cpi->uv_quant_shift[q][i], quant); | |
| 215 cpi->uv_zbin[q][i] = ROUND_POWER_OF_TWO(qzbin_factor * quant, 7); | |
| 216 cpi->uv_round[q][i] = (qrounding_factor * quant) >> 7; | |
| 217 cm->uv_dequant[q][i] = quant; | |
| 218 } | |
| 219 | |
| 220 #if CONFIG_ALPHA | |
| 221 // alpha | |
| 222 for (i = 0; i < 2; ++i) { | |
| 223 const int quant = i == 0 ? vp9_dc_quant(q, cm->a_dc_delta_q) | |
| 224 : vp9_ac_quant(q, cm->a_ac_delta_q); | |
| 225 invert_quant(&cpi->a_quant[q][i], &cpi->a_quant_shift[q][i], quant); | |
| 226 cpi->a_zbin[q][i] = ROUND_POWER_OF_TWO(qzbin_factor * quant, 7); | |
| 227 cpi->a_round[q][i] = (qrounding_factor * quant) >> 7; | |
| 228 cm->a_dequant[q][i] = quant; | |
| 229 } | |
| 230 #endif | |
| 231 | |
| 232 for (i = 2; i < 8; i++) { | |
| 233 cpi->y_quant[q][i] = cpi->y_quant[q][1]; | |
| 234 cpi->y_quant_shift[q][i] = cpi->y_quant_shift[q][1]; | |
| 235 cpi->y_zbin[q][i] = cpi->y_zbin[q][1]; | |
| 236 cpi->y_round[q][i] = cpi->y_round[q][1]; | |
| 237 cm->y_dequant[q][i] = cm->y_dequant[q][1]; | |
| 238 | |
| 239 cpi->uv_quant[q][i] = cpi->uv_quant[q][1]; | |
| 240 cpi->uv_quant_shift[q][i] = cpi->uv_quant_shift[q][1]; | |
| 241 cpi->uv_zbin[q][i] = cpi->uv_zbin[q][1]; | |
| 242 cpi->uv_round[q][i] = cpi->uv_round[q][1]; | |
| 243 cm->uv_dequant[q][i] = cm->uv_dequant[q][1]; | |
| 244 | |
| 245 #if CONFIG_ALPHA | |
| 246 cpi->a_quant[q][i] = cpi->a_quant[q][1]; | |
| 247 cpi->a_quant_shift[q][i] = cpi->a_quant_shift[q][1]; | |
| 248 cpi->a_zbin[q][i] = cpi->a_zbin[q][1]; | |
| 249 cpi->a_round[q][i] = cpi->a_round[q][1]; | |
| 250 cm->a_dequant[q][i] = cm->a_dequant[q][1]; | |
| 251 #endif | |
| 252 } | |
| 253 } | |
| 254 } | |
| 255 | |
| 256 void vp9_mb_init_quantizer(VP9_COMP *cpi, MACROBLOCK *x) { | |
| 257 int i; | |
| 258 VP9_COMMON *const cm = &cpi->common; | |
| 259 MACROBLOCKD *xd = &x->e_mbd; | |
| 260 int zbin_extra; | |
| 261 int segment_id = xd->mi_8x8[0]->mbmi.segment_id; | |
| 262 const int qindex = vp9_get_qindex(&cpi->common.seg, segment_id, | |
| 263 cpi->common.base_qindex); | |
| 264 | |
| 265 int rdmult = vp9_compute_rd_mult(cpi, qindex + cm->y_dc_delta_q); | |
| 266 | |
| 267 // Y | |
| 268 zbin_extra = (cpi->common.y_dequant[qindex][1] * | |
| 269 (cpi->zbin_mode_boost + x->act_zbin_adj)) >> 7; | |
| 270 | |
| 271 x->plane[0].quant = cpi->y_quant[qindex]; | |
| 272 x->plane[0].quant_shift = cpi->y_quant_shift[qindex]; | |
| 273 x->plane[0].zbin = cpi->y_zbin[qindex]; | |
| 274 x->plane[0].round = cpi->y_round[qindex]; | |
| 275 x->plane[0].zbin_extra = (int16_t)zbin_extra; | |
| 276 x->e_mbd.plane[0].dequant = cpi->common.y_dequant[qindex]; | |
| 277 | |
| 278 // UV | |
| 279 zbin_extra = (cpi->common.uv_dequant[qindex][1] * | |
| 280 (cpi->zbin_mode_boost + x->act_zbin_adj)) >> 7; | |
| 281 | |
| 282 for (i = 1; i < 3; i++) { | |
| 283 x->plane[i].quant = cpi->uv_quant[qindex]; | |
| 284 x->plane[i].quant_shift = cpi->uv_quant_shift[qindex]; | |
| 285 x->plane[i].zbin = cpi->uv_zbin[qindex]; | |
| 286 x->plane[i].round = cpi->uv_round[qindex]; | |
| 287 x->plane[i].zbin_extra = (int16_t)zbin_extra; | |
| 288 x->e_mbd.plane[i].dequant = cpi->common.uv_dequant[qindex]; | |
| 289 } | |
| 290 | |
| 291 #if CONFIG_ALPHA | |
| 292 x->plane[3].quant = cpi->a_quant[qindex]; | |
| 293 x->plane[3].quant_shift = cpi->a_quant_shift[qindex]; | |
| 294 x->plane[3].zbin = cpi->a_zbin[qindex]; | |
| 295 x->plane[3].round = cpi->a_round[qindex]; | |
| 296 x->plane[3].zbin_extra = (int16_t)zbin_extra; | |
| 297 x->e_mbd.plane[3].dequant = cpi->common.a_dequant[qindex]; | |
| 298 #endif | |
| 299 | |
| 300 x->skip_block = vp9_segfeature_active(&cpi->common.seg, segment_id, | |
| 301 SEG_LVL_SKIP); | |
| 302 | |
| 303 /* save this macroblock QIndex for vp9_update_zbin_extra() */ | |
| 304 x->q_index = qindex; | |
| 305 | |
| 306 /* R/D setup */ | |
| 307 cpi->mb.errorperbit = rdmult >> 6; | |
| 308 cpi->mb.errorperbit += (cpi->mb.errorperbit == 0); | |
| 309 | |
| 310 vp9_initialize_me_consts(cpi, x->q_index); | |
| 311 } | |
| 312 | |
| 313 void vp9_update_zbin_extra(VP9_COMP *cpi, MACROBLOCK *x) { | |
| 314 const int qindex = x->q_index; | |
| 315 const int y_zbin_extra = (cpi->common.y_dequant[qindex][1] * | |
| 316 (cpi->zbin_mode_boost + x->act_zbin_adj)) >> 7; | |
| 317 const int uv_zbin_extra = (cpi->common.uv_dequant[qindex][1] * | |
| 318 (cpi->zbin_mode_boost + x->act_zbin_adj)) >> 7; | |
| 319 | |
| 320 x->plane[0].zbin_extra = (int16_t)y_zbin_extra; | |
| 321 x->plane[1].zbin_extra = (int16_t)uv_zbin_extra; | |
| 322 x->plane[2].zbin_extra = (int16_t)uv_zbin_extra; | |
| 323 } | |
| 324 | |
| 325 void vp9_frame_init_quantizer(VP9_COMP *cpi) { | |
| 326 // Clear Zbin mode boost for default case | |
| 327 cpi->zbin_mode_boost = 0; | |
| 328 | |
| 329 // MB level quantizer setup | |
| 330 vp9_mb_init_quantizer(cpi, &cpi->mb); | |
| 331 } | |
| 332 | |
| 333 void vp9_set_quantizer(struct VP9_COMP *cpi, int q) { | |
| 334 VP9_COMMON *cm = &cpi->common; | |
| 335 | |
| 336 cm->base_qindex = q; | |
| 337 | |
| 338 // if any of the delta_q values are changing update flag will | |
| 339 // have to be set. | |
| 340 cm->y_dc_delta_q = 0; | |
| 341 cm->uv_dc_delta_q = 0; | |
| 342 cm->uv_ac_delta_q = 0; | |
| 343 | |
| 344 // quantizer has to be reinitialized if any delta_q changes. | |
| 345 // As there are not any here for now this is inactive code. | |
| 346 // if(update) | |
| 347 // vp9_init_quantizer(cpi); | |
| 348 } |
