third_party/libvpx/source/libvpx/vp8/encoder/quantize.c - Issue 1158913006: Move libvpx from DEPS to src

Unified Diff: third_party/libvpx/source/libvpx/vp8/encoder/quantize.c

Issue 1158913006: Move libvpx from DEPS to src (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master

Patch Set: add DEPS file with #include paths Created 5 years, 7 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

Download patch

« third_party/libvpx/DEPS ('K') | « third_party/libvpx/source/libvpx/vp8/encoder/quantize.h ('k') | third_party/libvpx/source/libvpx/vp8/encoder/ratectrl.h » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Hide Comments ('s')

Index: third_party/libvpx/source/libvpx/vp8/encoder/quantize.c

diff --git a/third_party/libvpx/source/libvpx/vp8/encoder/quantize.c b/third_party/libvpx/source/libvpx/vp8/encoder/quantize.c

new file mode 100644

index 0000000000000000000000000000000000000000..c5a7bc67039b78c6d11702914d21896f4da3723c

--- /dev/null

+++ b/third_party/libvpx/source/libvpx/vp8/encoder/quantize.c

@@ -0,0 +1,583 @@

+/*

+ *

+ * 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 "onyx_int.h"

+#include "quantize.h"

+#include "vp8/common/quant_common.h"

+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 = (char)(eob + 1);

+void vp8_regular_quantize_b_c(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;

+ memset(qcoeff_ptr, 0, 32);

+ 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]) >> 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; /* reset zero runlength */

+ }

+ *d->eob = (char)(eob + 1);

+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]);

+static const int qrounding_factors[129] =

+ 48, 48, 48, 48, 48, 48, 48, 48,

+ 48

+};

+static const int qzbin_factors[129] =

+ 84, 84, 84, 84, 84, 84, 84, 84,

+ 80, 80, 80, 80, 80, 80, 80, 80,

+ 80

+};

+static const int qrounding_factors_y2[129] =

+ 48, 48, 48, 48, 48, 48, 48, 48,

+ 48

+};

+static const int qzbin_factors_y2[129] =

+ 84, 84, 84, 84, 84, 84, 84, 84,

+ 80, 80, 80, 80, 80, 80, 80, 80,

+ 80

+};

+static void invert_quant(int improved_quant, short *quant,

+ short *shift, short d)

+ if(improved_quant)

+ {

+ unsigned t;

+ int l;

+ t = d;

+ for(l = 0; t > 1; l++)

+ t>>=1;

+ t = 1 + (1<<(16+l))/d;

+ *quant = (short)(t - (1<<16));

+ *shift = l;

+ /* use multiplication and constant shift by 16 */

+ *shift = 1 << (16 - *shift);

+ }

+ else

+ {

+ *quant = (1 << 16) / d;

+ *shift = 0;

+ /* use multiplication and constant shift by 16 */

+ *shift = 1 << (16 - *shift);

+ }

+void vp8cx_init_quantizer(VP8_COMP *cpi)

+ int i;

+ int quant_val;

+ int Q;

+ int zbin_boost[16] = {0, 0, 8, 10, 12, 14, 16, 20, 24, 28, 32, 36, 40, 44,

+ 44, 44};

+ for (Q = 0; Q < QINDEX_RANGE; Q++)

