2015-08-06 05:00:31 +03:00
|
|
|
/*
|
2016-09-02 22:04:54 +03:00
|
|
|
* Copyright (c) 2016, Alliance for Open Media. All rights reserved
|
2015-08-06 05:00:31 +03:00
|
|
|
*
|
2016-09-02 22:04:54 +03:00
|
|
|
* This source code is subject to the terms of the BSD 2 Clause License and
|
|
|
|
* the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
|
|
|
|
* was not distributed with this source code in the LICENSE file, you can
|
|
|
|
* obtain it at www.aomedia.org/license/software. If the Alliance for Open
|
|
|
|
* Media Patent License 1.0 was not distributed with this source code in the
|
|
|
|
* PATENTS file, you can obtain it at www.aomedia.org/license/patent.
|
2015-08-06 05:00:31 +03:00
|
|
|
*/
|
|
|
|
|
2016-08-31 00:01:10 +03:00
|
|
|
#ifndef AV1_COMMON_ENTROPY_H_
|
|
|
|
#define AV1_COMMON_ENTROPY_H_
|
2015-08-06 05:00:31 +03:00
|
|
|
|
2016-08-31 00:01:10 +03:00
|
|
|
#include "aom/aom_integer.h"
|
2016-08-23 02:08:15 +03:00
|
|
|
#include "aom_dsp/prob.h"
|
2015-08-06 05:00:31 +03:00
|
|
|
|
2015-12-16 22:17:25 +03:00
|
|
|
#if CONFIG_ANS
|
2016-08-23 02:08:15 +03:00
|
|
|
#include "av1/common/ans.h"
|
2015-12-16 22:17:25 +03:00
|
|
|
#endif // CONFIG_ANS
|
2016-08-23 02:08:15 +03:00
|
|
|
#include "av1/common/common.h"
|
|
|
|
#include "av1/common/enums.h"
|
2015-08-06 05:00:31 +03:00
|
|
|
|
|
|
|
#ifdef __cplusplus
|
|
|
|
extern "C" {
|
|
|
|
#endif
|
|
|
|
|
2016-08-12 04:55:00 +03:00
|
|
|
#define DIFF_UPDATE_PROB 252
|
2015-09-03 12:58:12 +03:00
|
|
|
#define GROUP_DIFF_UPDATE_PROB 252
|
2015-08-06 05:00:31 +03:00
|
|
|
|
2016-01-08 01:29:26 +03:00
|
|
|
#if CONFIG_ENTROPY
|
|
|
|
#define COEF_PROBS_BUFS 16
|
|
|
|
#define QCTX_BIN_BITS 2
|
|
|
|
#define QCTX_BINS (1 << QCTX_BIN_BITS)
|
|
|
|
#endif // CONFIG_ENTROPY
|
|
|
|
|
2015-08-06 05:00:31 +03:00
|
|
|
// Coefficient token alphabet
|
2016-08-12 04:55:00 +03:00
|
|
|
#define ZERO_TOKEN 0 // 0 Extra Bits 0+0
|
|
|
|
#define ONE_TOKEN 1 // 1 Extra Bits 0+1
|
|
|
|
#define TWO_TOKEN 2 // 2 Extra Bits 0+1
|
|
|
|
#define THREE_TOKEN 3 // 3 Extra Bits 0+1
|
|
|
|
#define FOUR_TOKEN 4 // 4 Extra Bits 0+1
|
2015-08-06 05:00:31 +03:00
|
|
|
#define CATEGORY1_TOKEN 5 // 5-6 Extra Bits 1+1
|
|
|
|
#define CATEGORY2_TOKEN 6 // 7-10 Extra Bits 2+1
|
|
|
|
#define CATEGORY3_TOKEN 7 // 11-18 Extra Bits 3+1
|
|
|
|
#define CATEGORY4_TOKEN 8 // 19-34 Extra Bits 4+1
|
|
|
|
#define CATEGORY5_TOKEN 9 // 35-66 Extra Bits 5+1
|
|
|
|
#define CATEGORY6_TOKEN 10 // 67+ Extra Bits 14+1
|
2016-08-12 04:55:00 +03:00
|
|
|
#define EOB_TOKEN 11 // EOB Extra Bits 0+0
|
2015-08-06 05:00:31 +03:00
|
|
|
|
|
|
|
#define ENTROPY_TOKENS 12
|
|
|
|
|
|
|
|
#define ENTROPY_NODES 11
|
|
|
|
|
2016-08-31 00:01:10 +03:00
|
|
|
DECLARE_ALIGNED(16, extern const uint8_t, av1_pt_energy_class[ENTROPY_TOKENS]);
|
2015-08-06 05:00:31 +03:00
|
|
|
|
2016-08-12 04:55:00 +03:00
|
|
|
#define CAT1_MIN_VAL 5
|
|
|
|
#define CAT2_MIN_VAL 7
|
|
|
|
#define CAT3_MIN_VAL 11
|
|
|
|
#define CAT4_MIN_VAL 19
|
|
|
|
#define CAT5_MIN_VAL 35
|
|
|
|
#define CAT6_MIN_VAL 67
|
2015-08-06 05:00:31 +03:00
|
|
|
|
|
|
|
// Extra bit probabilities.
|
2016-08-31 00:01:10 +03:00
|
|
|
DECLARE_ALIGNED(16, extern const uint8_t, av1_cat1_prob[1]);
|
|
|
|
DECLARE_ALIGNED(16, extern const uint8_t, av1_cat2_prob[2]);
|
|
|
|
DECLARE_ALIGNED(16, extern const uint8_t, av1_cat3_prob[3]);
|
|
|
|
DECLARE_ALIGNED(16, extern const uint8_t, av1_cat4_prob[4]);
|
|
|
|
DECLARE_ALIGNED(16, extern const uint8_t, av1_cat5_prob[5]);
|
|
|
|
DECLARE_ALIGNED(16, extern const uint8_t, av1_cat6_prob[14]);
|
|
|
|
|
|
|
|
#if CONFIG_AOM_HIGHBITDEPTH
|
|
|
|
DECLARE_ALIGNED(16, extern const uint8_t, av1_cat1_prob_high10[1]);
|
|
|
|
DECLARE_ALIGNED(16, extern const uint8_t, av1_cat2_prob_high10[2]);
|
|
|
|
DECLARE_ALIGNED(16, extern const uint8_t, av1_cat3_prob_high10[3]);
|
|
|
|
DECLARE_ALIGNED(16, extern const uint8_t, av1_cat4_prob_high10[4]);
|
|
|
|
DECLARE_ALIGNED(16, extern const uint8_t, av1_cat5_prob_high10[5]);
|
|
|
|
DECLARE_ALIGNED(16, extern const uint8_t, av1_cat6_prob_high10[16]);
|
|
|
|
DECLARE_ALIGNED(16, extern const uint8_t, av1_cat1_prob_high12[1]);
|
|
|
|
DECLARE_ALIGNED(16, extern const uint8_t, av1_cat2_prob_high12[2]);
|
|
|
|
DECLARE_ALIGNED(16, extern const uint8_t, av1_cat3_prob_high12[3]);
|
|
|
|
DECLARE_ALIGNED(16, extern const uint8_t, av1_cat4_prob_high12[4]);
|
|
|
|
DECLARE_ALIGNED(16, extern const uint8_t, av1_cat5_prob_high12[5]);
|
|
|
|
DECLARE_ALIGNED(16, extern const uint8_t, av1_cat6_prob_high12[18]);
|
|
|
|
#endif // CONFIG_AOM_HIGHBITDEPTH
|
2015-08-06 05:00:31 +03:00
|
|
|
|
|
|
|
#define EOB_MODEL_TOKEN 3
|
|
|
|
|
|
|
|
typedef struct {
|
2016-08-31 00:01:10 +03:00
|
|
|
const aom_tree_index *tree;
|
|
|
|
const aom_prob *prob;
|
2015-08-06 05:00:31 +03:00
|
|
|
int len;
|
|
|
|
int base_val;
|
|
|
|
const int16_t *cost;
|
2016-08-31 00:01:10 +03:00
|
|
|
} av1_extra_bit;
|
2015-08-06 05:00:31 +03:00
|
|
|
|
|
|
|
// indexed by token value
|
2016-08-31 00:01:10 +03:00
|
|
|
extern const av1_extra_bit av1_extra_bits[ENTROPY_TOKENS];
|
|
|
|
#if CONFIG_AOM_HIGHBITDEPTH
|
|
|
|
extern const av1_extra_bit av1_extra_bits_high10[ENTROPY_TOKENS];
|
|
|
|
extern const av1_extra_bit av1_extra_bits_high12[ENTROPY_TOKENS];
|
|
|
|
#endif // CONFIG_AOM_HIGHBITDEPTH
|
2015-08-06 05:00:31 +03:00
|
|
|
|
2016-08-12 04:55:00 +03:00
|
|
|
#define DCT_MAX_VALUE 16384
|
2016-08-31 00:01:10 +03:00
|
|
|
#if CONFIG_AOM_HIGHBITDEPTH
|
2016-08-12 04:55:00 +03:00
|
|
|
#define DCT_MAX_VALUE_HIGH10 65536
|
|
|
|
#define DCT_MAX_VALUE_HIGH12 262144
|
2016-08-31 00:01:10 +03:00
|
|
|
#endif // CONFIG_AOM_HIGHBITDEPTH
|
2015-08-06 05:00:31 +03:00
|
|
|
|
|
|
|
/* Coefficients are predicted via a 3-dimensional probability table. */
|
|
|
|
|
|
|
|
#define REF_TYPES 2 // intra=0, inter=1
|
|
|
|
|
|
|
|
/* Middle dimension reflects the coefficient position within the transform. */
|
|
|
|
#define COEF_BANDS 6
|
|
|
|
|
|
|
|
/* Inside dimension is measure of nearby complexity, that reflects the energy
|
|
|
|
of nearby coefficients are nonzero. For the first coefficient (DC, unless
|
|
|
|
block type is 0), we look at the (already encoded) blocks above and to the
|
|
|
|
left of the current block. The context index is then the number (0,1,or 2)
|
|
|
|
of these blocks having nonzero coefficients.
|
|
|
|
After decoding a coefficient, the measure is determined by the size of the
|
|
|
|
most recently decoded coefficient.
|
|
|
|
Note that the intuitive meaning of this measure changes as coefficients
|
|
|
|
are decoded, e.g., prior to the first token, a zero means that my neighbors
|
|
|
|
are empty while, after the first token, because of the use of end-of-block,
|
|
|
|
a zero means we just decoded a zero and hence guarantees that a non-zero
|
|
|
|
coefficient will appear later in this block. However, this shift
|
|
|
|
in meaning is perfectly OK because our context depends also on the
|
|
|
|
coefficient band (and since zigzag positions 0, 1, and 2 are in
|
|
|
|
distinct bands). */
|
|
|
|
|
|
|
|
#define COEFF_CONTEXTS 6
|
|
|
|
#define BAND_COEFF_CONTEXTS(band) ((band) == 0 ? 3 : COEFF_CONTEXTS)
|
|
|
|
|
|
|
|
// #define ENTROPY_STATS
|
|
|
|
|
2016-08-12 04:55:00 +03:00
|
|
|
typedef unsigned int
|
2016-08-31 00:01:10 +03:00
|
|
|
av1_coeff_count[REF_TYPES][COEF_BANDS][COEFF_CONTEXTS][ENTROPY_TOKENS];
|
2016-08-12 04:55:00 +03:00
|
|
|
typedef unsigned int
|
2016-08-31 00:01:10 +03:00
|
|
|
av1_coeff_stats[REF_TYPES][COEF_BANDS][COEFF_CONTEXTS][ENTROPY_NODES][2];
|
2015-08-06 05:00:31 +03:00
|
|
|
|
2016-08-12 04:55:00 +03:00
|
|
|
#define SUBEXP_PARAM 4 /* Subexponential code parameter */
|
|
|
|
#define MODULUS_PARAM 13 /* Modulus parameter */
|
2015-08-06 05:00:31 +03:00
|
|
|
|
2016-08-31 00:01:10 +03:00
|
|
|
struct AV1Common;
|
|
|
|
void av1_default_coef_probs(struct AV1Common *cm);
|
|
|
|
void av1_adapt_coef_probs(struct AV1Common *cm);
|
2016-01-08 01:29:26 +03:00
|
|
|
#if CONFIG_ENTROPY
|
2016-08-31 00:01:10 +03:00
|
|
|
void av1_partial_adapt_probs(struct AV1Common *cm, int mi_row, int mi_col);
|
2016-01-08 01:29:26 +03:00
|
|
|
#endif // CONFIG_ENTROPY
|
2015-08-06 05:00:31 +03:00
|
|
|
|
|
|
|
// This is the index in the scan order beyond which all coefficients for
|
|
|
|
// 8x8 transform and above are in the top band.
|
|
|
|
// This macro is currently unused but may be used by certain implementations
|
|
|
|
#define MAXBAND_INDEX 21
|
|
|
|
|
2016-08-31 00:01:10 +03:00
|
|
|
DECLARE_ALIGNED(16, extern const uint8_t, av1_coefband_trans_8x8plus[1024]);
|
2016-07-01 22:57:14 +03:00
|
|
|
#if CONFIG_EXT_TX
|
2016-08-31 00:01:10 +03:00
|
|
|
DECLARE_ALIGNED(16, extern const uint8_t, av1_coefband_trans_4x8_8x4[32]);
|
2016-07-01 22:57:14 +03:00
|
|
|
#endif // CONFIG_EXT_TX
|
2016-08-31 00:01:10 +03:00
|
|
|
DECLARE_ALIGNED(16, extern const uint8_t, av1_coefband_trans_4x4[16]);
|
2015-08-06 05:00:31 +03:00
|
|
|
|
2016-08-12 04:55:00 +03:00
|
|
|
DECLARE_ALIGNED(16, extern const uint16_t, band_count_table[TX_SIZES_ALL][8]);
|
2016-07-01 22:57:14 +03:00
|
|
|
DECLARE_ALIGNED(16, extern const uint16_t,
|
|
|
|
band_cum_count_table[TX_SIZES_ALL][8]);
|
|
|
|
|
2015-08-06 05:00:31 +03:00
|
|
|
static INLINE const uint8_t *get_band_translate(TX_SIZE tx_size) {
|
2016-07-01 22:57:14 +03:00
|
|
|
switch (tx_size) {
|
2016-08-31 00:01:10 +03:00
|
|
|
case TX_4X4: return av1_coefband_trans_4x4;
|
2016-07-01 22:57:14 +03:00
|
|
|
#if CONFIG_EXT_TX
|
2016-08-31 00:01:10 +03:00
|
|
|
case TX_4X8: return av1_coefband_trans_4x8_8x4;
|
2016-07-01 22:57:14 +03:00
|
|
|
#endif // CONFIG_EXT_TX
|
2016-08-31 00:01:10 +03:00
|
|
|
default: return av1_coefband_trans_8x8plus;
|
2016-07-01 22:57:14 +03:00
|
|
|
}
|
2015-08-06 05:00:31 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
// 128 lists of probabilities are stored for the following ONE node probs:
|
|
|
|
// 1, 3, 5, 7, ..., 253, 255
|
|
|
|
// In between probabilities are interpolated linearly
|
|
|
|
|
2015-10-09 02:01:42 +03:00
|
|
|
#define COEFF_PROB_MODELS 255
|
2015-08-06 05:00:31 +03:00
|
|
|
|
2016-08-12 04:55:00 +03:00
|
|
|
#define UNCONSTRAINED_NODES 3
|
2015-08-06 05:00:31 +03:00
|
|
|
|
2016-08-12 04:55:00 +03:00
|
|
|
#define PIVOT_NODE 2 // which node is pivot
|
2015-08-06 05:00:31 +03:00
|
|
|
|
|
|
|
#define MODEL_NODES (ENTROPY_NODES - UNCONSTRAINED_NODES)
|
2016-08-31 00:01:10 +03:00
|
|
|
extern const aom_tree_index av1_coef_con_tree[TREE_SIZE(ENTROPY_TOKENS)];
|
|
|
|
extern const aom_prob av1_pareto8_full[COEFF_PROB_MODELS][MODEL_NODES];
|
2015-12-16 22:17:25 +03:00
|
|
|
#if CONFIG_ANS
|
2016-01-06 23:37:27 +03:00
|
|
|
extern const AnsP10
|
2016-08-31 00:01:10 +03:00
|
|
|
av1_pareto8_token_probs[COEFF_PROB_MODELS][ENTROPY_TOKENS - 2];
|
2015-12-16 22:17:25 +03:00
|
|
|
|
2016-02-19 23:51:15 +03:00
|
|
|
typedef rans_dec_lut coeff_cdf_model[REF_TYPES][COEF_BANDS][COEFF_CONTEXTS];
|
2015-12-16 22:17:25 +03:00
|
|
|
#endif // CONFIG_ANS
|
2015-08-06 05:00:31 +03:00
|
|
|
|
2016-08-31 00:01:10 +03:00
|
|
|
typedef aom_prob av1_coeff_probs_model[REF_TYPES][COEF_BANDS][COEFF_CONTEXTS]
|
|
|
|
[UNCONSTRAINED_NODES];
|
2015-08-06 05:00:31 +03:00
|
|
|
|
2016-08-31 00:01:10 +03:00
|
|
|
typedef unsigned int av1_coeff_count_model
|
2016-08-12 04:55:00 +03:00
|
|
|
[REF_TYPES][COEF_BANDS][COEFF_CONTEXTS][UNCONSTRAINED_NODES + 1];
|
2015-08-06 05:00:31 +03:00
|
|
|
|
2016-08-31 00:01:10 +03:00
|
|
|
void av1_model_to_full_probs(const aom_prob *model, aom_prob *full);
|
2015-08-06 05:00:31 +03:00
|
|
|
|
|
|
|
typedef char ENTROPY_CONTEXT;
|
|
|
|
|
|
|
|
static INLINE int combine_entropy_contexts(ENTROPY_CONTEXT a,
|
|
|
|
ENTROPY_CONTEXT b) {
|
|
|
|
return (a != 0) + (b != 0);
|
|
|
|
}
|
|
|
|
|
2016-08-12 04:55:00 +03:00
|
|
|
static INLINE int get_entropy_context(TX_SIZE tx_size, const ENTROPY_CONTEXT *a,
|
2015-08-06 05:00:31 +03:00
|
|
|
const ENTROPY_CONTEXT *l) {
|
|
|
|
ENTROPY_CONTEXT above_ec = 0, left_ec = 0;
|
|
|
|
|
|
|
|
switch (tx_size) {
|
|
|
|
case TX_4X4:
|
|
|
|
above_ec = a[0] != 0;
|
|
|
|
left_ec = l[0] != 0;
|
|
|
|
break;
|
2016-07-01 22:57:14 +03:00
|
|
|
#if CONFIG_EXT_TX
|
|
|
|
case TX_4X8:
|
|
|
|
above_ec = a[0] != 0;
|
|
|
|
left_ec = !!*(const uint16_t *)l;
|
|
|
|
break;
|
|
|
|
case TX_8X4:
|
|
|
|
above_ec = !!*(const uint16_t *)a;
|
|
|
|
left_ec = l[0] != 0;
|
|
|
|
break;
|
2016-07-22 18:55:42 +03:00
|
|
|
case TX_8X16:
|
|
|
|
above_ec = !!*(const uint16_t *)a;
|
2016-08-19 01:10:22 +03:00
|
|
|
left_ec = !!*(const uint32_t *)l;
|
2016-07-22 18:55:42 +03:00
|
|
|
break;
|
|
|
|
case TX_16X8:
|
|
|
|
above_ec = !!*(const uint32_t *)a;
|
2016-08-19 01:10:22 +03:00
|
|
|
left_ec = !!*(const uint16_t *)l;
|
2016-07-22 18:55:42 +03:00
|
|
|
break;
|
|
|
|
case TX_16X32:
|
|
|
|
above_ec = !!*(const uint32_t *)a;
|
2016-08-19 01:10:22 +03:00
|
|
|
left_ec = !!*(const uint64_t *)l;
|
2016-07-22 18:55:42 +03:00
|
|
|
break;
|
|
|
|
case TX_32X16:
|
|
|
|
above_ec = !!*(const uint64_t *)a;
|
2016-08-19 01:10:22 +03:00
|
|
|
left_ec = !!*(const uint32_t *)l;
|
2016-07-22 18:55:42 +03:00
|
|
|
break;
|
2016-07-01 22:57:14 +03:00
|
|
|
#endif // CONFIG_EXT_TX
|
2015-08-06 05:00:31 +03:00
|
|
|
case TX_8X8:
|
|
|
|
above_ec = !!*(const uint16_t *)a;
|
2016-08-12 04:55:00 +03:00
|
|
|
left_ec = !!*(const uint16_t *)l;
|
2015-08-06 05:00:31 +03:00
|
|
|
break;
|
|
|
|
case TX_16X16:
|
|
|
|
above_ec = !!*(const uint32_t *)a;
|
2016-08-12 04:55:00 +03:00
|
|
|
left_ec = !!*(const uint32_t *)l;
|
2015-08-06 05:00:31 +03:00
|
|
|
break;
|
|
|
|
case TX_32X32:
|
|
|
|
above_ec = !!*(const uint64_t *)a;
|
2016-08-12 04:55:00 +03:00
|
|
|
left_ec = !!*(const uint64_t *)l;
|
2015-08-06 05:00:31 +03:00
|
|
|
break;
|
2016-08-12 04:55:00 +03:00
|
|
|
default: assert(0 && "Invalid transform size."); break;
|
2015-08-06 05:00:31 +03:00
|
|
|
}
|
|
|
|
return combine_entropy_contexts(above_ec, left_ec);
|
|
|
|
}
|
|
|
|
|
2016-02-19 23:51:15 +03:00
|
|
|
#if CONFIG_ANS
|
|
|
|
struct frame_contexts;
|
2016-08-31 00:01:10 +03:00
|
|
|
void av1_coef_pareto_cdfs(struct frame_contexts *fc);
|
2016-02-19 23:51:15 +03:00
|
|
|
#endif // CONFIG_ANS
|
2016-04-27 01:04:19 +03:00
|
|
|
|
|
|
|
#if CONFIG_ENTROPY
|
2016-08-12 04:55:00 +03:00
|
|
|
#define COEF_COUNT_SAT_BITS 5
|
|
|
|
#define COEF_MAX_UPDATE_FACTOR_BITS 7
|
|
|
|
#define COEF_COUNT_SAT_AFTER_KEY_BITS 5
|
2016-04-27 01:04:19 +03:00
|
|
|
#define COEF_MAX_UPDATE_FACTOR_AFTER_KEY_BITS 7
|
2016-08-12 04:55:00 +03:00
|
|
|
#define MODE_MV_COUNT_SAT_BITS 5
|
|
|
|
#define MODE_MV_MAX_UPDATE_FACTOR_BITS 7
|
2016-04-27 01:04:19 +03:00
|
|
|
|
|
|
|
#else
|
|
|
|
|
|
|
|
#define COEF_COUNT_SAT 24
|
|
|
|
#define COEF_MAX_UPDATE_FACTOR 112
|
|
|
|
#define COEF_COUNT_SAT_AFTER_KEY 24
|
|
|
|
#define COEF_MAX_UPDATE_FACTOR_AFTER_KEY 128
|
|
|
|
|
|
|
|
#endif // CONFIG_ENTROPY
|
|
|
|
|
2016-08-31 00:01:10 +03:00
|
|
|
static INLINE aom_prob av1_merge_probs(aom_prob pre_prob,
|
|
|
|
const unsigned int ct[2],
|
|
|
|
unsigned int count_sat,
|
|
|
|
unsigned int max_update_factor) {
|
2016-04-27 01:04:19 +03:00
|
|
|
#if CONFIG_ENTROPY
|
2016-08-31 00:01:10 +03:00
|
|
|
const aom_prob prob = get_binary_prob(ct[0], ct[1]);
|
2016-04-27 01:04:19 +03:00
|
|
|
const unsigned int count =
|
2016-08-31 00:01:10 +03:00
|
|
|
AOMMIN(ct[0] + ct[1], (unsigned int)(1 << count_sat));
|
2016-08-12 04:55:00 +03:00
|
|
|
const unsigned int factor = count << (max_update_factor - count_sat);
|
2016-04-27 01:04:19 +03:00
|
|
|
return weighted_prob(pre_prob, prob, factor);
|
|
|
|
#else
|
|
|
|
return merge_probs(pre_prob, ct, count_sat, max_update_factor);
|
|
|
|
#endif // CONFIG_ENTROPY
|
|
|
|
}
|
|
|
|
|
2016-08-31 00:01:10 +03:00
|
|
|
static INLINE aom_prob av1_mode_mv_merge_probs(aom_prob pre_prob,
|
|
|
|
const unsigned int ct[2]) {
|
2016-04-27 01:04:19 +03:00
|
|
|
#if CONFIG_ENTROPY
|
2016-08-31 00:01:10 +03:00
|
|
|
return av1_merge_probs(pre_prob, ct, MODE_MV_COUNT_SAT_BITS,
|
|
|
|
MODE_MV_MAX_UPDATE_FACTOR_BITS);
|
2016-04-27 01:04:19 +03:00
|
|
|
#else
|
|
|
|
return mode_mv_merge_probs(pre_prob, ct);
|
|
|
|
#endif // CONFIG_ENTROPY
|
|
|
|
}
|
|
|
|
|
2015-08-06 05:00:31 +03:00
|
|
|
#ifdef __cplusplus
|
|
|
|
} // extern "C"
|
|
|
|
#endif
|
|
|
|
|
2016-08-31 00:01:10 +03:00
|
|
|
#endif // AV1_COMMON_ENTROPY_H_
|