1 // Copyright 2019 The libgav1 Authors
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
6 //
7 // http://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS IS" BASIS,
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 // See the License for the specific language governing permissions and
13 // limitations under the License.
14
15 #include "src/quantizer.h"
16
17 #include <cassert>
18 #include <cstdint>
19
20 #include "src/utils/common.h"
21 #include "src/utils/constants.h"
22
23 #if LIBGAV1_MAX_BITDEPTH != 8 && LIBGAV1_MAX_BITDEPTH != 10
24 #error LIBGAV1_MAX_BITDEPTH must be 8 or 10
25 #endif
26
27 namespace libgav1 {
28 namespace {
29
30 // Import all the constants in the anonymous namespace.
31 #include "src/quantizer_tables.inc"
32
33 // Format the kDcLookup and kAcLookup arrays manually for easier comparison
34 // with the Dc_Qlookup and Ac_Qlookup arrays in Section 7.12.2.
35
36 // clang-format off
37 constexpr int16_t kDcLookup[][256] = {
38 // Lookup table for 8 bit.
39 {
40 4, 8, 8, 9, 10, 11, 12, 12, 13, 14, 15, 16,
41 17, 18, 19, 19, 20, 21, 22, 23, 24, 25, 26, 26,
42 27, 28, 29, 30, 31, 32, 32, 33, 34, 35, 36, 37,
43 38, 38, 39, 40, 41, 42, 43, 43, 44, 45, 46, 47,
44 48, 48, 49, 50, 51, 52, 53, 53, 54, 55, 56, 57,
45 57, 58, 59, 60, 61, 62, 62, 63, 64, 65, 66, 66,
46 67, 68, 69, 70, 70, 71, 72, 73, 74, 74, 75, 76,
47 77, 78, 78, 79, 80, 81, 81, 82, 83, 84, 85, 85,
48 87, 88, 90, 92, 93, 95, 96, 98, 99, 101, 102, 104,
49 105, 107, 108, 110, 111, 113, 114, 116, 117, 118, 120, 121,
50 123, 125, 127, 129, 131, 134, 136, 138, 140, 142, 144, 146,
51 148, 150, 152, 154, 156, 158, 161, 164, 166, 169, 172, 174,
52 177, 180, 182, 185, 187, 190, 192, 195, 199, 202, 205, 208,
53 211, 214, 217, 220, 223, 226, 230, 233, 237, 240, 243, 247,
54 250, 253, 257, 261, 265, 269, 272, 276, 280, 284, 288, 292,
55 296, 300, 304, 309, 313, 317, 322, 326, 330, 335, 340, 344,
56 349, 354, 359, 364, 369, 374, 379, 384, 389, 395, 400, 406,
57 411, 417, 423, 429, 435, 441, 447, 454, 461, 467, 475, 482,
58 489, 497, 505, 513, 522, 530, 539, 549, 559, 569, 579, 590,
59 602, 614, 626, 640, 654, 668, 684, 700, 717, 736, 755, 775,
60 796, 819, 843, 869, 896, 925, 955, 988, 1022, 1058, 1098, 1139,
61 1184, 1232, 1282, 1336
62 },
63 #if LIBGAV1_MAX_BITDEPTH >= 10
64 // Lookup table for 10 bit.
65 {
66 4, 9, 10, 13, 15, 17, 20, 22, 25, 28, 31, 34,
67 37, 40, 43, 47, 50, 53, 57, 60, 64, 68, 71, 75,
68 78, 82, 86, 90, 93, 97, 101, 105, 109, 113, 116, 120,
69 124, 128, 132, 136, 140, 143, 147, 151, 155, 159, 163, 166,
70 170, 174, 178, 182, 185, 189, 193, 197, 200, 204, 208, 212,
71 215, 219, 223, 226, 230, 233, 237, 241, 244, 248, 251, 255,
72 259, 262, 266, 269, 273, 276, 280, 283, 287, 290, 293, 297,
73 300, 304, 307, 310, 314, 317, 321, 324, 327, 331, 334, 337,
74 343, 350, 356, 362, 369, 375, 381, 387, 394, 400, 406, 412,
75 418, 424, 430, 436, 442, 448, 454, 460, 466, 472, 478, 484,
76 490, 499, 507, 516, 525, 533, 542, 550, 559, 567, 576, 584,
77 592, 601, 609, 617, 625, 634, 644, 655, 666, 676, 687, 698,
78 708, 718, 729, 739, 749, 759, 770, 782, 795, 807, 819, 831,
79 844, 856, 868, 880, 891, 906, 920, 933, 947, 961, 975, 988,
80 1001, 1015, 1030, 1045, 1061, 1076, 1090, 1105, 1120, 1137, 1153, 1170,
81 1186, 1202, 1218, 1236, 1253, 1271, 1288, 1306, 1323, 1342, 1361, 1379,
82 1398, 1416, 1436, 1456, 1476, 1496, 1516, 1537, 1559, 1580, 1601, 1624,
83 1647, 1670, 1692, 1717, 1741, 1766, 1791, 1817, 1844, 1871, 1900, 1929,
84 1958, 1990, 2021, 2054, 2088, 2123, 2159, 2197, 2236, 2276, 2319, 2363,
85 2410, 2458, 2508, 2561, 2616, 2675, 2737, 2802, 2871, 2944, 3020, 3102,
86 3188, 3280, 3375, 3478, 3586, 3702, 3823, 3953, 4089, 4236, 4394, 4559,
87 4737, 4929, 5130, 5347
88 },
89 #endif // LIBGAV1_MAX_BITDEPTH >= 10
90 };
91
92 constexpr int16_t kAcLookup[][256] = {
93 // Lookup table for 8 bit.
94 {
95 4, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
96 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
97 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42,
98 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
99 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66,
100 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78,
101 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90,
102 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102,
103 104, 106, 108, 110, 112, 114, 116, 118, 120, 122, 124, 126,
104 128, 130, 132, 134, 136, 138, 140, 142, 144, 146, 148, 150,
105 152, 155, 158, 161, 164, 167, 170, 173, 176, 179, 182, 185,
106 188, 191, 194, 197, 200, 203, 207, 211, 215, 219, 223, 227,
107 231, 235, 239, 243, 247, 251, 255, 260, 265, 270, 275, 280,
108 285, 290, 295, 300, 305, 311, 317, 323, 329, 335, 341, 347,
109 353, 359, 366, 373, 380, 387, 394, 401, 408, 416, 424, 432,
110 440, 448, 456, 465, 474, 483, 492, 501, 510, 520, 530, 540,
111 550, 560, 571, 582, 593, 604, 615, 627, 639, 651, 663, 676,
112 689, 702, 715, 729, 743, 757, 771, 786, 801, 816, 832, 848,
113 864, 881, 898, 915, 933, 951, 969, 988, 1007, 1026, 1046, 1066,
114 1087, 1108, 1129, 1151, 1173, 1196, 1219, 1243, 1267, 1292, 1317, 1343,
115 1369, 1396, 1423, 1451, 1479, 1508, 1537, 1567, 1597, 1628, 1660, 1692,
116 1725, 1759, 1793, 1828
117 },
118 #if LIBGAV1_MAX_BITDEPTH >= 10
119 // Lookup table for 10 bit.
120 {
121 4, 9, 11, 13, 16, 18, 21, 24, 27, 30, 33, 37,
122 40, 44, 48, 51, 55, 59, 63, 67, 71, 75, 79, 83,
123 88, 92, 96, 100, 105, 109, 114, 118, 122, 127, 131, 136,
124 140, 145, 149, 154, 158, 163, 168, 172, 177, 181, 186, 190,
125 195, 199, 204, 208, 213, 217, 222, 226, 231, 235, 240, 244,
126 249, 253, 258, 262, 267, 271, 275, 280, 284, 289, 293, 297,
127 302, 306, 311, 315, 319, 324, 328, 332, 337, 341, 345, 349,
128 354, 358, 362, 367, 371, 375, 379, 384, 388, 392, 396, 401,
129 409, 417, 425, 433, 441, 449, 458, 466, 474, 482, 490, 498,
130 506, 514, 523, 531, 539, 547, 555, 563, 571, 579, 588, 596,
131 604, 616, 628, 640, 652, 664, 676, 688, 700, 713, 725, 737,
132 749, 761, 773, 785, 797, 809, 825, 841, 857, 873, 889, 905,
133 922, 938, 954, 970, 986, 1002, 1018, 1038, 1058, 1078, 1098, 1118,
134 1138, 1158, 1178, 1198, 1218, 1242, 1266, 1290, 1314, 1338, 1362, 1386,
135 1411, 1435, 1463, 1491, 1519, 1547, 1575, 1603, 1631, 1663, 1695, 1727,
136 1759, 1791, 1823, 1859, 1895, 1931, 1967, 2003, 2039, 2079, 2119, 2159,
137 2199, 2239, 2283, 2327, 2371, 2415, 2459, 2507, 2555, 2603, 2651, 2703,
138 2755, 2807, 2859, 2915, 2971, 3027, 3083, 3143, 3203, 3263, 3327, 3391,
139 3455, 3523, 3591, 3659, 3731, 3803, 3876, 3952, 4028, 4104, 4184, 4264,
140 4348, 4432, 4516, 4604, 4692, 4784, 4876, 4972, 5068, 5168, 5268, 5372,
141 5476, 5584, 5692, 5804, 5916, 6032, 6148, 6268, 6388, 6512, 6640, 6768,
142 6900, 7036, 7172, 7312
143 },
144 #endif // LIBGAV1_MAX_BITDEPTH >= 10
145 };
146 // clang-format on
147
Transpose(uint8_t * const dst,const uint8_t * const src,int src_width,int src_height)148 void Transpose(uint8_t* const dst, const uint8_t* const src, int src_width,
149 int src_height) {
150 const int dst_width = src_height;
151 const int dst_height = src_width;
152 Array2DView<const uint8_t> source(src_height, src_width, src);
153 Array2DView<uint8_t> dest(dst_height, dst_width, dst);
154 for (int y = 0; y < dst_height; ++y) {
155 for (int x = 0; x < dst_width; ++x) {
156 dest[y][x] = source[x][y];
157 }
158 }
159 }
160
161 // Copies the lower triangle and fills the upper triangle of |dst| using |src|
162 // as the source.
FillUpperTriangle(uint8_t * dst,const uint8_t * src,int size)163 void FillUpperTriangle(uint8_t* dst, const uint8_t* src, int size) {
164 Array2DView<uint8_t> dest(size, size, dst);
165 int k = 0;
166 for (int y = 0; y < size; ++y) {
167 for (int x = 0; x <= y; ++x) {
168 dest[y][x] = dest[x][y] = src[k++];
169 }
170 }
171 }
172
173 } // namespace
174
InitializeQuantizerMatrix(QuantizerMatrix * quantizer_matrix_ptr)175 bool InitializeQuantizerMatrix(QuantizerMatrix* quantizer_matrix_ptr) {
176 for (int level = 0; level < kNumQuantizerLevelsForQuantizerMatrix; ++level) {
177 for (int plane_type = kPlaneTypeY; plane_type < kNumPlaneTypes;
178 ++plane_type) {
179 auto& quantizer_matrix = (*quantizer_matrix_ptr)[level][plane_type];
180 // Notes about how these matrices are populated:
181 // * For square transforms, we store only the lower left triangle (it is
182 // symmetric about the main diagonal. So when populating the matrix, we
183 // will have to fill in the upper right triangle.
184 // * For rectangular transforms, the matrices are transposes when the
185 // width and height are reversed. So when populating we populate it with
186 // memcpy when w < h and populate it by transposing when w > h.
187 // * There is a special case for 16x16 where the matrix is the same as
188 // 32x32 with some offsets.
189 // * We use the "adjusted transform size" when using these matrices, so we
190 // won't have to populate them for transform sizes with one of the
191 // dimensions equal to 64.
192 for (int tx_size = 0; tx_size < kNumTransformSizes; ++tx_size) {
193 if (kTransformWidth[tx_size] == 64 || kTransformHeight[tx_size] == 64) {
194 continue;
195 }
196 const int size = kTransformWidth[tx_size] * kTransformHeight[tx_size];
197 if (!quantizer_matrix[tx_size].Resize(size)) {
198 return false;
199 }
200 }
201 #define QUANTIZER_MEMCPY(W, H) \
202 memcpy(quantizer_matrix[kTransformSize##W##x##H].get(), \
203 kQuantizerMatrix##W##x##H[level][plane_type], (W) * (H))
204 #define QUANTIZER_TRANSPOSE(W, H) \
205 Transpose(quantizer_matrix[kTransformSize##W##x##H].get(), \
206 kQuantizerMatrix##H##x##W[level][plane_type], H, W)
207 #define QUANTIZER_FILL_UPPER_TRIANGLE(SIZE) \
208 FillUpperTriangle(quantizer_matrix[kTransformSize##SIZE##x##SIZE].get(), \
209 kQuantizerMatrix##SIZE##x##SIZE[level][plane_type], SIZE)
210 QUANTIZER_FILL_UPPER_TRIANGLE(4); // 4x4
211 QUANTIZER_MEMCPY(4, 8); // 4x8
212 QUANTIZER_MEMCPY(4, 16); // 4x16
213 QUANTIZER_TRANSPOSE(8, 4); // 8x4
214 QUANTIZER_FILL_UPPER_TRIANGLE(8); // 8x8
215 QUANTIZER_MEMCPY(8, 16); // 8x16
216 QUANTIZER_MEMCPY(8, 32); // 8x32
217 QUANTIZER_TRANSPOSE(16, 4); // 16x4
218 QUANTIZER_TRANSPOSE(16, 8); // 16x8
219 QUANTIZER_MEMCPY(16, 32); // 16x32
220 QUANTIZER_TRANSPOSE(32, 8); // 32x8
221 QUANTIZER_TRANSPOSE(32, 16); // 32x16
222 QUANTIZER_FILL_UPPER_TRIANGLE(32); // 32x32
223 // 16x16.
224 Array2DView<uint8_t> dst16x16(
225 16, 16, quantizer_matrix[kTransformSize16x16].get());
226 Array2DView<const uint8_t> src32x32(
227 32, 32, quantizer_matrix[kTransformSize32x32].get());
228 for (int y = 0; y < 16; ++y) {
229 for (int x = 0; x < 16; ++x) {
230 dst16x16[y][x] = src32x32[MultiplyBy2(y)][MultiplyBy2(x)];
231 }
232 }
233 #undef QUANTIZER_FILL_UPPER_TRIANGLE
234 #undef QUANTIZER_TRANSPOSE
235 #undef QUANTIZER_MEMCPY
236 }
237 }
238 return true;
239 }
240
GetQIndex(const Segmentation & segmentation,int index,int base_qindex)241 int GetQIndex(const Segmentation& segmentation, int index, int base_qindex) {
242 if (segmentation.FeatureActive(index, kSegmentFeatureQuantizer)) {
243 const int segment_qindex =
244 base_qindex +
245 segmentation.feature_data[index][kSegmentFeatureQuantizer];
246 return Clip3(segment_qindex, kMinQuantizer, kMaxQuantizer);
247 }
248 return base_qindex;
249 }
250
Quantizer(int bitdepth,const QuantizerParameters * params)251 Quantizer::Quantizer(int bitdepth, const QuantizerParameters* params)
252 : params_(*params) {
253 assert(bitdepth >= 8 && bitdepth <= LIBGAV1_MAX_BITDEPTH);
254 const int index = BitdepthToArrayIndex(bitdepth);
255 dc_lookup_ = kDcLookup[index];
256 ac_lookup_ = kAcLookup[index];
257 }
258
GetDcValue(Plane plane,int qindex) const259 int Quantizer::GetDcValue(Plane plane, int qindex) const {
260 return dc_lookup_[Clip3(qindex + params_.delta_dc[plane], kMinQuantizer,
261 kMaxQuantizer)];
262 }
263
GetAcValue(Plane plane,int qindex) const264 int Quantizer::GetAcValue(Plane plane, int qindex) const {
265 return ac_lookup_[Clip3(qindex + params_.delta_ac[plane], kMinQuantizer,
266 kMaxQuantizer)];
267 }
268
269 } // namespace libgav1
270