ref: 6e6b46d97295c8227717e294f07de7283303369a
dir: /vp8/encoder/quantize.c/
/* * Copyright (c) 2010 The WebM project authors. All Rights Reserved. * * Use of this source code is governed by a BSD-style license * that can be found in the LICENSE file in the root of the source * tree. An additional intellectual property rights grant can be found * in the file PATENTS. All contributing project authors may * be found in the AUTHORS file in the root of the source tree. */ #include <math.h> #include "vpx_mem/vpx_mem.h" #include "quantize.h" #include "entropy.h" #include "predictdc.h" #define EXACT_QUANT #ifdef EXACT_FASTQUANT void vp8_fast_quantize_b_c(BLOCK *b, BLOCKD *d) { int i, rc, eob; int zbin; int x, y, z, sz; short *coeff_ptr = b->coeff; short *zbin_ptr = b->zbin; short *round_ptr = b->round; short *quant_ptr = b->quant_fast; short *quant_shift_ptr = b->quant_shift; short *qcoeff_ptr = d->qcoeff; short *dqcoeff_ptr = d->dqcoeff; short *dequant_ptr = d->dequant; vpx_memset(qcoeff_ptr, 0, 32); vpx_memset(dqcoeff_ptr, 0, 32); eob = -1; for (i = 0; i < 16; i++) { rc = vp8_default_zig_zag1d[i]; z = coeff_ptr[rc]; zbin = zbin_ptr[rc] ; sz = (z >> 31); // sign of z x = (z ^ sz) - sz; // x = abs(z) if (x >= zbin) { x += round_ptr[rc]; y = (((x * quant_ptr[rc]) >> 16) + x) >> quant_shift_ptr[rc]; // quantize (x) x = (y ^ sz) - sz; // get the sign back qcoeff_ptr[rc] = x; // write to destination dqcoeff_ptr[rc] = x * dequant_ptr[rc]; // dequantized value if (y) { eob = i; // last nonzero coeffs } } } d->eob = eob + 1; } #else void vp8_fast_quantize_b_c(BLOCK *b, BLOCKD *d) { int i, rc, eob; int x, y, z, sz; short *coeff_ptr = b->coeff; short *round_ptr = b->round; short *quant_ptr = b->quant_fast; short *qcoeff_ptr = d->qcoeff; short *dqcoeff_ptr = d->dqcoeff; short *dequant_ptr = d->dequant; eob = -1; for (i = 0; i < 16; i++) { rc = vp8_default_zig_zag1d[i]; z = coeff_ptr[rc]; sz = (z >> 31); // sign of z x = (z ^ sz) - sz; // x = abs(z) y = ((x + round_ptr[rc]) * quant_ptr[rc]) >> 16; // quantize (x) x = (y ^ sz) - sz; // get the sign back qcoeff_ptr[rc] = x; // write to destination dqcoeff_ptr[rc] = x * dequant_ptr[rc]; // dequantized value if (y) { eob = i; // last nonzero coeffs } } d->eob = eob + 1; } #endif #ifdef EXACT_QUANT void vp8_regular_quantize_b(BLOCK *b, BLOCKD *d) { int i, rc, eob; int zbin; int x, y, z, sz; short *zbin_boost_ptr = b->zrun_zbin_boost; short *coeff_ptr = b->coeff; short *zbin_ptr = b->zbin; short *round_ptr = b->round; short *quant_ptr = b->quant; short *quant_shift_ptr = b->quant_shift; short *qcoeff_ptr = d->qcoeff; short *dqcoeff_ptr = d->dqcoeff; short *dequant_ptr = d->dequant; short zbin_oq_value = b->zbin_extra; vpx_memset(qcoeff_ptr, 0, 32); vpx_memset(dqcoeff_ptr, 0, 32); eob = -1; for (i = 0; i < 16; i++) { rc = vp8_default_zig_zag1d[i]; z = coeff_ptr[rc]; zbin = zbin_ptr[rc] + *zbin_boost_ptr + zbin_oq_value; zbin_boost_ptr ++; sz = (z >> 31); // sign of z x = (z ^ sz) - sz; // x = abs(z) if (x >= zbin) { x += round_ptr[rc]; y = (((x * quant_ptr[rc]) >> 16) + x) >> quant_shift_ptr[rc]; // quantize (x) x = (y ^ sz) - sz; // get the sign back qcoeff_ptr[rc] = x; // write to destination dqcoeff_ptr[rc] = x * dequant_ptr[rc]; // dequantized value if (y) { eob = i; // last nonzero coeffs zbin_boost_ptr = b->zrun_zbin_boost; // reset zero runlength } } } d->eob = eob + 1; } /* Perform regular quantization, with unbiased rounding and no zero bin. */ void vp8_strict_quantize_b(BLOCK *b, BLOCKD *d) { int i; int rc; int eob; int x; int y; int z; int sz; short *coeff_ptr; short *quant_ptr; short *quant_shift_ptr; short *qcoeff_ptr; short *dqcoeff_ptr; short *dequant_ptr; coeff_ptr = b->coeff; quant_ptr = b->quant; quant_shift_ptr = b->quant_shift; qcoeff_ptr = d->qcoeff; dqcoeff_ptr = d->dqcoeff; dequant_ptr = d->dequant; eob = - 1; vpx_memset(qcoeff_ptr, 0, 32); vpx_memset(dqcoeff_ptr, 0, 32); for (i = 0; i < 16; i++) { int dq; int round; /*TODO: These arrays should be stored in zig-zag order.*/ rc = vp8_default_zig_zag1d[i]; z = coeff_ptr[rc]; dq = dequant_ptr[rc]; round = dq >> 1; /* Sign of z. */ sz = -(z < 0); x = (z + sz) ^ sz; x += round; if (x >= dq) { /* Quantize x. */ y = (((x * quant_ptr[rc]) >> 16) + x) >> quant_shift_ptr[rc]; /* Put the sign back. */ x = (y + sz) ^ sz; /* Save the coefficient and its dequantized value. */ qcoeff_ptr[rc] = x; dqcoeff_ptr[rc] = x * dq; /* Remember the last non-zero coefficient. */ if (y) eob = i; } } d->eob = eob + 1; } #else void vp8_regular_quantize_b(BLOCK *b, BLOCKD *d) { int i, rc, eob; int zbin; int x, y, z, sz; short *zbin_boost_ptr = b->zrun_zbin_boost; short *coeff_ptr = b->coeff; short *zbin_ptr = b->zbin; short *round_ptr = b->round; short *quant_ptr = b->quant; short *qcoeff_ptr = d->qcoeff; short *dqcoeff_ptr = d->dqcoeff; short *dequant_ptr = d->dequant; short zbin_oq_value = b->zbin_extra; vpx_memset(qcoeff_ptr, 0, 32); vpx_memset(dqcoeff_ptr, 0, 32); eob = -1; for (i = 0; i < 16; i++) { rc = vp8_default_zig_zag1d[i]; z = coeff_ptr[rc]; //if ( i == 0 ) // zbin = zbin_ptr[rc] + *zbin_boost_ptr + zbin_oq_value/2; //else zbin = zbin_ptr[rc] + *zbin_boost_ptr + zbin_oq_value; zbin_boost_ptr ++; sz = (z >> 31); // sign of z x = (z ^ sz) - sz; // x = abs(z) if (x >= zbin) { y = ((x + round_ptr[rc]) * quant_ptr[rc]) >> 16; // quantize (x) x = (y ^ sz) - sz; // get the sign back qcoeff_ptr[rc] = x; // write to destination dqcoeff_ptr[rc] = x * dequant_ptr[rc]; // dequantized value if (y) { eob = i; // last nonzero coeffs zbin_boost_ptr = &b->zrun_zbin_boost[0]; // reset zero runlength } } } d->eob = eob + 1; } #endif void vp8_quantize_mby(MACROBLOCK *x) { int i; int has_2nd_order = (x->e_mbd.mode_info_context->mbmi.mode != B_PRED && x->e_mbd.mode_info_context->mbmi.mode != SPLITMV); for (i = 0; i < 16; i++) x->quantize_b(&x->block[i], &x->e_mbd.block[i]); if(has_2nd_order) x->quantize_b(&x->block[24], &x->e_mbd.block[24]); } void vp8_quantize_mb(MACROBLOCK *x) { int i; int has_2nd_order=(x->e_mbd.mode_info_context->mbmi.mode != B_PRED && x->e_mbd.mode_info_context->mbmi.mode != SPLITMV); for (i = 0; i < 24+has_2nd_order; i++) x->quantize_b(&x->block[i], &x->e_mbd.block[i]); } void vp8_quantize_mbuv(MACROBLOCK *x) { int i; for (i = 16; i < 24; i++) x->quantize_b(&x->block[i], &x->e_mbd.block[i]); }