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
|
|
|
*/
|
|
|
|
|
|
2012-11-30 01:36:10 +01:00
|
|
|
#ifndef VP9_ENCODER_VP9_TOKENIZE_H_
|
|
|
|
|
#define VP9_ENCODER_VP9_TOKENIZE_H_
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-11-27 22:59:17 +01:00
|
|
|
#include "vp9/common/vp9_entropy.h"
|
2012-11-28 19:41:40 +01:00
|
|
|
#include "vp9/encoder/vp9_block.h"
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-10-30 20:58:42 +01:00
|
|
|
void vp9_tokenize_initialize();
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
typedef struct {
|
2012-12-19 00:31:19 +01:00
|
|
|
int16_t Token;
|
|
|
|
|
int16_t Extra;
|
2010-09-16 16:00:04 +02:00
|
|
|
} TOKENVALUE;
|
|
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
typedef struct {
|
2012-10-31 22:40:53 +01:00
|
|
|
const vp9_prob *context_tree;
|
2012-12-19 00:31:19 +01:00
|
|
|
int16_t Extra;
|
|
|
|
|
uint8_t Token;
|
|
|
|
|
uint8_t skip_eob_node;
|
2010-05-18 17:58:33 +02:00
|
|
|
} TOKENEXTRA;
|
|
|
|
|
|
2012-12-14 21:35:33 +01:00
|
|
|
typedef int64_t vp9_coeff_accum[COEF_BANDS][PREV_COEF_CONTEXTS]
|
|
|
|
|
[MAX_ENTROPY_TOKENS];
|
2012-12-08 01:09:59 +01:00
|
|
|
|
2012-10-30 05:07:40 +01:00
|
|
|
extern int vp9_mby_is_skippable_4x4(MACROBLOCKD *xd, int has_y2_block);
|
|
|
|
|
extern int vp9_mbuv_is_skippable_4x4(MACROBLOCKD *xd);
|
|
|
|
|
extern int vp9_mby_is_skippable_8x8(MACROBLOCKD *xd, int has_y2_block);
|
|
|
|
|
extern int vp9_mbuv_is_skippable_8x8(MACROBLOCKD *xd);
|
|
|
|
|
extern int vp9_mby_is_skippable_16x16(MACROBLOCKD *xd);
|
32x32 transform for superblocks.
This adds Debargha's DCT/DWT hybrid and a regular 32x32 DCT, and adds
code all over the place to wrap that in the bitstream/encoder/decoder/RD.
Some implementation notes (these probably need careful review):
- token range is extended by 1 bit, since the value range out of this
transform is [-16384,16383].
- the coefficients coming out of the FDCT are manually scaled back by
1 bit, or else they won't fit in int16_t (they are 17 bits). Because
of this, the RD error scoring does not right-shift the MSE score by
two (unlike for 4x4/8x8/16x16).
- to compensate for this loss in precision, the quantizer is halved
also. This is currently a little hacky.
- FDCT and IDCT is double-only right now. Needs a fixed-point impl.
- There are no default probabilities for the 32x32 transform yet; I'm
simply using the 16x16 luma ones. A future commit will add newly
generated probabilities for all transforms.
- No ADST version. I don't think we'll add one for this level; if an
ADST is desired, transform-size selection can scale back to 16x16
or lower, and use an ADST at that level.
Additional notes specific to Debargha's DWT/DCT hybrid:
- coefficient scale is different for the top/left 16x16 (DCT-over-DWT)
block than for the rest (DWT pixel differences) of the block. Therefore,
RD error scoring isn't easily scalable between coefficient and pixel
domain. Thus, unfortunately, we need to compute the RD distortion in
the pixel domain until we figure out how to scale these appropriately.
Change-Id: I00386f20f35d7fabb19aba94c8162f8aee64ef2b
2012-12-07 23:45:05 +01:00
|
|
|
extern int vp9_sby_is_skippable_32x32(MACROBLOCKD *xd);
|
|
|
|
|
extern int vp9_sbuv_is_skippable_16x16(MACROBLOCKD *xd);
|
2012-02-22 03:10:18 +01:00
|
|
|
|
2012-11-02 19:22:57 +01:00
|
|
|
struct VP9_COMP;
|
|
|
|
|
|
|
|
|
|
extern void vp9_tokenize_mb(struct VP9_COMP *cpi, MACROBLOCKD *xd,
|
|
|
|
|
TOKENEXTRA **t, int dry_run);
|
32x32 transform for superblocks.
This adds Debargha's DCT/DWT hybrid and a regular 32x32 DCT, and adds
code all over the place to wrap that in the bitstream/encoder/decoder/RD.
Some implementation notes (these probably need careful review):
- token range is extended by 1 bit, since the value range out of this
transform is [-16384,16383].
- the coefficients coming out of the FDCT are manually scaled back by
1 bit, or else they won't fit in int16_t (they are 17 bits). Because
of this, the RD error scoring does not right-shift the MSE score by
two (unlike for 4x4/8x8/16x16).
- to compensate for this loss in precision, the quantizer is halved
also. This is currently a little hacky.
- FDCT and IDCT is double-only right now. Needs a fixed-point impl.
- There are no default probabilities for the 32x32 transform yet; I'm
simply using the 16x16 luma ones. A future commit will add newly
generated probabilities for all transforms.
- No ADST version. I don't think we'll add one for this level; if an
ADST is desired, transform-size selection can scale back to 16x16
or lower, and use an ADST at that level.
Additional notes specific to Debargha's DWT/DCT hybrid:
- coefficient scale is different for the top/left 16x16 (DCT-over-DWT)
block than for the rest (DWT pixel differences) of the block. Therefore,
RD error scoring isn't easily scalable between coefficient and pixel
domain. Thus, unfortunately, we need to compute the RD distortion in
the pixel domain until we figure out how to scale these appropriately.
Change-Id: I00386f20f35d7fabb19aba94c8162f8aee64ef2b
2012-12-07 23:45:05 +01:00
|
|
|
extern void vp9_tokenize_sb(struct VP9_COMP *cpi, MACROBLOCKD *xd,
|
|
|
|
|
TOKENEXTRA **t, int dry_run);
|
2012-11-02 19:22:57 +01:00
|
|
|
|
|
|
|
|
extern void vp9_stuff_mb(struct VP9_COMP *cpi, MACROBLOCKD *xd,
|
|
|
|
|
TOKENEXTRA **t, int dry_run);
|
32x32 transform for superblocks.
This adds Debargha's DCT/DWT hybrid and a regular 32x32 DCT, and adds
code all over the place to wrap that in the bitstream/encoder/decoder/RD.
Some implementation notes (these probably need careful review):
- token range is extended by 1 bit, since the value range out of this
transform is [-16384,16383].
- the coefficients coming out of the FDCT are manually scaled back by
1 bit, or else they won't fit in int16_t (they are 17 bits). Because
of this, the RD error scoring does not right-shift the MSE score by
two (unlike for 4x4/8x8/16x16).
- to compensate for this loss in precision, the quantizer is halved
also. This is currently a little hacky.
- FDCT and IDCT is double-only right now. Needs a fixed-point impl.
- There are no default probabilities for the 32x32 transform yet; I'm
simply using the 16x16 luma ones. A future commit will add newly
generated probabilities for all transforms.
- No ADST version. I don't think we'll add one for this level; if an
ADST is desired, transform-size selection can scale back to 16x16
or lower, and use an ADST at that level.
Additional notes specific to Debargha's DWT/DCT hybrid:
- coefficient scale is different for the top/left 16x16 (DCT-over-DWT)
block than for the rest (DWT pixel differences) of the block. Therefore,
RD error scoring isn't easily scalable between coefficient and pixel
domain. Thus, unfortunately, we need to compute the RD distortion in
the pixel domain until we figure out how to scale these appropriately.
Change-Id: I00386f20f35d7fabb19aba94c8162f8aee64ef2b
2012-12-07 23:45:05 +01:00
|
|
|
extern void vp9_stuff_sb(struct VP9_COMP *cpi, MACROBLOCKD *xd,
|
|
|
|
|
TOKENEXTRA **t, int dry_run);
|
2012-11-02 19:22:57 +01:00
|
|
|
|
32x32 transform for superblocks.
This adds Debargha's DCT/DWT hybrid and a regular 32x32 DCT, and adds
code all over the place to wrap that in the bitstream/encoder/decoder/RD.
Some implementation notes (these probably need careful review):
- token range is extended by 1 bit, since the value range out of this
transform is [-16384,16383].
- the coefficients coming out of the FDCT are manually scaled back by
1 bit, or else they won't fit in int16_t (they are 17 bits). Because
of this, the RD error scoring does not right-shift the MSE score by
two (unlike for 4x4/8x8/16x16).
- to compensate for this loss in precision, the quantizer is halved
also. This is currently a little hacky.
- FDCT and IDCT is double-only right now. Needs a fixed-point impl.
- There are no default probabilities for the 32x32 transform yet; I'm
simply using the 16x16 luma ones. A future commit will add newly
generated probabilities for all transforms.
- No ADST version. I don't think we'll add one for this level; if an
ADST is desired, transform-size selection can scale back to 16x16
or lower, and use an ADST at that level.
Additional notes specific to Debargha's DWT/DCT hybrid:
- coefficient scale is different for the top/left 16x16 (DCT-over-DWT)
block than for the rest (DWT pixel differences) of the block. Therefore,
RD error scoring isn't easily scalable between coefficient and pixel
domain. Thus, unfortunately, we need to compute the RD distortion in
the pixel domain until we figure out how to scale these appropriately.
Change-Id: I00386f20f35d7fabb19aba94c8162f8aee64ef2b
2012-12-07 23:45:05 +01:00
|
|
|
extern void vp9_fix_contexts_sb(MACROBLOCKD *xd);
|
2010-05-18 17:58:33 +02:00
|
|
|
#ifdef ENTROPY_STATS
|
|
|
|
|
void init_context_counters();
|
|
|
|
|
void print_context_counters();
|
|
|
|
|
|
2012-12-08 01:09:59 +01:00
|
|
|
extern vp9_coeff_accum context_counters_4x4[BLOCK_TYPES_4X4];
|
|
|
|
|
extern vp9_coeff_accum context_counters_8x8[BLOCK_TYPES_8X8];
|
|
|
|
|
extern vp9_coeff_accum context_counters_16x16[BLOCK_TYPES_16X16];
|
|
|
|
|
extern vp9_coeff_accum context_counters_32x32[BLOCK_TYPES_32X32];
|
|
|
|
|
|
|
|
|
|
extern vp9_coeff_accum hybrid_context_counters_4x4[BLOCK_TYPES_4X4];
|
|
|
|
|
extern vp9_coeff_accum hybrid_context_counters_8x8[BLOCK_TYPES_8X8];
|
|
|
|
|
extern vp9_coeff_accum hybrid_context_counters_16x16[BLOCK_TYPES_16X16];
|
2012-08-03 02:03:14 +02:00
|
|
|
#endif
|
|
|
|
|
|
2012-10-31 01:12:12 +01:00
|
|
|
extern const int *vp9_dct_value_cost_ptr;
|
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
|
|
|
/* TODO: The Token field should be broken out into a separate char array to
|
|
|
|
|
* improve cache locality, since it's needed for costing when the rest of the
|
|
|
|
|
* fields are not.
|
|
|
|
|
*/
|
2012-10-31 01:12:12 +01:00
|
|
|
extern const TOKENVALUE *vp9_dct_value_tokens_ptr;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-12-19 00:31:19 +01:00
|
|
|
#endif // VP9_ENCODER_VP9_TOKENIZE_H_
|