FFmpeg coverage


Directory: ../../../ffmpeg/
File: src/libavcodec/texturedspenc.c
Date: 2024-04-19 07:31:02
Exec Total Coverage
Lines: 247 265 93.2%
Functions: 11 13 84.6%
Branches: 93 98 94.9%

Line Branch Exec Source
1 /*
2 * Texture block compression
3 * Copyright (C) 2015 Vittorio Giovara <vittorio.giovara@gmail.com>
4 * Based on public domain code by Fabian Giesen, Sean Barrett and Yann Collet.
5 *
6 * This file is part of FFmpeg
7 *
8 * Permission is hereby granted, free of charge, to any person obtaining a
9 * copy of this software and associated documentation files (the "Software"),
10 * to deal in the Software without restriction, including without limitation
11 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
12 * and/or sell copies of the Software, and to permit persons to whom the
13 * Software is furnished to do so, subject to the following conditions:
14 * The above copyright notice and this permission notice shall be included
15 * in all copies or substantial portions of the Software.
16 *
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
20 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
21 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
22 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
23 * IN THE SOFTWARE.
24 */
25
26 #include <stddef.h>
27 #include <stdint.h>
28
29 #include "libavutil/attributes.h"
30 #include "libavutil/common.h"
31 #include "libavutil/intreadwrite.h"
32
33 #include "texturedsp.h"
34
35 static const uint8_t expand5[32] = {
36 0, 8, 16, 24, 33, 41, 49, 57, 66, 74, 82, 90,
37 99, 107, 115, 123, 132, 140, 148, 156, 165, 173, 181, 189,
38 198, 206, 214, 222, 231, 239, 247, 255,
39 };
40
41 static const uint8_t expand6[64] = {
42 0, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 44,
43 48, 52, 56, 60, 65, 69, 73, 77, 81, 85, 89, 93,
44 97, 101, 105, 109, 113, 117, 121, 125, 130, 134, 138, 142,
45 146, 150, 154, 158, 162, 166, 170, 174, 178, 182, 186, 190,
46 195, 199, 203, 207, 211, 215, 219, 223, 227, 231, 235, 239,
47 243, 247, 251, 255,
48 };
49
50 static const uint8_t match5[256][2] = {
51 { 0, 0 }, { 0, 0 }, { 0, 1 }, { 0, 1 }, { 1, 0 }, { 1, 0 },
52 { 1, 0 }, { 1, 1 }, { 1, 1 }, { 2, 0 }, { 2, 0 }, { 0, 4 },
53 { 2, 1 }, { 2, 1 }, { 2, 1 }, { 3, 0 }, { 3, 0 }, { 3, 0 },
54 { 3, 1 }, { 1, 5 }, { 3, 2 }, { 3, 2 }, { 4, 0 }, { 4, 0 },
55 { 4, 1 }, { 4, 1 }, { 4, 2 }, { 4, 2 }, { 4, 2 }, { 3, 5 },
56 { 5, 1 }, { 5, 1 }, { 5, 2 }, { 4, 4 }, { 5, 3 }, { 5, 3 },
57 { 5, 3 }, { 6, 2 }, { 6, 2 }, { 6, 2 }, { 6, 3 }, { 5, 5 },
58 { 6, 4 }, { 6, 4 }, { 4, 8 }, { 7, 3 }, { 7, 3 }, { 7, 3 },
59 { 7, 4 }, { 7, 4 }, { 7, 4 }, { 7, 5 }, { 5, 9 }, { 7, 6 },
60 { 7, 6 }, { 8, 4 }, { 8, 4 }, { 8, 5 }, { 8, 5 }, { 8, 6 },
61 { 8, 6 }, { 8, 6 }, { 7, 9 }, { 9, 5 }, { 9, 5 }, { 9, 6 },
62 { 8, 8 }, { 9, 7 }, { 9, 7 }, { 9, 7 }, { 10, 6 }, { 10, 6 },
63 { 10, 6 }, { 10, 7 }, { 9, 9 }, { 10, 8 }, { 10, 8 }, { 8, 12 },
64 { 11, 7 }, { 11, 7 }, { 11, 7 }, { 11, 8 }, { 11, 8 }, { 11, 8 },
65 { 11, 9 }, { 9, 13 }, { 11, 10 }, { 11, 10 }, { 12, 8 }, { 12, 8 },
66 { 12, 9 }, { 12, 9 }, { 12, 10 }, { 12, 10 }, { 12, 10 }, { 11, 13 },
67 { 13, 9 }, { 13, 9 }, { 13, 10 }, { 12, 12 }, { 13, 11 }, { 13, 11 },
68 { 13, 11 }, { 14, 10 }, { 14, 10 }, { 14, 10 }, { 14, 11 }, { 13, 13 },
69 { 14, 12 }, { 14, 12 }, { 12, 16 }, { 15, 11 }, { 15, 11 }, { 15, 11 },
70 { 15, 12 }, { 15, 12 }, { 15, 12 }, { 15, 13 }, { 13, 17 }, { 15, 14 },
71 { 15, 14 }, { 16, 12 }, { 16, 12 }, { 16, 13 }, { 16, 13 }, { 16, 14 },
72 { 16, 14 }, { 16, 14 }, { 15, 17 }, { 17, 13 }, { 17, 13 }, { 17, 14 },
73 { 16, 16 }, { 17, 15 }, { 17, 15 }, { 17, 15 }, { 18, 14 }, { 18, 14 },
74 { 18, 14 }, { 18, 15 }, { 17, 17 }, { 18, 16 }, { 18, 16 }, { 16, 20 },
75 { 19, 15 }, { 19, 15 }, { 19, 15 }, { 19, 16 }, { 19, 16 }, { 19, 16 },
76 { 19, 17 }, { 17, 21 }, { 19, 18 }, { 19, 18 }, { 20, 16 }, { 20, 16 },
77 { 20, 17 }, { 20, 17 }, { 20, 18 }, { 20, 18 }, { 20, 18 }, { 19, 21 },
78 { 21, 17 }, { 21, 17 }, { 21, 18 }, { 20, 20 }, { 21, 19 }, { 21, 19 },
79 { 21, 19 }, { 22, 18 }, { 22, 18 }, { 22, 18 }, { 22, 19 }, { 21, 21 },
80 { 22, 20 }, { 22, 20 }, { 20, 24 }, { 23, 19 }, { 23, 19 }, { 23, 19 },
81 { 23, 20 }, { 23, 20 }, { 23, 20 }, { 23, 21 }, { 21, 25 }, { 23, 22 },
82 { 23, 22 }, { 24, 20 }, { 24, 20 }, { 24, 21 }, { 24, 21 }, { 24, 22 },
83 { 24, 22 }, { 24, 22 }, { 23, 25 }, { 25, 21 }, { 25, 21 }, { 25, 22 },
84 { 24, 24 }, { 25, 23 }, { 25, 23 }, { 25, 23 }, { 26, 22 }, { 26, 22 },
85 { 26, 22 }, { 26, 23 }, { 25, 25 }, { 26, 24 }, { 26, 24 }, { 24, 28 },
86 { 27, 23 }, { 27, 23 }, { 27, 23 }, { 27, 24 }, { 27, 24 }, { 27, 24 },
87 { 27, 25 }, { 25, 29 }, { 27, 26 }, { 27, 26 }, { 28, 24 }, { 28, 24 },
88 { 28, 25 }, { 28, 25 }, { 28, 26 }, { 28, 26 }, { 28, 26 }, { 27, 29 },
89 { 29, 25 }, { 29, 25 }, { 29, 26 }, { 28, 28 }, { 29, 27 }, { 29, 27 },
90 { 29, 27 }, { 30, 26 }, { 30, 26 }, { 30, 26 }, { 30, 27 }, { 29, 29 },
91 { 30, 28 }, { 30, 28 }, { 30, 28 }, { 31, 27 }, { 31, 27 }, { 31, 27 },
92 { 31, 28 }, { 31, 28 }, { 31, 28 }, { 31, 29 }, { 31, 29 }, { 31, 30 },
93 { 31, 30 }, { 31, 30 }, { 31, 31 }, { 31, 31 },
94 };
95
96 static const uint8_t match6[256][2] = {
97 { 0, 0 }, { 0, 1 }, { 1, 0 }, { 1, 0 }, { 1, 1 }, { 2, 0 },
98 { 2, 1 }, { 3, 0 }, { 3, 0 }, { 3, 1 }, { 4, 0 }, { 4, 0 },
99 { 4, 1 }, { 5, 0 }, { 5, 1 }, { 6, 0 }, { 6, 0 }, { 6, 1 },
100 { 7, 0 }, { 7, 0 }, { 7, 1 }, { 8, 0 }, { 8, 1 }, { 8, 1 },
101 { 8, 2 }, { 9, 1 }, { 9, 2 }, { 9, 2 }, { 9, 3 }, { 10, 2 },
102 { 10, 3 }, { 10, 3 }, { 10, 4 }, { 11, 3 }, { 11, 4 }, { 11, 4 },
103 { 11, 5 }, { 12, 4 }, { 12, 5 }, { 12, 5 }, { 12, 6 }, { 13, 5 },
104 { 13, 6 }, { 8, 16 }, { 13, 7 }, { 14, 6 }, { 14, 7 }, { 9, 17 },
105 { 14, 8 }, { 15, 7 }, { 15, 8 }, { 11, 16 }, { 15, 9 }, { 15, 10 },
106 { 16, 8 }, { 16, 9 }, { 16, 10 }, { 15, 13 }, { 17, 9 }, { 17, 10 },
107 { 17, 11 }, { 15, 16 }, { 18, 10 }, { 18, 11 }, { 18, 12 }, { 16, 16 },
108 { 19, 11 }, { 19, 12 }, { 19, 13 }, { 17, 17 }, { 20, 12 }, { 20, 13 },
109 { 20, 14 }, { 19, 16 }, { 21, 13 }, { 21, 14 }, { 21, 15 }, { 20, 17 },
110 { 22, 14 }, { 22, 15 }, { 25, 10 }, { 22, 16 }, { 23, 15 }, { 23, 16 },
111 { 26, 11 }, { 23, 17 }, { 24, 16 }, { 24, 17 }, { 27, 12 }, { 24, 18 },
112 { 25, 17 }, { 25, 18 }, { 28, 13 }, { 25, 19 }, { 26, 18 }, { 26, 19 },
113 { 29, 14 }, { 26, 20 }, { 27, 19 }, { 27, 20 }, { 30, 15 }, { 27, 21 },
114 { 28, 20 }, { 28, 21 }, { 28, 21 }, { 28, 22 }, { 29, 21 }, { 29, 22 },
115 { 24, 32 }, { 29, 23 }, { 30, 22 }, { 30, 23 }, { 25, 33 }, { 30, 24 },
116 { 31, 23 }, { 31, 24 }, { 27, 32 }, { 31, 25 }, { 31, 26 }, { 32, 24 },
117 { 32, 25 }, { 32, 26 }, { 31, 29 }, { 33, 25 }, { 33, 26 }, { 33, 27 },
118 { 31, 32 }, { 34, 26 }, { 34, 27 }, { 34, 28 }, { 32, 32 }, { 35, 27 },
119 { 35, 28 }, { 35, 29 }, { 33, 33 }, { 36, 28 }, { 36, 29 }, { 36, 30 },
120 { 35, 32 }, { 37, 29 }, { 37, 30 }, { 37, 31 }, { 36, 33 }, { 38, 30 },
121 { 38, 31 }, { 41, 26 }, { 38, 32 }, { 39, 31 }, { 39, 32 }, { 42, 27 },
122 { 39, 33 }, { 40, 32 }, { 40, 33 }, { 43, 28 }, { 40, 34 }, { 41, 33 },
123 { 41, 34 }, { 44, 29 }, { 41, 35 }, { 42, 34 }, { 42, 35 }, { 45, 30 },
124 { 42, 36 }, { 43, 35 }, { 43, 36 }, { 46, 31 }, { 43, 37 }, { 44, 36 },
125 { 44, 37 }, { 44, 37 }, { 44, 38 }, { 45, 37 }, { 45, 38 }, { 40, 48 },
126 { 45, 39 }, { 46, 38 }, { 46, 39 }, { 41, 49 }, { 46, 40 }, { 47, 39 },
127 { 47, 40 }, { 43, 48 }, { 47, 41 }, { 47, 42 }, { 48, 40 }, { 48, 41 },
128 { 48, 42 }, { 47, 45 }, { 49, 41 }, { 49, 42 }, { 49, 43 }, { 47, 48 },
129 { 50, 42 }, { 50, 43 }, { 50, 44 }, { 48, 48 }, { 51, 43 }, { 51, 44 },
130 { 51, 45 }, { 49, 49 }, { 52, 44 }, { 52, 45 }, { 52, 46 }, { 51, 48 },
131 { 53, 45 }, { 53, 46 }, { 53, 47 }, { 52, 49 }, { 54, 46 }, { 54, 47 },
132 { 57, 42 }, { 54, 48 }, { 55, 47 }, { 55, 48 }, { 58, 43 }, { 55, 49 },
133 { 56, 48 }, { 56, 49 }, { 59, 44 }, { 56, 50 }, { 57, 49 }, { 57, 50 },
134 { 60, 45 }, { 57, 51 }, { 58, 50 }, { 58, 51 }, { 61, 46 }, { 58, 52 },
135 { 59, 51 }, { 59, 52 }, { 62, 47 }, { 59, 53 }, { 60, 52 }, { 60, 53 },
136 { 60, 53 }, { 60, 54 }, { 61, 53 }, { 61, 54 }, { 61, 54 }, { 61, 55 },
137 { 62, 54 }, { 62, 55 }, { 62, 55 }, { 62, 56 }, { 63, 55 }, { 63, 56 },
138 { 63, 56 }, { 63, 57 }, { 63, 58 }, { 63, 59 }, { 63, 59 }, { 63, 60 },
139 { 63, 61 }, { 63, 62 }, { 63, 62 }, { 63, 63 },
140 };
141
142 /* Multiplication over 8 bit emulation */
143 #define mul8(a, b) (((a) * (b) + 128 + (((a) * (b) + 128) >> 8)) >> 8)
144
145 /* Conversion from rgb24 to rgb565 */
146 #define rgb2rgb565(r, g, b) \
147 ((mul8(r, 31) << 11) | (mul8(g, 63) << 5) | (mul8(b, 31) << 0))
148
149 /* Linear interpolation at 1/3 point between a and b */
150 #define lerp13(a, b) ((2 * (a) + (b)) / 3)
151
152 /* Linear interpolation on an RGB pixel */
153 31238 static inline void lerp13rgb(uint8_t *out, uint8_t *p1, uint8_t *p2)
154 {
155 31238 out[0] = lerp13(p1[0], p2[0]);
156 31238 out[1] = lerp13(p1[1], p2[1]);
157 31238 out[2] = lerp13(p1[2], p2[2]);
158 31238 }
159
160 /* Conversion from rgb565 to rgb24 */
161 31238 static inline void rgb5652rgb(uint8_t *out, uint16_t v)
162 {
163 31238 int rv = (v & 0xf800) >> 11;
164 31238 int gv = (v & 0x07e0) >> 5;
165 31238 int bv = (v & 0x001f) >> 0;
166
167 31238 out[0] = expand5[rv];
168 31238 out[1] = expand6[gv];
169 31238 out[2] = expand5[bv];
170 31238 out[3] = 0;
171 31238 }
172
173 /* Color matching function */
174 15619 static unsigned int match_colors(const uint8_t *block, ptrdiff_t stride,
175 uint16_t c0, uint16_t c1)
176 {
177 15619 uint32_t mask = 0;
178 int dirr, dirg, dirb;
179 int dots[16];
180 int stops[4];
181 15619 int x, y, k = 0;
182 int c0_point, half_point, c3_point;
183 uint8_t color[16];
184 static const uint32_t indexMap[8] = {
185 0U << 30, 2U << 30, 0U << 30, 2U << 30,
186 3U << 30, 3U << 30, 1U << 30, 1U << 30,
187 };
188
189 /* Fill color and compute direction for each component */
190 15619 rgb5652rgb(color + 0, c0);
191 15619 rgb5652rgb(color + 4, c1);
192 15619 lerp13rgb(color + 8, color + 0, color + 4);
193 15619 lerp13rgb(color + 12, color + 4, color + 0);
194
195 15619 dirr = color[0 * 4 + 0] - color[1 * 4 + 0];
196 15619 dirg = color[0 * 4 + 1] - color[1 * 4 + 1];
197 15619 dirb = color[0 * 4 + 2] - color[1 * 4 + 2];
198
199
2/2
✓ Branch 0 taken 62476 times.
✓ Branch 1 taken 15619 times.
78095 for (y = 0; y < 4; y++) {
200
2/2
✓ Branch 0 taken 249904 times.
✓ Branch 1 taken 62476 times.
312380 for (x = 0; x < 4; x++)
201 249904 dots[k++] = block[0 + x * 4 + y * stride] * dirr +
202 249904 block[1 + x * 4 + y * stride] * dirg +
203 249904 block[2 + x * 4 + y * stride] * dirb;
204
205 62476 stops[y] = color[0 + y * 4] * dirr +
206 62476 color[1 + y * 4] * dirg +
207 62476 color[2 + y * 4] * dirb;
208 }
209
210 /* Think of the colors as arranged on a line; project point onto that line,
211 * then choose next color out of available ones. we compute the crossover
212 * points for 'best color in top half'/'best in bottom half' and then
213 * the same inside that subinterval.
214 *
215 * Relying on this 1d approximation isn't always optimal in terms of
216 * Euclidean distance, but it's very close and a lot faster.
217 *
218 * http://cbloomrants.blogspot.com/2008/12/12-08-08-dxtc-summary.html */
219 15619 c0_point = (stops[1] + stops[3]) >> 1;
220 15619 half_point = (stops[3] + stops[2]) >> 1;
221 15619 c3_point = (stops[2] + stops[0]) >> 1;
222
223
2/2
✓ Branch 0 taken 249904 times.
✓ Branch 1 taken 15619 times.
265523 for (x = 0; x < 16; x++) {
224 249904 int dot = dots[x];
225
2/2
✓ Branch 0 taken 107753 times.
✓ Branch 1 taken 142151 times.
249904 int bits = (dot < half_point ? 4 : 0) |
226
2/2
✓ Branch 0 taken 55495 times.
✓ Branch 1 taken 194409 times.
249904 (dot < c0_point ? 2 : 0) |
227 249904 (dot < c3_point ? 1 : 0);
228
229 249904 mask >>= 2;
230 249904 mask |= indexMap[bits];
231 }
232
233 15619 return mask;
234 }
235
236 /* Color optimization function */
237 9388 static void optimize_colors(const uint8_t *block, ptrdiff_t stride,
238 uint16_t *pmax16, uint16_t *pmin16)
239 {
240 const uint8_t *minp;
241 const uint8_t *maxp;
242 9388 const int iter_power = 4;
243 double magn;
244 int v_r, v_g, v_b;
245 float covf[6], vfr, vfg, vfb;
246 int mind, maxd;
247 9388 int cov[6] = { 0 };
248 int mu[3], min[3], max[3];
249 int ch, iter, x, y;
250
251 /* Determine color distribution */
252
2/2
✓ Branch 0 taken 28164 times.
✓ Branch 1 taken 9388 times.
37552 for (ch = 0; ch < 3; ch++) {
253 28164 const uint8_t *bp = &block[ch];
254 int muv, minv, maxv;
255
256 28164 muv = minv = maxv = bp[0];
257
2/2
✓ Branch 0 taken 112656 times.
✓ Branch 1 taken 28164 times.
140820 for (y = 0; y < 4; y++) {
258
2/2
✓ Branch 0 taken 450624 times.
✓ Branch 1 taken 112656 times.
563280 for (x = 0; x < 4; x++) {
259 450624 muv += bp[x * 4 + y * stride];
260
2/2
✓ Branch 0 taken 42225 times.
✓ Branch 1 taken 408399 times.
450624 if (bp[x * 4 + y * stride] < minv)
261 42225 minv = bp[x * 4 + y * stride];
262
2/2
✓ Branch 0 taken 44075 times.
✓ Branch 1 taken 364324 times.
408399 else if (bp[x * 4 + y * stride] > maxv)
263 44075 maxv = bp[x * 4 + y * stride];
264 }
265 }
266
267 28164 mu[ch] = (muv + 8) >> 4;
268 28164 min[ch] = minv;
269 28164 max[ch] = maxv;
270 }
271
272 /* Determine covariance matrix */
273
2/2
✓ Branch 0 taken 37552 times.
✓ Branch 1 taken 9388 times.
46940 for (y = 0; y < 4; y++) {
274
2/2
✓ Branch 0 taken 150208 times.
✓ Branch 1 taken 37552 times.
187760 for (x = 0; x < 4; x++) {
275 150208 int r = block[x * 4 + stride * y + 0] - mu[0];
276 150208 int g = block[x * 4 + stride * y + 1] - mu[1];
277 150208 int b = block[x * 4 + stride * y + 2] - mu[2];
278
279 150208 cov[0] += r * r;
280 150208 cov[1] += r * g;
281 150208 cov[2] += r * b;
282 150208 cov[3] += g * g;
283 150208 cov[4] += g * b;
284 150208 cov[5] += b * b;
285 }
286 }
287
288 /* Convert covariance matrix to float, find principal axis via power iter */
289
2/2
✓ Branch 0 taken 56328 times.
✓ Branch 1 taken 9388 times.
65716 for (x = 0; x < 6; x++)
290 56328 covf[x] = cov[x] / 255.0f;
291
292 9388 vfr = (float) (max[0] - min[0]);
293 9388 vfg = (float) (max[1] - min[1]);
294 9388 vfb = (float) (max[2] - min[2]);
295
296
2/2
✓ Branch 0 taken 37552 times.
✓ Branch 1 taken 9388 times.
46940 for (iter = 0; iter < iter_power; iter++) {
297 37552 float r = vfr * covf[0] + vfg * covf[1] + vfb * covf[2];
298 37552 float g = vfr * covf[1] + vfg * covf[3] + vfb * covf[4];
299 37552 float b = vfr * covf[2] + vfg * covf[4] + vfb * covf[5];
300
301 37552 vfr = r;
302 37552 vfg = g;
303 37552 vfb = b;
304 }
305
306 9388 magn = fabs(vfr);
307
2/2
✓ Branch 0 taken 4285 times.
✓ Branch 1 taken 5103 times.
9388 if (fabs(vfg) > magn)
308 4285 magn = fabs(vfg);
309
2/2
✓ Branch 0 taken 1404 times.
✓ Branch 1 taken 7984 times.
9388 if (fabs(vfb) > magn)
310 1404 magn = fabs(vfb);
311
312 /* if magnitude is too small, default to luminance */
313
2/2
✓ Branch 0 taken 53 times.
✓ Branch 1 taken 9335 times.
9388 if (magn < 4.0f) {
314 /* JPEG YCbCr luma coefs, scaled by 1000 */
315 53 v_r = 299;
316 53 v_g = 587;
317 53 v_b = 114;
318 } else {
319 9335 magn = 512.0 / magn;
320 9335 v_r = (int) (vfr * magn);
321 9335 v_g = (int) (vfg * magn);
322 9335 v_b = (int) (vfb * magn);
323 }
324
325 /* Pick colors at extreme points */
326 9388 mind = maxd = block[0] * v_r + block[1] * v_g + block[2] * v_b;
327 9388 minp = maxp = block;
328
2/2
✓ Branch 0 taken 37552 times.
✓ Branch 1 taken 9388 times.
46940 for (y = 0; y < 4; y++) {
329
2/2
✓ Branch 0 taken 150208 times.
✓ Branch 1 taken 37552 times.
187760 for (x = 0; x < 4; x++) {
330 150208 int dot = block[x * 4 + y * stride + 0] * v_r +
331 150208 block[x * 4 + y * stride + 1] * v_g +
332 150208 block[x * 4 + y * stride + 2] * v_b;
333
334
2/2
✓ Branch 0 taken 18681 times.
✓ Branch 1 taken 131527 times.
150208 if (dot < mind) {
335 18681 mind = dot;
336 18681 minp = block + x * 4 + y * stride;
337
2/2
✓ Branch 0 taken 18460 times.
✓ Branch 1 taken 113067 times.
131527 } else if (dot > maxd) {
338 18460 maxd = dot;
339 18460 maxp = block + x * 4 + y * stride;
340 }
341 }
342 }
343
344 9388 *pmax16 = rgb2rgb565(maxp[0], maxp[1], maxp[2]);
345 9388 *pmin16 = rgb2rgb565(minp[0], minp[1], minp[2]);
346 9388 }
347
348 /* Try to optimize colors to suit block contents better, by solving
349 * a least squares system via normal equations + Cramer's rule. */
350 9388 static int refine_colors(const uint8_t *block, ptrdiff_t stride,
351 uint16_t *pmax16, uint16_t *pmin16, uint32_t mask)
352 {
353 9388 uint32_t cm = mask;
354 9388 uint16_t oldMin = *pmin16;
355 9388 uint16_t oldMax = *pmax16;
356 uint16_t min16, max16;
357 int x, y;
358
359 /* Additional magic to save a lot of multiplies in the accumulating loop.
360 * The tables contain precomputed products of weights for least squares
361 * system, accumulated inside one 32-bit register */
362 static const int w1tab[4] = { 3, 0, 2, 1 };
363 static const int prods[4] = { 0x090000, 0x000900, 0x040102, 0x010402 };
364
365 /* Check if all pixels have the same index */
366
2/2
✓ Branch 0 taken 951 times.
✓ Branch 1 taken 8437 times.
9388 if ((mask ^ (mask << 2)) < 4) {
367 /* If so, linear system would be singular; solve using optimal
368 * single-color match on average color. */
369 951 int r = 8, g = 8, b = 8;
370
2/2
✓ Branch 0 taken 3804 times.
✓ Branch 1 taken 951 times.
4755 for (y = 0; y < 4; y++) {
371
2/2
✓ Branch 0 taken 15216 times.
✓ Branch 1 taken 3804 times.
19020 for (x = 0; x < 4; x++) {
372 15216 r += block[0 + x * 4 + y * stride];
373 15216 g += block[1 + x * 4 + y * stride];
374 15216 b += block[2 + x * 4 + y * stride];
375 }
376 }
377
378 951 r >>= 4;
379 951 g >>= 4;
380 951 b >>= 4;
381
382 951 max16 = (match5[r][0] << 11) | (match6[g][0] << 5) | match5[b][0];
383 951 min16 = (match5[r][1] << 11) | (match6[g][1] << 5) | match5[b][1];
384 } else {
385 float fr, fg, fb;
386 8437 int at1_r = 0, at1_g = 0, at1_b = 0;
387 8437 int at2_r = 0, at2_g = 0, at2_b = 0;
388 8437 int akku = 0;
389 int xx, xy, yy;
390
391
2/2
✓ Branch 0 taken 33748 times.
✓ Branch 1 taken 8437 times.
42185 for (y = 0; y < 4; y++) {
392
2/2
✓ Branch 0 taken 134992 times.
✓ Branch 1 taken 33748 times.
168740 for (x = 0; x < 4; x++) {
393 134992 int step = cm & 3;
394 134992 int w1 = w1tab[step];
395 134992 int r = block[0 + x * 4 + y * stride];
396 134992 int g = block[1 + x * 4 + y * stride];
397 134992 int b = block[2 + x * 4 + y * stride];
398
399 134992 akku += prods[step];
400 134992 at1_r += w1 * r;
401 134992 at1_g += w1 * g;
402 134992 at1_b += w1 * b;
403 134992 at2_r += r;
404 134992 at2_g += g;
405 134992 at2_b += b;
406
407 134992 cm >>= 2;
408 }
409 }
410
411 8437 at2_r = 3 * at2_r - at1_r;
412 8437 at2_g = 3 * at2_g - at1_g;
413 8437 at2_b = 3 * at2_b - at1_b;
414
415 /* Extract solutions and decide solvability */
416 8437 xx = akku >> 16;
417 8437 yy = (akku >> 8) & 0xFF;
418 8437 xy = (akku >> 0) & 0xFF;
419
420 8437 fr = 3.0f * 31.0f / 255.0f / (xx * yy - xy * xy);
421 8437 fg = fr * 63.0f / 31.0f;
422 8437 fb = fr;
423
424 /* Solve */
425 8437 max16 = av_clip_uintp2((at1_r * yy - at2_r * xy) * fr + 0.5f, 5) << 11;
426 8437 max16 |= av_clip_uintp2((at1_g * yy - at2_g * xy) * fg + 0.5f, 6) << 5;
427 8437 max16 |= av_clip_uintp2((at1_b * yy - at2_b * xy) * fb + 0.5f, 5) << 0;
428
429 8437 min16 = av_clip_uintp2((at2_r * xx - at1_r * xy) * fr + 0.5f, 5) << 11;
430 8437 min16 |= av_clip_uintp2((at2_g * xx - at1_g * xy) * fg + 0.5f, 6) << 5;
431 8437 min16 |= av_clip_uintp2((at2_b * xx - at1_b * xy) * fb + 0.5f, 5) << 0;
432 }
433
434 9388 *pmin16 = min16;
435 9388 *pmax16 = max16;
436
4/4
✓ Branch 0 taken 3040 times.
✓ Branch 1 taken 6348 times.
✓ Branch 2 taken 822 times.
✓ Branch 3 taken 2218 times.
9388 return oldMin != min16 || oldMax != max16;
437 }
438
439 /* Check if input block is a constant color */
440 131648 static int constant_color(const uint8_t *block, ptrdiff_t stride)
441 {
442 int x, y;
443 131648 uint32_t first = AV_RL32(block);
444
445
2/2
✓ Branch 0 taken 502236 times.
✓ Branch 1 taken 122260 times.
624496 for (y = 0; y < 4; y++)
446
2/2
✓ Branch 0 taken 1989406 times.
✓ Branch 1 taken 492848 times.
2482254 for (x = 0; x < 4; x++)
447
2/2
✓ Branch 0 taken 9388 times.
✓ Branch 1 taken 1980018 times.
1989406 if (first != AV_RL32(block + x * 4 + y * stride))
448 9388 return 0;
449 122260 return 1;
450 }
451
452 /* Main color compression function */
453 131648 static void compress_color(uint8_t *dst, ptrdiff_t stride, const uint8_t *block)
454 {
455 uint32_t mask;
456 uint16_t max16, min16;
457 131648 int constant = constant_color(block, stride);
458
459 /* Constant color will load values from tables */
460
2/2
✓ Branch 0 taken 122260 times.
✓ Branch 1 taken 9388 times.
131648 if (constant) {
461 122260 int r = block[0];
462 122260 int g = block[1];
463 122260 int b = block[2];
464 122260 mask = 0xAAAAAAAA;
465 122260 max16 = (match5[r][0] << 11) | (match6[g][0] << 5) | match5[b][0];
466 122260 min16 = (match5[r][1] << 11) | (match6[g][1] << 5) | match5[b][1];
467 } else {
468 int refine;
469
470 /* Otherwise find pca and map along principal axis */
471 9388 optimize_colors(block, stride, &max16, &min16);
472
2/2
✓ Branch 0 taken 8449 times.
✓ Branch 1 taken 939 times.
9388 if (max16 != min16)
473 8449 mask = match_colors(block, stride, max16, min16);
474 else
475 939 mask = 0;
476
477 /* One pass refinement */
478 9388 refine = refine_colors(block, stride, &max16, &min16, mask);
479
2/2
✓ Branch 0 taken 7170 times.
✓ Branch 1 taken 2218 times.
9388 if (refine) {
480
1/2
✓ Branch 0 taken 7170 times.
✗ Branch 1 not taken.
7170 if (max16 != min16)
481 7170 mask = match_colors(block, stride, max16, min16);
482 else
483 mask = 0;
484 }
485 }
486
487 /* Finally write the color block */
488
2/2
✓ Branch 0 taken 222 times.
✓ Branch 1 taken 131426 times.
131648 if (max16 < min16) {
489 222 FFSWAP(uint16_t, min16, max16);
490 222 mask ^= 0x55555555;
491 }
492
493 131648 AV_WL16(dst + 0, max16);
494 131648 AV_WL16(dst + 2, min16);
495 131648 AV_WL32(dst + 4, mask);
496 131648 }
497
498 /* Alpha compression function */
499 1024 static void compress_alpha(uint8_t *dst, ptrdiff_t stride, const uint8_t *block)
500 {
501 int x, y;
502 int dist, bias, dist4, dist2;
503 int mn, mx;
504 1024 int bits = 0;
505 1024 int mask = 0;
506
507 1024 memset(dst, 0, 8);
508
509 /* Find min/max color */
510 1024 mn = mx = block[3];
511
2/2
✓ Branch 0 taken 4096 times.
✓ Branch 1 taken 1024 times.
5120 for (y = 0; y < 4; y++) {
512
2/2
✓ Branch 0 taken 16384 times.
✓ Branch 1 taken 4096 times.
20480 for (x = 0; x < 4; x++) {
513 16384 int val = block[3 + x * 4 + y * stride];
514
2/2
✓ Branch 0 taken 265 times.
✓ Branch 1 taken 16119 times.
16384 if (val < mn)
515 265 mn = val;
516
2/2
✓ Branch 0 taken 3328 times.
✓ Branch 1 taken 12791 times.
16119 else if (val > mx)
517 3328 mx = val;
518 }
519 }
520
521 /* Encode them */
522 1024 dst[0] = (uint8_t) mx;
523 1024 dst[1] = (uint8_t) mn;
524 1024 dst += 2;
525
526 /* Mono-alpha shortcut */
527
2/2
✓ Branch 0 taken 8 times.
✓ Branch 1 taken 1016 times.
1024 if (mn == mx)
528 8 return;
529
530 /* Determine bias and emit color indices.
531 * Given the choice of mx/mn, these indices are optimal:
532 * fgiesen.wordpress.com/2009/12/15/dxt5-alpha-block-index-determination */
533 1016 dist = mx - mn;
534
535 1016 dist4 = dist * 4;
536 1016 dist2 = dist * 2;
537
2/2
✓ Branch 0 taken 1015 times.
✓ Branch 1 taken 1 times.
1016 if (dist < 8)
538 1015 bias = dist - 1 - mn * 7;
539 else
540 1 bias = dist / 2 + 2 - mn * 7;
541
542
2/2
✓ Branch 0 taken 4064 times.
✓ Branch 1 taken 1016 times.
5080 for (y = 0; y < 4; y++) {
543
2/2
✓ Branch 0 taken 16256 times.
✓ Branch 1 taken 4064 times.
20320 for (x = 0; x < 4; x++) {
544 16256 int alp = block[3 + x * 4 + y * stride] * 7 + bias;
545 int ind, tmp;
546
547 /* This is a "linear scale" lerp factor between 0 (val=min)
548 * and 7 (val=max) to select index. */
549
2/2
✓ Branch 0 taken 8286 times.
✓ Branch 1 taken 7970 times.
16256 tmp = (alp >= dist4) ? -1 : 0;
550 16256 ind = tmp & 4;
551 16256 alp -= dist4 & tmp;
552
2/2
✓ Branch 0 taken 8315 times.
✓ Branch 1 taken 7941 times.
16256 tmp = (alp >= dist2) ? -1 : 0;
553 16256 ind += tmp & 2;
554 16256 alp -= dist2 & tmp;
555 16256 ind += (alp >= dist);
556
557 /* Turn linear scale into DXT index (0/1 are extreme points) */
558 16256 ind = -ind & 7;
559 16256 ind ^= (2 > ind);
560
561 /* Write index */
562 16256 mask |= ind << bits;
563 16256 bits += 3;
564
2/2
✓ Branch 0 taken 6096 times.
✓ Branch 1 taken 10160 times.
16256 if (bits >= 8) {
565 6096 *dst++ = mask;
566 6096 mask >>= 8;
567 6096 bits -= 8;
568 }
569 }
570 }
571 }
572
573 /**
574 * Convert a RGBA buffer to unscaled YCoCg.
575 * Scale is usually introduced to avoid banding over a certain range of colors,
576 * but this version of the algorithm does not introduce it as much as other
577 * implementations, allowing for a simpler and faster conversion.
578 */
579 static void rgba2ycocg(uint8_t *dst, const uint8_t *pixel)
580 {
581 int r = pixel[0];
582 int g = (pixel[1] + 1) >> 1;
583 int b = pixel[2];
584 int t = (2 + r + b) >> 2;
585
586 dst[0] = av_clip_uint8(128 + ((r - b + 1) >> 1)); /* Co */
587 dst[1] = av_clip_uint8(128 + g - t); /* Cg */
588 dst[2] = 0;
589 dst[3] = av_clip_uint8(g + t); /* Y */
590 }
591
592 /**
593 * Compress one block of RGBA pixels in a DXT1 texture and store the
594 * resulting bytes in 'dst'. Alpha is not preserved.
595 *
596 * @param dst output buffer.
597 * @param stride scanline in bytes.
598 * @param block block to compress.
599 * @return how much texture data has been written.
600 */
601 130624 static int dxt1_block(uint8_t *dst, ptrdiff_t stride, const uint8_t *block)
602 {
603 130624 compress_color(dst, stride, block);
604
605 130624 return 8;
606 }
607
608 /**
609 * Compress one block of RGBA pixels in a DXT5 texture and store the
610 * resulting bytes in 'dst'. Alpha is preserved.
611 *
612 * @param dst output buffer.
613 * @param stride scanline in bytes.
614 * @param block block to compress.
615 * @return how much texture data has been written.
616 */
617 1024 static int dxt5_block(uint8_t *dst, ptrdiff_t stride, const uint8_t *block)
618 {
619 1024 compress_alpha(dst, stride, block);
620 1024 compress_color(dst + 8, stride, block);
621
622 1024 return 16;
623 }
624
625 /**
626 * Compress one block of RGBA pixels in a DXT5-YCoCg texture and store the
627 * resulting bytes in 'dst'. Alpha is not preserved.
628 *
629 * @param dst output buffer.
630 * @param stride scanline in bytes.
631 * @param block block to compress.
632 * @return how much texture data has been written.
633 */
634 static int dxt5ys_block(uint8_t *dst, ptrdiff_t stride, const uint8_t *block)
635 {
636 int x, y;
637 uint8_t reorder[64];
638
639 /* Reorder the components and then run a normal DXT5 compression. */
640 for (y = 0; y < 4; y++)
641 for (x = 0; x < 4; x++)
642 rgba2ycocg(reorder + x * 4 + y * 16, block + x * 4 + y * stride);
643
644 compress_alpha(dst + 0, 16, reorder);
645 compress_color(dst + 8, 16, reorder);
646
647 return 16;
648 }
649
650 13 av_cold void ff_texturedspenc_init(TextureDSPEncContext *c)
651 {
652 13 c->dxt1_block = dxt1_block;
653 13 c->dxt5_block = dxt5_block;
654 13 c->dxt5ys_block = dxt5ys_block;
655 13 }
656
657 #define TEXTUREDSP_FUNC_NAME ff_texturedsp_exec_compress_threads
658 #define TEXTUREDSP_TEX_FUNC(a, b, c) tex_funct(c, b, a)
659 #include "texturedsp_template.c"
660