entcode.h 4.77 KB
 Yushin Cho committed Nov 06, 2016 1 2 3 4 5 6 7 8 9 10 ``````/* * Copyright (c) 2001-2016, Alliance for Open Media. All rights reserved * * 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. */ `````` Nathan E. Egge committed Oct 14, 2016 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 `````` #if !defined(_entcode_H) #define _entcode_H (1) #include #include #include "av1/common/odintrin.h" /*Set this flag 1 to enable a "reduced overhead" version of the entropy coder. This uses a partition function that more accurately follows the input probability estimates at the expense of some additional CPU cost (though still an order of magnitude less than a full division). In classic arithmetic coding, the partition function maps a value x in the range [0, ft] to a value in y in [0, r] with 0 < ft <= r via y = x*r/ft. Any deviation from this value increases coding inefficiency. To avoid divisions, we require ft <= r < 2*ft (enforcing it by shifting up ft if necessary), and replace that function with y = x + OD_MINI(x, r - ft). This counts values of x smaller than r - ft double compared to values larger than r - ft, which over-estimates the probability of symbols at the start of the alphabet, and under-estimates the probability of symbols at the end of the alphabet. The overall coding inefficiency assuming accurate probability models and independent symbols is in the 1% range, which is similar to that of CABAC. To reduce overhead even further, we split this into two cases: 1) r - ft > ft - (r - ft). That is, we have more values of x that are double-counted than single-counted. In this case, we still double-count the first 2*r - 3*ft values of x, but after that we alternate between single-counting and double-counting for the rest. 2) r - ft < ft - (r - ft). That is, we have more values of x that are single-counted than double-counted. In this case, we alternate between single-counting and double-counting for the first 2*(r - ft) values of x, and single-count the rest. For two equiprobable symbols in different places in the alphabet, this reduces the maximum ratio of over-estimation to under-estimation from 2:1 for the previous partition function to either 4:3 or 3:2 (for each of the two cases above, respectively), assuming symbol probabilities significantly greater than 1/32768. That reduces the worst-case per-symbol overhead from 1 bit to 0.58 bits. The resulting function is e = OD_MAXI(2*r - 3*ft, 0); y = x + OD_MINI(x, e) + OD_MINI(OD_MAXI(x - e, 0) >> 1, r - ft). Here, e is a value that is greater than 0 in case 1, and 0 in case 2. This function is about 3 times as expensive to evaluate as the high-overhead version, but still an order of magnitude cheaper than a division, since it is composed only of very simple operations. Because we want to fit in 16-bit registers and must use unsigned values to do so, we use saturating subtraction to enforce the maximums with 0. Enabling this reduces the measured overhead in ectest from 0.805% to 0.621% (vs. 0.022% for the division-based partition function with r much greater than ft). It improves performance on ntt-short-1 by about 0.3%.*/ #define OD_EC_REDUCED_OVERHEAD (1) /*OPT: od_ec_window must be at least 32 bits, but if you have fast arithmetic on a larger type, you can speed up the decoder by using it here.*/ typedef uint32_t od_ec_window; #define OD_EC_WINDOW_SIZE ((int)sizeof(od_ec_window) * CHAR_BIT) /*Unsigned subtraction with unsigned saturation. This implementation of the macro is intentionally chosen to increase the number of common subexpressions in the reduced-overhead partition function. This matters for C code, but it would not for hardware with a saturating subtraction instruction.*/ #define OD_SUBSATU(a, b) ((a)-OD_MINI(a, b)) /*The number of bits to use for the range-coded part of unsigned integers.*/ #define OD_EC_UINT_BITS (4) /*The resolution of fractional-precision bit usage measurements, i.e., 3 => 1/8th bits.*/ #define OD_BITRES (3) extern const uint16_t OD_UNIFORM_CDFS_Q15[135]; /*Returns a Q15 CDF for a uniform probability distribution of the given size. n: The size of the distribution. This must be at least 2, and no more than 16.*/ #define OD_UNIFORM_CDF_Q15(n) (OD_UNIFORM_CDFS_Q15 + ((n) * ((n)-1) >> 1) - 1) /*See entcode.c for further documentation.*/ OD_WARN_UNUSED_RESULT uint32_t od_ec_tell_frac(uint32_t nbits_total, uint32_t rng); #endif``````