2010-05-18 17:58:33 +02:00
|
|
|
/*
|
2010-09-09 14:16:39 +02:00
|
|
|
* Copyright (c) 2010 The WebM project authors. All Rights Reserved.
|
2010-05-18 17:58:33 +02:00
|
|
|
*
|
2010-06-18 18:39:21 +02:00
|
|
|
* Use of this source code is governed by a BSD-style license
|
2010-06-04 22:19:40 +02:00
|
|
|
* that can be found in the LICENSE file in the root of the source
|
|
|
|
|
* tree. An additional intellectual property rights grant can be found
|
2010-06-18 18:39:21 +02:00
|
|
|
* in the file PATENTS. All contributing project authors may
|
2010-06-04 22:19:40 +02:00
|
|
|
* be found in the AUTHORS file in the root of the source tree.
|
2010-05-18 17:58:33 +02:00
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#ifndef __INC_QUANTIZE_H
|
|
|
|
|
#define __INC_QUANTIZE_H
|
|
|
|
|
|
|
|
|
|
#include "block.h"
|
|
|
|
|
|
|
|
|
|
#define prototype_quantize_block(sym) \
|
|
|
|
|
void (sym)(BLOCK *b,BLOCKD *d)
|
|
|
|
|
|
2011-05-09 09:09:41 +02:00
|
|
|
#define prototype_quantize_block_pair(sym) \
|
|
|
|
|
void (sym)(BLOCK *b1, BLOCK *b2, BLOCKD *d1, BLOCKD *d2)
|
|
|
|
|
|
|
|
|
|
#define prototype_quantize_mb(sym) \
|
|
|
|
|
void (sym)(MACROBLOCK *x)
|
2011-04-11 11:04:17 +02:00
|
|
|
|
2010-06-14 20:07:56 +02:00
|
|
|
#if ARCH_X86 || ARCH_X86_64
|
|
|
|
|
#include "x86/quantize_x86.h"
|
|
|
|
|
#endif
|
|
|
|
|
|
2010-05-18 17:58:33 +02:00
|
|
|
#if ARCH_ARM
|
|
|
|
|
#include "arm/quantize_arm.h"
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#ifndef vp8_quantize_quantb
|
|
|
|
|
#define vp8_quantize_quantb vp8_regular_quantize_b
|
|
|
|
|
#endif
|
|
|
|
|
extern prototype_quantize_block(vp8_quantize_quantb);
|
|
|
|
|
|
2011-05-09 09:09:41 +02:00
|
|
|
#ifndef vp8_quantize_quantb_pair
|
|
|
|
|
#define vp8_quantize_quantb_pair vp8_regular_quantize_b_pair
|
|
|
|
|
#endif
|
|
|
|
|
extern prototype_quantize_block_pair(vp8_quantize_quantb_pair);
|
|
|
|
|
|
2010-05-18 17:58:33 +02:00
|
|
|
#ifndef vp8_quantize_fastquantb
|
|
|
|
|
#define vp8_quantize_fastquantb vp8_fast_quantize_b_c
|
|
|
|
|
#endif
|
|
|
|
|
extern prototype_quantize_block(vp8_quantize_fastquantb);
|
2012-02-29 02:11:12 +01:00
|
|
|
|
2011-02-14 23:18:18 +01:00
|
|
|
#ifndef vp8_quantize_quantb_8x8
|
|
|
|
|
#define vp8_quantize_quantb_8x8 vp8_regular_quantize_b_8x8
|
|
|
|
|
#endif
|
|
|
|
|
extern prototype_quantize_block(vp8_quantize_quantb_8x8);
|
|
|
|
|
|
|
|
|
|
#ifndef vp8_quantize_fastquantb_8x8
|
|
|
|
|
#define vp8_quantize_fastquantb_8x8 vp8_fast_quantize_b_8x8_c
|
|
|
|
|
#endif
|
|
|
|
|
extern prototype_quantize_block(vp8_quantize_fastquantb_8x8);
|
|
|
|
|
|
|
|
|
|
#ifndef vp8_quantize_quantb_2x2
|
|
|
|
|
#define vp8_quantize_quantb_2x2 vp8_regular_quantize_b_2x2
|
|
|
|
|
#endif
|
|
|
|
|
extern prototype_quantize_block(vp8_quantize_quantb_2x2);
|
|
|
|
|
|
|
|
|
|
#ifndef vp8_quantize_fastquantb_2x2
|
|
|
|
|
#define vp8_quantize_fastquantb_2x2 vp8_fast_quantize_b_2x2_c
|
|
|
|
|
#endif
|
|
|
|
|
extern prototype_quantize_block(vp8_quantize_fastquantb_2x2);
|
2012-02-29 02:11:12 +01:00
|
|
|
|
2011-02-14 23:18:18 +01:00
|
|
|
|
2011-05-09 09:09:41 +02:00
|
|
|
#ifndef vp8_quantize_fastquantb_pair
|
|
|
|
|
#define vp8_quantize_fastquantb_pair vp8_fast_quantize_b_pair_c
|
|
|
|
|
#endif
|
|
|
|
|
extern prototype_quantize_block_pair(vp8_quantize_fastquantb_pair);
|
|
|
|
|
|
2010-05-18 17:58:33 +02:00
|
|
|
typedef struct
|
|
|
|
|
{
|
|
|
|
|
prototype_quantize_block(*quantb);
|
2011-05-09 09:09:41 +02:00
|
|
|
prototype_quantize_block_pair(*quantb_pair);
|
2010-05-18 17:58:33 +02:00
|
|
|
prototype_quantize_block(*fastquantb);
|
2011-02-14 23:18:18 +01:00
|
|
|
prototype_quantize_block(*quantb_8x8);
|
|
|
|
|
prototype_quantize_block(*fastquantb_8x8);
|
|
|
|
|
prototype_quantize_block(*quantb_2x2);
|
|
|
|
|
prototype_quantize_block(*fastquantb_2x2);
|
2011-05-09 09:09:41 +02:00
|
|
|
prototype_quantize_block_pair(*fastquantb_pair);
|
2010-05-18 17:58:33 +02:00
|
|
|
} vp8_quantize_rtcd_vtable_t;
|
|
|
|
|
|
2011-05-09 09:09:41 +02:00
|
|
|
#ifndef vp8_quantize_mb
|
|
|
|
|
#define vp8_quantize_mb vp8_quantize_mb_c
|
|
|
|
|
#endif
|
|
|
|
|
extern prototype_quantize_mb(vp8_quantize_mb);
|
|
|
|
|
|
|
|
|
|
#ifndef vp8_quantize_mbuv
|
|
|
|
|
#define vp8_quantize_mbuv vp8_quantize_mbuv_c
|
|
|
|
|
#endif
|
|
|
|
|
extern prototype_quantize_mb(vp8_quantize_mbuv);
|
|
|
|
|
|
|
|
|
|
#ifndef vp8_quantize_mby
|
|
|
|
|
#define vp8_quantize_mby vp8_quantize_mby_c
|
|
|
|
|
#endif
|
|
|
|
|
extern prototype_quantize_mb(vp8_quantize_mby);
|
2011-04-11 11:04:17 +02:00
|
|
|
|
2010-05-18 17:58:33 +02:00
|
|
|
#if CONFIG_RUNTIME_CPU_DETECT
|
|
|
|
|
#define QUANTIZE_INVOKE(ctx,fn) (ctx)->fn
|
|
|
|
|
#else
|
|
|
|
|
#define QUANTIZE_INVOKE(ctx,fn) vp8_quantize_##fn
|
|
|
|
|
#endif
|
|
|
|
|
|
Add trellis quantization.
Replace the exponential search for optimal rounding during
quantization with a linear Viterbi trellis and enable it
by default when using --best.
Right now this operates on top of the output of the adaptive
zero-bin quantizer in vp8_regular_quantize_b() and gives a small
gain.
It can be tested as a replacement for that quantizer by
enabling the call to vp8_strict_quantize_b(), which uses
normal rounding and no zero bin offset.
Ultimately, the quantizer will have to become a function of lambda
in order to take advantage of activity masking, since there is
limited ability to change the quantization factor itself.
However, currently vp8_strict_quantize_b() plus the trellis
quantizer (which is lambda-dependent) loses to
vp8_regular_quantize_b() alone (which is not) on my test clip.
Patch Set 3:
Fix an issue related to the cost evaluation of successor
states when a coefficient is reduced to zero. With this
issue fixed, now the trellis search almost exactly matches
the exponential search.
Patch Set 2:
Overall, the goal of this patch set is to make "trellis"
search to produce encodings that match the exponential
search version. There are three main differences between
Patch Set 2 and 1:
a. Patch set 1 did not properly account for the scale of
2nd order error, so patch set 2 disable it all together
for 2nd blocks.
b. Patch set 1 was not consistent on when to enable the
the quantization optimization. Patch set 2 restore the
condition to be consistent.
c. Patch set 1 checks quantized level L-1, and L for any
input coefficient was quantized to L. Patch set 2 limits
the candidate coefficient to those that were rounded up
to L. It is worth noting here that a strategy to check
L and L+1 for coefficients that were truncated down to L
might work.
(a and b get trellis quant to basically match the exponential
search on all mid/low rate encodings on cif set, without
a, b, trellis quant can hurt the psnr by 0.2 to .3db at
200kbps for some cif clips)
(c gets trellis quant to match the exponential search
to match at Q0 encoding, without c, trellis quant can be
1.5 to 2db lower for encodings with fixed Q at 0 on most
derf cif clips)
Change-Id: Ib1a043b665d75fbf00cb0257b7c18e90eebab95e
2010-07-02 23:35:53 +02:00
|
|
|
extern void vp8_strict_quantize_b(BLOCK *b,BLOCKD *d);
|
2011-02-14 23:18:18 +01:00
|
|
|
extern void vp8_strict_quantize_b_8x8(BLOCK *b,BLOCKD *d);
|
|
|
|
|
extern void vp8_strict_quantize_b_2x2(BLOCK *b,BLOCKD *d);
|
2011-05-19 17:04:03 +02:00
|
|
|
struct VP8_COMP;
|
|
|
|
|
extern void vp8_set_quantizer(struct VP8_COMP *cpi, int Q);
|
|
|
|
|
extern void vp8cx_frame_init_quantizer(struct VP8_COMP *cpi);
|
|
|
|
|
extern void vp8_update_zbin_extra(struct VP8_COMP *cpi, MACROBLOCK *x);
|
|
|
|
|
extern void vp8cx_mb_init_quantizer(struct VP8_COMP *cpi, MACROBLOCK *x);
|
|
|
|
|
extern void vp8cx_init_quantizer(struct VP8_COMP *cpi);
|
|
|
|
|
|
2010-05-18 17:58:33 +02:00
|
|
|
#endif
|