+ {

+ /* dc values */

+ quant_val = vp8_dc_quant(Q, cpi->common.y1dc_delta_q);

+ cpi->Y1quant_fast[Q][0] = (1 << 16) / quant_val;

+ invert_quant(cpi->sf.improved_quant, cpi->Y1quant[Q] + 0,

+ cpi->Y1quant_shift[Q] + 0, quant_val);

+ cpi->Y1zbin[Q][0] = ((qzbin_factors[Q] * quant_val) + 64) >> 7;

+ cpi->Y1round[Q][0] = (qrounding_factors[Q] * quant_val) >> 7;

+ cpi->common.Y1dequant[Q][0] = quant_val;

+ cpi->zrun_zbin_boost_y1[Q][0] = (quant_val * zbin_boost[0]) >> 7;

+ quant_val = vp8_dc2quant(Q, cpi->common.y2dc_delta_q);

+ cpi->Y2quant_fast[Q][0] = (1 << 16) / quant_val;

+ invert_quant(cpi->sf.improved_quant, cpi->Y2quant[Q] + 0,

+ cpi->Y2quant_shift[Q] + 0, quant_val);

+ cpi->Y2zbin[Q][0] = ((qzbin_factors_y2[Q] * quant_val) + 64) >> 7;

+ cpi->Y2round[Q][0] = (qrounding_factors_y2[Q] * quant_val) >> 7;

+ cpi->common.Y2dequant[Q][0] = quant_val;

+ cpi->zrun_zbin_boost_y2[Q][0] = (quant_val * zbin_boost[0]) >> 7;

+ quant_val = vp8_dc_uv_quant(Q, cpi->common.uvdc_delta_q);

+ cpi->UVquant_fast[Q][0] = (1 << 16) / quant_val;

+ invert_quant(cpi->sf.improved_quant, cpi->UVquant[Q] + 0,

+ cpi->UVquant_shift[Q] + 0, quant_val);

+ cpi->UVzbin[Q][0] = ((qzbin_factors[Q] * quant_val) + 64) >> 7;;

+ cpi->UVround[Q][0] = (qrounding_factors[Q] * quant_val) >> 7;

+ cpi->common.UVdequant[Q][0] = quant_val;

+ cpi->zrun_zbin_boost_uv[Q][0] = (quant_val * zbin_boost[0]) >> 7;

+ /* all the ac values = ; */

+ quant_val = vp8_ac_yquant(Q);

+ cpi->Y1quant_fast[Q][1] = (1 << 16) / quant_val;

+ invert_quant(cpi->sf.improved_quant, cpi->Y1quant[Q] + 1,

+ cpi->Y1quant_shift[Q] + 1, quant_val);

+ cpi->Y1zbin[Q][1] = ((qzbin_factors[Q] * quant_val) + 64) >> 7;

+ cpi->Y1round[Q][1] = (qrounding_factors[Q] * quant_val) >> 7;

+ cpi->common.Y1dequant[Q][1] = quant_val;

+ cpi->zrun_zbin_boost_y1[Q][1] = (quant_val * zbin_boost[1]) >> 7;

+ quant_val = vp8_ac2quant(Q, cpi->common.y2ac_delta_q);

+ cpi->Y2quant_fast[Q][1] = (1 << 16) / quant_val;

+ invert_quant(cpi->sf.improved_quant, cpi->Y2quant[Q] + 1,

+ cpi->Y2quant_shift[Q] + 1, quant_val);

+ cpi->Y2zbin[Q][1] = ((qzbin_factors_y2[Q] * quant_val) + 64) >> 7;

+ cpi->Y2round[Q][1] = (qrounding_factors_y2[Q] * quant_val) >> 7;

+ cpi->common.Y2dequant[Q][1] = quant_val;

+ cpi->zrun_zbin_boost_y2[Q][1] = (quant_val * zbin_boost[1]) >> 7;

+ quant_val = vp8_ac_uv_quant(Q, cpi->common.uvac_delta_q);

+ cpi->UVquant_fast[Q][1] = (1 << 16) / quant_val;

+ invert_quant(cpi->sf.improved_quant, cpi->UVquant[Q] + 1,

+ cpi->UVquant_shift[Q] + 1, quant_val);

+ cpi->UVzbin[Q][1] = ((qzbin_factors[Q] * quant_val) + 64) >> 7;

+ cpi->UVround[Q][1] = (qrounding_factors[Q] * quant_val) >> 7;

+ cpi->common.UVdequant[Q][1] = quant_val;

+ cpi->zrun_zbin_boost_uv[Q][1] = (quant_val * zbin_boost[1]) >> 7;

+ for (i = 2; i < 16; i++)

+ {

+ cpi->Y1quant_fast[Q][i] = cpi->Y1quant_fast[Q][1];

+ cpi->Y1quant[Q][i] = cpi->Y1quant[Q][1];

+ cpi->Y1quant_shift[Q][i] = cpi->Y1quant_shift[Q][1];

+ cpi->Y1zbin[Q][i] = cpi->Y1zbin[Q][1];

+ cpi->Y1round[Q][i] = cpi->Y1round[Q][1];

+ cpi->zrun_zbin_boost_y1[Q][i] = (cpi->common.Y1dequant[Q][1] *

+ zbin_boost[i]) >> 7;

+ cpi->Y2quant_fast[Q][i] = cpi->Y2quant_fast[Q][1];

+ cpi->Y2quant[Q][i] = cpi->Y2quant[Q][1];

+ cpi->Y2quant_shift[Q][i] = cpi->Y2quant_shift[Q][1];

+ cpi->Y2zbin[Q][i] = cpi->Y2zbin[Q][1];

+ cpi->Y2round[Q][i] = cpi->Y2round[Q][1];

+ cpi->zrun_zbin_boost_y2[Q][i] = (cpi->common.Y2dequant[Q][1] *

+ zbin_boost[i]) >> 7;

+ cpi->UVquant_fast[Q][i] = cpi->UVquant_fast[Q][1];

+ cpi->UVquant[Q][i] = cpi->UVquant[Q][1];

+ cpi->UVquant_shift[Q][i] = cpi->UVquant_shift[Q][1];

+ cpi->UVzbin[Q][i] = cpi->UVzbin[Q][1];

+ cpi->UVround[Q][i] = cpi->UVround[Q][1];

+ cpi->zrun_zbin_boost_uv[Q][i] = (cpi->common.UVdequant[Q][1] *

+ zbin_boost[i]) >> 7;

+ }

+#define ZBIN_EXTRA_Y \

+ (( cpi->common.Y1dequant[QIndex][1] * \

+ ( x->zbin_over_quant + \

+ x->zbin_mode_boost + \

+ x->act_zbin_adj ) ) >> 7)

+#define ZBIN_EXTRA_UV \

+ (( cpi->common.UVdequant[QIndex][1] * \

+ ( x->zbin_over_quant + \

+ x->zbin_mode_boost + \

+ x->act_zbin_adj ) ) >> 7)

+#define ZBIN_EXTRA_Y2 \

+ (( cpi->common.Y2dequant[QIndex][1] * \

+ ( (x->zbin_over_quant / 2) + \

+ x->zbin_mode_boost + \

+ x->act_zbin_adj ) ) >> 7)

+void vp8cx_mb_init_quantizer(VP8_COMP *cpi, MACROBLOCK *x, int ok_to_skip)

+ int i;

+ int QIndex;

+ MACROBLOCKD *xd = &x->e_mbd;

+ int zbin_extra;

+ /* Select the baseline MB Q index. */

+ if (xd->segmentation_enabled)

+ {

+ /* Abs Value */

+ if (xd->mb_segement_abs_delta == SEGMENT_ABSDATA)

+ QIndex = xd->segment_feature_data[MB_LVL_ALT_Q][xd->mode_info_context->mbmi.segment_id];

+ /* Delta Value */

+ else

+ {

+ QIndex = cpi->common.base_qindex + xd->segment_feature_data[MB_LVL_ALT_Q][xd->mode_info_context->mbmi.segment_id];

+ /* Clamp to valid range */

+ QIndex = (QIndex >= 0) ? ((QIndex <= MAXQ) ? QIndex : MAXQ) : 0;

+ }

+ else

+ QIndex = cpi->common.base_qindex;

+ /* This initialization should be called at least once. Use ok_to_skip to

+ * decide if it is ok to skip.

+ * Before encoding a frame, this function is always called with ok_to_skip

+ * =0, which means no skiping of calculations. The "last" values are

+ * initialized at that time.

+ */

+ if (!ok_to_skip || QIndex != x->q_index)

+ {

+ xd->dequant_y1_dc[0] = 1;

+ xd->dequant_y1[0] = cpi->common.Y1dequant[QIndex][0];

+ xd->dequant_y2[0] = cpi->common.Y2dequant[QIndex][0];

+ xd->dequant_uv[0] = cpi->common.UVdequant[QIndex][0];

+ for (i = 1; i < 16; i++)

+ {

+ xd->dequant_y1_dc[i] =

+ xd->dequant_y1[i] = cpi->common.Y1dequant[QIndex][1];

+ xd->dequant_y2[i] = cpi->common.Y2dequant[QIndex][1];

+ xd->dequant_uv[i] = cpi->common.UVdequant[QIndex][1];

+ }

+#if 1

+ /*TODO: Remove dequant from BLOCKD. This is a temporary solution until

+ * the quantizer code uses a passed in pointer to the dequant constants.

+ * This will also require modifications to the x86 and neon assembly.

+ * */

+ for (i = 0; i < 16; i++)

+ x->e_mbd.block[i].dequant = xd->dequant_y1;

+ for (i = 16; i < 24; i++)

+ x->e_mbd.block[i].dequant = xd->dequant_uv;

+ x->e_mbd.block[24].dequant = xd->dequant_y2;

+#endif

+ /* Y */

+ zbin_extra = ZBIN_EXTRA_Y;

+ for (i = 0; i < 16; i++)

+ {

+ x->block[i].quant = cpi->Y1quant[QIndex];

+ x->block[i].quant_fast = cpi->Y1quant_fast[QIndex];

+ x->block[i].quant_shift = cpi->Y1quant_shift[QIndex];

+ x->block[i].zbin = cpi->Y1zbin[QIndex];

+ x->block[i].round = cpi->Y1round[QIndex];

+ x->block[i].zrun_zbin_boost = cpi->zrun_zbin_boost_y1[QIndex];

+ x->block[i].zbin_extra = (short)zbin_extra;

+ }

+ /* UV */

+ zbin_extra = ZBIN_EXTRA_UV;

+ for (i = 16; i < 24; i++)

+ {

+ x->block[i].quant = cpi->UVquant[QIndex];

+ x->block[i].quant_fast = cpi->UVquant_fast[QIndex];

+ x->block[i].quant_shift = cpi->UVquant_shift[QIndex];

+ x->block[i].zbin = cpi->UVzbin[QIndex];

+ x->block[i].round = cpi->UVround[QIndex];

+ x->block[i].zrun_zbin_boost = cpi->zrun_zbin_boost_uv[QIndex];

+ x->block[i].zbin_extra = (short)zbin_extra;

+ }

+ /* Y2 */

+ zbin_extra = ZBIN_EXTRA_Y2;

+ x->block[24].quant_fast = cpi->Y2quant_fast[QIndex];

+ x->block[24].quant = cpi->Y2quant[QIndex];

+ x->block[24].quant_shift = cpi->Y2quant_shift[QIndex];

+ x->block[24].zbin = cpi->Y2zbin[QIndex];

+ x->block[24].round = cpi->Y2round[QIndex];

+ x->block[24].zrun_zbin_boost = cpi->zrun_zbin_boost_y2[QIndex];

+ x->block[24].zbin_extra = (short)zbin_extra;

+ /* save this macroblock QIndex for vp8_update_zbin_extra() */

+ x->q_index = QIndex;

+ x->last_zbin_over_quant = x->zbin_over_quant;

+ x->last_zbin_mode_boost = x->zbin_mode_boost;

+ x->last_act_zbin_adj = x->act_zbin_adj;

+ }

+ else if(x->last_zbin_over_quant != x->zbin_over_quant

+ || x->last_zbin_mode_boost != x->zbin_mode_boost

+ || x->last_act_zbin_adj != x->act_zbin_adj)

+ {

+ /* Y */

+ zbin_extra = ZBIN_EXTRA_Y;

+ for (i = 0; i < 16; i++)

+ x->block[i].zbin_extra = (short)zbin_extra;

+ /* UV */

+ zbin_extra = ZBIN_EXTRA_UV;

+ for (i = 16; i < 24; i++)

+ x->block[i].zbin_extra = (short)zbin_extra;

+ /* Y2 */

+ zbin_extra = ZBIN_EXTRA_Y2;

+ x->block[24].zbin_extra = (short)zbin_extra;

+ x->last_zbin_over_quant = x->zbin_over_quant;

+ x->last_zbin_mode_boost = x->zbin_mode_boost;

+ x->last_act_zbin_adj = x->act_zbin_adj;

+ }

+void vp8_update_zbin_extra(VP8_COMP *cpi, MACROBLOCK *x)

+ int i;

+ int QIndex = x->q_index;

+ int zbin_extra;

+ /* Y */

+ zbin_extra = ZBIN_EXTRA_Y;

+ for (i = 0; i < 16; i++)

+ x->block[i].zbin_extra = (short)zbin_extra;

+ /* UV */

+ zbin_extra = ZBIN_EXTRA_UV;

+ for (i = 16; i < 24; i++)

+ x->block[i].zbin_extra = (short)zbin_extra;

+ /* Y2 */

+ zbin_extra = ZBIN_EXTRA_Y2;

+ x->block[24].zbin_extra = (short)zbin_extra;

+#undef ZBIN_EXTRA_Y

+#undef ZBIN_EXTRA_UV

+#undef ZBIN_EXTRA_Y2

+void vp8cx_frame_init_quantizer(VP8_COMP *cpi)

+ /* Clear Zbin mode boost for default case */

+ cpi->mb.zbin_mode_boost = 0;

+ /* MB level quantizer setup */

+ vp8cx_mb_init_quantizer(cpi, &cpi->mb, 0);

+void vp8_set_quantizer(struct VP8_COMP *cpi, int Q)

+ VP8_COMMON *cm = &cpi->common;

+ MACROBLOCKD *mbd = &cpi->mb.e_mbd;

+ int update = 0;

+ int new_delta_q;

+ int new_uv_delta_q;

+ cm->base_qindex = Q;

+ /* if any of the delta_q values are changing update flag has to be set */

+ /* currently only y2dc_delta_q may change */

+ cm->y1dc_delta_q = 0;

+ cm->y2ac_delta_q = 0;

+ if (Q < 4)

+ {

+ new_delta_q = 4-Q;

+ }

+ else

+ new_delta_q = 0;

+ update |= cm->y2dc_delta_q != new_delta_q;

+ cm->y2dc_delta_q = new_delta_q;

+ new_uv_delta_q = 0;

+ // For screen content, lower the q value for UV channel. For now, select

+ // conservative delta; same delta for dc and ac, and decrease it with lower

+ // Q, and set to 0 below some threshold. May want to condition this in

+ // future on the variance/energy in UV channel.

+ if (cpi->oxcf.screen_content_mode && Q > 40) {

+ new_uv_delta_q = -(int)(0.15 * Q);

+ // Check range: magnitude of delta is 4 bits.

+ if (new_uv_delta_q < -15) {

+ new_uv_delta_q = -15;

+ }

+ update |= cm->uvdc_delta_q != new_uv_delta_q;

+ cm->uvdc_delta_q = new_uv_delta_q;

+ cm->uvac_delta_q = new_uv_delta_q;

+ /* Set Segment specific quatizers */

+ mbd->segment_feature_data[MB_LVL_ALT_Q][0] = cpi->segment_feature_data[MB_LVL_ALT_Q][0];

+ mbd->segment_feature_data[MB_LVL_ALT_Q][1] = cpi->segment_feature_data[MB_LVL_ALT_Q][1];

+ mbd->segment_feature_data[MB_LVL_ALT_Q][2] = cpi->segment_feature_data[MB_LVL_ALT_Q][2];

+ mbd->segment_feature_data[MB_LVL_ALT_Q][3] = cpi->segment_feature_data[MB_LVL_ALT_Q][3];

+ /* quantizer has to be reinitialized for any delta_q changes */

+ if(update)

+ vp8cx_init_quantizer(cpi);

« third_party/libvpx/DEPS ('K') | « third_party/libvpx/source/libvpx/vp8/encoder/quantize.h ('k') | third_party/libvpx/source/libvpx/vp8/encoder/ratectrl.h » ('j') | no next file with comments »