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"
|
2013-12-05 02:39:30 +01:00
|
|
|
|
2012-11-28 19:41:40 +01:00
|
|
|
#include "vp9/encoder/vp9_block.h"
|
2013-12-05 02:39:30 +01:00
|
|
|
#include "vp9/encoder/vp9_treewriter.h"
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2014-01-18 21:16:11 +01:00
|
|
|
#ifdef __cplusplus
|
|
|
|
extern "C" {
|
|
|
|
#endif
|
|
|
|
|
2016-07-27 05:43:23 +02:00
|
|
|
#define EOSB_TOKEN 127 // Not signalled, encoder only
|
2013-12-04 02:23:03 +01:00
|
|
|
|
2014-10-01 06:56:33 +02:00
|
|
|
#if CONFIG_VP9_HIGHBITDEPTH
|
2016-07-27 05:43:23 +02:00
|
|
|
typedef int32_t EXTRABIT;
|
2014-10-01 06:56:33 +02:00
|
|
|
#else
|
2016-07-27 05:43:23 +02:00
|
|
|
typedef int16_t EXTRABIT;
|
2014-10-01 06:56:33 +02:00
|
|
|
#endif
|
2014-12-22 17:42:52 +01:00
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
int16_t token;
|
|
|
|
EXTRABIT extra;
|
2010-09-16 16:00:04 +02:00
|
|
|
} TOKENVALUE;
|
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
typedef struct {
|
2015-07-20 22:49:15 +02:00
|
|
|
const vpx_prob *context_tree;
|
2016-01-20 23:09:45 +01:00
|
|
|
int16_t token;
|
2014-12-22 17:42:52 +01:00
|
|
|
EXTRABIT extra;
|
2010-05-18 17:58:33 +02:00
|
|
|
} TOKENEXTRA;
|
|
|
|
|
2015-07-20 23:04:21 +02:00
|
|
|
extern const vpx_tree_index vp9_coef_tree[];
|
|
|
|
extern const vpx_tree_index vp9_coef_con_tree[];
|
2014-12-22 22:35:56 +01:00
|
|
|
extern const struct vp9_token vp9_coef_encodings[];
|
2013-11-27 20:27:57 +01:00
|
|
|
|
2013-12-04 02:59:32 +01:00
|
|
|
int vp9_is_skippable_in_plane(MACROBLOCK *x, BLOCK_SIZE bsize, int plane);
|
Rework partition search skip scheme
This commit enables the encoder to skip split partition search if
the bigger block size has all non-zero quantized coefficients in low
frequency area and the total rate cost is below a certain threshold.
It logarithmatically scales the rate threshold according to the
current block size. For speed 3, the compression performance loss:
derf -0.093%
stdhd -0.066%
Local experiments show 4% - 20% encoding speed-up for speed 3.
blue_sky_1080p, 1500 kbps
51051 b/f, 35.891 dB, 67236 ms ->
50554 b/f, 35.857 dB, 59270 ms (12% speed-up)
old_town_cross_720p, 1500 kbps
14431 b/f, 36.249 dB, 57687 ms ->
14108 b/f, 36.172 dB, 46586 ms (19% speed-up)
pedestrian_area_1080p, 1500 kbps
50812 b/f, 40.124 dB, 100439 ms ->
50755 b/f, 40.118 dB, 96549 ms (4% speed-up)
mobile_calendar_720p, 1000 kbps
10352 b/f, 35.055 dB, 51837 ms ->
10172 b/f, 35.003 dB, 44076 ms (15% speed-up)
Change-Id: I412e34db49060775b3b89ba1738522317c3239c8
2014-10-03 02:49:00 +02:00
|
|
|
int vp9_has_high_freq_in_plane(MACROBLOCK *x, BLOCK_SIZE bsize, int plane);
|
2013-12-04 02:59:32 +01:00
|
|
|
|
2012-11-02 19:22:57 +01:00
|
|
|
struct VP9_COMP;
|
2014-11-21 20:11:06 +01:00
|
|
|
struct ThreadData;
|
2012-11-02 19:22:57 +01:00
|
|
|
|
2014-11-21 20:11:06 +01:00
|
|
|
void vp9_tokenize_sb(struct VP9_COMP *cpi, struct ThreadData *td,
|
2016-04-08 20:38:25 +02:00
|
|
|
TOKENEXTRA **t, int dry_run, int seg_skip,
|
|
|
|
BLOCK_SIZE bsize);
|
2012-11-02 19:22:57 +01:00
|
|
|
|
2015-10-06 23:03:34 +02:00
|
|
|
typedef struct {
|
|
|
|
const vpx_prob *prob;
|
|
|
|
int len;
|
|
|
|
int base_val;
|
|
|
|
const int16_t *cost;
|
|
|
|
} vp9_extra_bit;
|
|
|
|
|
|
|
|
// indexed by token value
|
|
|
|
extern const vp9_extra_bit vp9_extra_bits[ENTROPY_TOKENS];
|
|
|
|
#if CONFIG_VP9_HIGHBITDEPTH
|
|
|
|
extern const vp9_extra_bit vp9_extra_bits_high10[ENTROPY_TOKENS];
|
|
|
|
extern const vp9_extra_bit vp9_extra_bits_high12[ENTROPY_TOKENS];
|
|
|
|
#endif // CONFIG_VP9_HIGHBITDEPTH
|
|
|
|
|
2014-02-25 22:06:42 +01:00
|
|
|
extern const int16_t *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;
|
2014-12-22 17:42:52 +01:00
|
|
|
extern const TOKENVALUE *vp9_dct_cat_lt_10_value_tokens;
|
2016-02-26 23:42:25 +01:00
|
|
|
extern const int *vp9_dct_cat_lt_10_value_cost;
|
2014-12-24 00:06:17 +01:00
|
|
|
extern const int16_t vp9_cat6_low_cost[256];
|
2016-01-13 23:21:30 +01:00
|
|
|
extern const int vp9_cat6_high_cost[64];
|
|
|
|
extern const int vp9_cat6_high10_high_cost[256];
|
|
|
|
extern const int vp9_cat6_high12_high_cost[1024];
|
|
|
|
static INLINE int vp9_get_cost(int16_t token, EXTRABIT extrabits,
|
|
|
|
const int *cat6_high_table) {
|
2014-12-24 00:06:17 +01:00
|
|
|
if (token != CATEGORY6_TOKEN)
|
2016-01-13 23:21:30 +01:00
|
|
|
return vp9_extra_bits[token].cost[extrabits >> 1];
|
2016-07-27 05:43:23 +02:00
|
|
|
return vp9_cat6_low_cost[(extrabits >> 1) & 0xff] +
|
|
|
|
cat6_high_table[extrabits >> 9];
|
2014-12-24 00:06:17 +01:00
|
|
|
}
|
|
|
|
|
2014-09-24 15:36:34 +02:00
|
|
|
#if CONFIG_VP9_HIGHBITDEPTH
|
2016-07-27 05:43:23 +02:00
|
|
|
static INLINE const int *vp9_get_high_cost_table(int bit_depth) {
|
2014-12-24 00:06:17 +01:00
|
|
|
return bit_depth == 8 ? vp9_cat6_high_cost
|
2016-07-27 05:43:23 +02:00
|
|
|
: (bit_depth == 10 ? vp9_cat6_high10_high_cost
|
|
|
|
: vp9_cat6_high12_high_cost);
|
2014-12-24 00:06:17 +01:00
|
|
|
}
|
|
|
|
#else
|
2016-07-27 05:43:23 +02:00
|
|
|
static INLINE const int *vp9_get_high_cost_table(int bit_depth) {
|
|
|
|
(void)bit_depth;
|
2014-12-24 00:06:17 +01:00
|
|
|
return vp9_cat6_high_cost;
|
|
|
|
}
|
2014-09-24 15:36:34 +02:00
|
|
|
#endif // CONFIG_VP9_HIGHBITDEPTH
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2014-12-22 17:42:52 +01:00
|
|
|
static INLINE void vp9_get_token_extra(int v, int16_t *token, EXTRABIT *extra) {
|
|
|
|
if (v >= CAT6_MIN_VAL || v <= -CAT6_MIN_VAL) {
|
|
|
|
*token = CATEGORY6_TOKEN;
|
|
|
|
if (v >= CAT6_MIN_VAL)
|
|
|
|
*extra = 2 * v - 2 * CAT6_MIN_VAL;
|
|
|
|
else
|
|
|
|
*extra = -2 * v - 2 * CAT6_MIN_VAL + 1;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
*token = vp9_dct_cat_lt_10_value_tokens[v].token;
|
|
|
|
*extra = vp9_dct_cat_lt_10_value_tokens[v].extra;
|
|
|
|
}
|
|
|
|
static INLINE int16_t vp9_get_token(int v) {
|
2016-07-27 05:43:23 +02:00
|
|
|
if (v >= CAT6_MIN_VAL || v <= -CAT6_MIN_VAL) return 10;
|
2014-12-22 17:42:52 +01:00
|
|
|
return vp9_dct_cat_lt_10_value_tokens[v].token;
|
|
|
|
}
|
|
|
|
|
2016-02-26 23:42:25 +01:00
|
|
|
static INLINE int vp9_get_token_cost(int v, int16_t *token,
|
|
|
|
const int *cat6_high_table) {
|
|
|
|
if (v >= CAT6_MIN_VAL || v <= -CAT6_MIN_VAL) {
|
|
|
|
EXTRABIT extrabits;
|
|
|
|
*token = CATEGORY6_TOKEN;
|
|
|
|
extrabits = abs(v) - CAT6_MIN_VAL;
|
|
|
|
return vp9_cat6_low_cost[extrabits & 0xff] +
|
|
|
|
cat6_high_table[extrabits >> 8];
|
|
|
|
}
|
|
|
|
*token = vp9_dct_cat_lt_10_value_tokens[v].token;
|
|
|
|
return vp9_dct_cat_lt_10_value_cost[v];
|
|
|
|
}
|
2014-12-22 17:42:52 +01:00
|
|
|
|
2014-01-18 21:16:11 +01:00
|
|
|
#ifdef __cplusplus
|
|
|
|
} // extern "C"
|
|
|
|
#endif
|
|
|
|
|
2012-12-19 00:31:19 +01:00
|
|
|
#endif // VP9_ENCODER_VP9_TOKENIZE_H_
|