Line | Branch | Exec | Source |
---|---|---|---|
1 | /* | ||
2 | * Copyright (C) 2024 Niklas Haas | ||
3 | * Copyright (C) 2001-2003 Michael Niedermayer <michaelni@gmx.at> | ||
4 | * | ||
5 | * This file is part of FFmpeg. | ||
6 | * | ||
7 | * FFmpeg is free software; you can redistribute it and/or | ||
8 | * modify it under the terms of the GNU Lesser General Public | ||
9 | * License as published by the Free Software Foundation; either | ||
10 | * version 2.1 of the License, or (at your option) any later version. | ||
11 | * | ||
12 | * FFmpeg is distributed in the hope that it will be useful, | ||
13 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
14 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
15 | * Lesser General Public License for more details. | ||
16 | * | ||
17 | * You should have received a copy of the GNU Lesser General Public | ||
18 | * License along with FFmpeg; if not, write to the Free Software | ||
19 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA | ||
20 | */ | ||
21 | |||
22 | #include "config.h" | ||
23 | |||
24 | #define _DEFAULT_SOURCE | ||
25 | #define _SVID_SOURCE // needed for MAP_ANONYMOUS | ||
26 | #define _DARWIN_C_SOURCE // needed for MAP_ANON | ||
27 | #include <inttypes.h> | ||
28 | #include <math.h> | ||
29 | #include <stdio.h> | ||
30 | #include <string.h> | ||
31 | #if HAVE_MMAP | ||
32 | #include <sys/mman.h> | ||
33 | #if defined(MAP_ANON) && !defined(MAP_ANONYMOUS) | ||
34 | #define MAP_ANONYMOUS MAP_ANON | ||
35 | #endif | ||
36 | #endif | ||
37 | #if HAVE_VIRTUALALLOC | ||
38 | #include <windows.h> | ||
39 | #endif | ||
40 | |||
41 | #include "libavutil/attributes.h" | ||
42 | #include "libavutil/avassert.h" | ||
43 | #include "libavutil/cpu.h" | ||
44 | #include "libavutil/csp.h" | ||
45 | #include "libavutil/emms.h" | ||
46 | #include "libavutil/imgutils.h" | ||
47 | #include "libavutil/intreadwrite.h" | ||
48 | #include "libavutil/libm.h" | ||
49 | #include "libavutil/mathematics.h" | ||
50 | #include "libavutil/mem.h" | ||
51 | #include "libavutil/opt.h" | ||
52 | #include "libavutil/pixdesc.h" | ||
53 | #include "libavutil/slicethread.h" | ||
54 | #include "libavutil/thread.h" | ||
55 | #include "libavutil/aarch64/cpu.h" | ||
56 | #include "libavutil/ppc/cpu.h" | ||
57 | #include "libavutil/x86/asm.h" | ||
58 | #include "libavutil/x86/cpu.h" | ||
59 | #include "libavutil/loongarch/cpu.h" | ||
60 | |||
61 | #include "rgb2rgb.h" | ||
62 | #include "swscale.h" | ||
63 | #include "swscale_internal.h" | ||
64 | #include "graph.h" | ||
65 | |||
66 | /** | ||
67 | * Allocate and return an SwsContext without performing initialization. | ||
68 | */ | ||
69 | 3145 | static SwsContext *alloc_set_opts(int srcW, int srcH, enum AVPixelFormat srcFormat, | |
70 | int dstW, int dstH, enum AVPixelFormat dstFormat, | ||
71 | int flags, const double *param) | ||
72 | { | ||
73 | 3145 | SwsContext *sws = sws_alloc_context(); | |
74 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 3145 times.
|
3145 | if (!sws) |
75 | ✗ | return NULL; | |
76 | |||
77 | 3145 | sws->flags = flags; | |
78 | 3145 | sws->src_w = srcW; | |
79 | 3145 | sws->src_h = srcH; | |
80 | 3145 | sws->dst_w = dstW; | |
81 | 3145 | sws->dst_h = dstH; | |
82 | 3145 | sws->src_format = srcFormat; | |
83 | 3145 | sws->dst_format = dstFormat; | |
84 | |||
85 |
2/2✓ Branch 0 taken 2 times.
✓ Branch 1 taken 3143 times.
|
3145 | if (param) { |
86 | 2 | sws->scaler_params[0] = param[0]; | |
87 | 2 | sws->scaler_params[1] = param[1]; | |
88 | } | ||
89 | |||
90 | 3145 | return sws; | |
91 | } | ||
92 | |||
93 | 53496 | int ff_shuffle_filter_coefficients(SwsInternal *c, int *filterPos, | |
94 | int filterSize, int16_t *filter, | ||
95 | int dstW) | ||
96 | { | ||
97 | #if ARCH_X86_64 | ||
98 | int i, j, k; | ||
99 | 53496 | int cpu_flags = av_get_cpu_flags(); | |
100 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 53496 times.
|
53496 | if (!filter) |
101 | ✗ | return 0; | |
102 |
4/6✓ Branch 0 taken 390 times.
✓ Branch 1 taken 53106 times.
✓ Branch 2 taken 390 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 390 times.
✗ Branch 5 not taken.
|
53496 | if (EXTERNAL_AVX2_FAST(cpu_flags) && !(cpu_flags & AV_CPU_FLAG_SLOW_GATHER)) { |
103 |
4/4✓ Branch 0 taken 266 times.
✓ Branch 1 taken 124 times.
✓ Branch 2 taken 180 times.
✓ Branch 3 taken 86 times.
|
390 | if ((c->srcBpc == 8) && (c->dstBpc <= 14)) { |
104 | 180 | int16_t *filterCopy = NULL; | |
105 |
2/2✓ Branch 0 taken 30 times.
✓ Branch 1 taken 150 times.
|
180 | if (filterSize > 4) { |
106 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 30 times.
|
30 | if (!FF_ALLOC_TYPED_ARRAY(filterCopy, dstW * filterSize)) |
107 | ✗ | return AVERROR(ENOMEM); | |
108 | 30 | memcpy(filterCopy, filter, dstW * filterSize * sizeof(int16_t)); | |
109 | } | ||
110 | // Do not swap filterPos for pixels which won't be processed by | ||
111 | // the main loop. | ||
112 |
2/2✓ Branch 0 taken 13356 times.
✓ Branch 1 taken 180 times.
|
13536 | for (i = 0; i + 16 <= dstW; i += 16) { |
113 | 13356 | FFSWAP(int, filterPos[i + 2], filterPos[i + 4]); | |
114 | 13356 | FFSWAP(int, filterPos[i + 3], filterPos[i + 5]); | |
115 | 13356 | FFSWAP(int, filterPos[i + 10], filterPos[i + 12]); | |
116 | 13356 | FFSWAP(int, filterPos[i + 11], filterPos[i + 13]); | |
117 | } | ||
118 |
2/2✓ Branch 0 taken 30 times.
✓ Branch 1 taken 150 times.
|
180 | if (filterSize > 4) { |
119 | // 16 pixels are processed at a time. | ||
120 |
2/2✓ Branch 0 taken 330 times.
✓ Branch 1 taken 30 times.
|
360 | for (i = 0; i + 16 <= dstW; i += 16) { |
121 | // 4 filter coeffs are processed at a time. | ||
122 |
2/2✓ Branch 0 taken 1782 times.
✓ Branch 1 taken 330 times.
|
2112 | for (k = 0; k + 4 <= filterSize; k += 4) { |
123 |
2/2✓ Branch 0 taken 28512 times.
✓ Branch 1 taken 1782 times.
|
30294 | for (j = 0; j < 16; ++j) { |
124 | 28512 | int from = (i + j) * filterSize + k; | |
125 | 28512 | int to = i * filterSize + j * 4 + k * 16; | |
126 | 28512 | memcpy(&filter[to], &filterCopy[from], 4 * sizeof(int16_t)); | |
127 | } | ||
128 | } | ||
129 | } | ||
130 | // 4 pixels are processed at a time in the tail. | ||
131 |
2/2✓ Branch 0 taken 20 times.
✓ Branch 1 taken 30 times.
|
50 | for (; i < dstW; i += 4) { |
132 | // 4 filter coeffs are processed at a time. | ||
133 | 20 | int rem = dstW - i >= 4 ? 4 : dstW - i; | |
134 |
2/2✓ Branch 0 taken 108 times.
✓ Branch 1 taken 20 times.
|
128 | for (k = 0; k + 4 <= filterSize; k += 4) { |
135 |
2/2✓ Branch 0 taken 432 times.
✓ Branch 1 taken 108 times.
|
540 | for (j = 0; j < rem; ++j) { |
136 | 432 | int from = (i + j) * filterSize + k; | |
137 | 432 | int to = i * filterSize + j * 4 + k * 4; | |
138 | 432 | memcpy(&filter[to], &filterCopy[from], 4 * sizeof(int16_t)); | |
139 | } | ||
140 | } | ||
141 | } | ||
142 | } | ||
143 | 180 | av_free(filterCopy); | |
144 | } | ||
145 | } | ||
146 | #endif | ||
147 | 53496 | return 0; | |
148 | } | ||
149 | |||
150 | ✗ | static double getSplineCoeff(double a, double b, double c, double d, | |
151 | double dist) | ||
152 | { | ||
153 | ✗ | if (dist <= 1.0) | |
154 | ✗ | return ((d * dist + c) * dist + b) * dist + a; | |
155 | else | ||
156 | ✗ | return getSplineCoeff(0.0, | |
157 | ✗ | b + 2.0 * c + 3.0 * d, | |
158 | ✗ | c + 3.0 * d, | |
159 | ✗ | -b - 3.0 * c - 6.0 * d, | |
160 | dist - 1.0); | ||
161 | } | ||
162 | |||
163 | 210240 | static av_cold int get_local_pos(SwsInternal *s, int chr_subsample, int pos, int dir) | |
164 | { | ||
165 |
3/4✓ Branch 0 taken 210240 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 80397 times.
✓ Branch 3 taken 129843 times.
|
210240 | if (pos == -1 || pos <= -513) { |
166 | 80397 | pos = (128 << chr_subsample) - 128; | |
167 | } | ||
168 | 210240 | pos += 128; // relative to ideal left edge | |
169 | 210240 | return pos >> chr_subsample; | |
170 | } | ||
171 | |||
172 | typedef struct { | ||
173 | int flag; ///< flag associated to the algorithm | ||
174 | const char *description; ///< human-readable description | ||
175 | int size_factor; ///< size factor used when initing the filters | ||
176 | } ScaleAlgorithm; | ||
177 | |||
178 | static const ScaleAlgorithm scale_algorithms[] = { | ||
179 | { SWS_AREA, "area averaging", 1 /* downscale only, for upscale it is bilinear */ }, | ||
180 | { SWS_BICUBIC, "bicubic", 4 }, | ||
181 | { SWS_BICUBLIN, "luma bicubic / chroma bilinear", -1 }, | ||
182 | { SWS_BILINEAR, "bilinear", 2 }, | ||
183 | { SWS_FAST_BILINEAR, "fast bilinear", -1 }, | ||
184 | { SWS_GAUSS, "Gaussian", 8 /* infinite ;) */ }, | ||
185 | { SWS_LANCZOS, "Lanczos", -1 /* custom */ }, | ||
186 | { SWS_POINT, "nearest neighbor / point", -1 }, | ||
187 | { SWS_SINC, "sinc", 20 /* infinite ;) */ }, | ||
188 | { SWS_SPLINE, "bicubic spline", 20 /* infinite :)*/ }, | ||
189 | { SWS_X, "experimental", 8 }, | ||
190 | }; | ||
191 | |||
192 | 105120 | static av_cold int initFilter(int16_t **outFilter, int32_t **filterPos, | |
193 | int *outFilterSize, int xInc, int srcW, | ||
194 | int dstW, int filterAlign, int one, | ||
195 | int flags, int cpu_flags, | ||
196 | SwsVector *srcFilter, SwsVector *dstFilter, | ||
197 | double param[2], int srcPos, int dstPos) | ||
198 | { | ||
199 | int i; | ||
200 | int filterSize; | ||
201 | int filter2Size; | ||
202 | int minFilterSize; | ||
203 | 105120 | int64_t *filter = NULL; | |
204 | 105120 | int64_t *filter2 = NULL; | |
205 | 105120 | const int64_t fone = 1LL << (54 - FFMIN(av_log2(srcW/dstW), 8)); | |
206 | 105120 | int ret = -1; | |
207 | |||
208 | 105120 | emms_c(); // FIXME should not be required but IS (even for non-MMX versions) | |
209 | |||
210 | // NOTE: the +3 is for the MMX(+1) / SSE(+3) scaler which reads over the end | ||
211 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 105120 times.
|
105120 | if (!FF_ALLOC_TYPED_ARRAY(*filterPos, dstW + 3)) |
212 | ✗ | goto nomem; | |
213 | |||
214 |
6/8✓ Branch 0 taken 91656 times.
✓ Branch 1 taken 13464 times.
✓ Branch 2 taken 82408 times.
✓ Branch 3 taken 9248 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 13464 times.
✓ Branch 6 taken 82408 times.
✗ Branch 7 not taken.
|
187528 | if (FFABS(xInc - 0x10000) < 10 && srcPos == dstPos) { // unscaled |
215 | int i; | ||
216 | 82408 | filterSize = 1; | |
217 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 82408 times.
|
82408 | if (!FF_ALLOCZ_TYPED_ARRAY(filter, dstW * filterSize)) |
218 | ✗ | goto nomem; | |
219 | |||
220 |
2/2✓ Branch 0 taken 29915823 times.
✓ Branch 1 taken 82408 times.
|
29998231 | for (i = 0; i < dstW; i++) { |
221 | 29915823 | filter[i * filterSize] = fone; | |
222 | 29915823 | (*filterPos)[i] = i; | |
223 | } | ||
224 |
2/2✓ Branch 0 taken 301 times.
✓ Branch 1 taken 22411 times.
|
22712 | } else if (flags & SWS_POINT) { // lame looking point sampling mode |
225 | int i; | ||
226 | int64_t xDstInSrc; | ||
227 | 301 | filterSize = 1; | |
228 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 301 times.
|
301 | if (!FF_ALLOC_TYPED_ARRAY(filter, dstW * filterSize)) |
229 | ✗ | goto nomem; | |
230 | |||
231 | 301 | xDstInSrc = ((dstPos*(int64_t)xInc)>>8) - ((srcPos*0x8000LL)>>7); | |
232 |
2/2✓ Branch 0 taken 87091 times.
✓ Branch 1 taken 301 times.
|
87392 | for (i = 0; i < dstW; i++) { |
233 | 87091 | int xx = (xDstInSrc - ((filterSize - 1) << 15) + (1 << 15)) >> 16; | |
234 | |||
235 | 87091 | (*filterPos)[i] = xx; | |
236 | 87091 | filter[i] = fone; | |
237 | 87091 | xDstInSrc += xInc; | |
238 | } | ||
239 |
4/4✓ Branch 0 taken 13300 times.
✓ Branch 1 taken 9111 times.
✓ Branch 2 taken 13212 times.
✓ Branch 3 taken 88 times.
|
22411 | } else if ((xInc <= (1 << 16) && (flags & SWS_AREA)) || |
240 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 22323 times.
|
22411 | (flags & SWS_FAST_BILINEAR)) { // bilinear upscale |
241 | int i; | ||
242 | int64_t xDstInSrc; | ||
243 | 88 | filterSize = 2; | |
244 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 88 times.
|
88 | if (!FF_ALLOC_TYPED_ARRAY(filter, dstW * filterSize)) |
245 | ✗ | goto nomem; | |
246 | |||
247 | 88 | xDstInSrc = ((dstPos*(int64_t)xInc)>>8) - ((srcPos*0x8000LL)>>7); | |
248 |
2/2✓ Branch 0 taken 157236 times.
✓ Branch 1 taken 88 times.
|
157324 | for (i = 0; i < dstW; i++) { |
249 | 157236 | int xx = (xDstInSrc - ((filterSize - 1) << 15) + (1 << 15)) >> 16; | |
250 | int j; | ||
251 | |||
252 | 157236 | (*filterPos)[i] = xx; | |
253 | // bilinear upscale / linear interpolate / area averaging | ||
254 |
2/2✓ Branch 0 taken 314472 times.
✓ Branch 1 taken 157236 times.
|
471708 | for (j = 0; j < filterSize; j++) { |
255 | 314472 | int64_t coeff = fone - FFABS((int64_t)xx * (1 << 16) - xDstInSrc) * (fone >> 16); | |
256 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 314472 times.
|
314472 | if (coeff < 0) |
257 | ✗ | coeff = 0; | |
258 | 314472 | filter[i * filterSize + j] = coeff; | |
259 | 314472 | xx++; | |
260 | } | ||
261 | 157236 | xDstInSrc += xInc; | |
262 | } | ||
263 | } else { | ||
264 | int64_t xDstInSrc; | ||
265 | 22323 | int sizeFactor = -1; | |
266 | |||
267 |
1/2✓ Branch 0 taken 45226 times.
✗ Branch 1 not taken.
|
45226 | for (i = 0; i < FF_ARRAY_ELEMS(scale_algorithms); i++) { |
268 |
3/4✓ Branch 0 taken 22323 times.
✓ Branch 1 taken 22903 times.
✓ Branch 2 taken 22323 times.
✗ Branch 3 not taken.
|
45226 | if (flags & scale_algorithms[i].flag && scale_algorithms[i].size_factor > 0) { |
269 | 22323 | sizeFactor = scale_algorithms[i].size_factor; | |
270 | 22323 | break; | |
271 | } | ||
272 | } | ||
273 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 22323 times.
|
22323 | if (flags & SWS_LANCZOS) |
274 | ✗ | sizeFactor = param[0] != SWS_PARAM_DEFAULT ? ceil(2 * param[0]) : 6; | |
275 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 22323 times.
|
22323 | av_assert0(sizeFactor > 0); |
276 | |||
277 |
2/2✓ Branch 0 taken 13212 times.
✓ Branch 1 taken 9111 times.
|
22323 | if (xInc <= 1 << 16) |
278 | 13212 | filterSize = 1 + sizeFactor; // upscale | |
279 | else | ||
280 | 9111 | filterSize = 1 + (sizeFactor * srcW + dstW - 1) / dstW; | |
281 | |||
282 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 22323 times.
|
22323 | filterSize = FFMIN(filterSize, srcW - 2); |
283 | 22323 | filterSize = FFMAX(filterSize, 1); | |
284 | |||
285 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 22323 times.
|
22323 | if (!FF_ALLOC_TYPED_ARRAY(filter, dstW * filterSize)) |
286 | ✗ | goto nomem; | |
287 | 22323 | xDstInSrc = ((dstPos*(int64_t)xInc)>>7) - ((srcPos*0x10000LL)>>7); | |
288 |
2/2✓ Branch 0 taken 7917712 times.
✓ Branch 1 taken 22323 times.
|
7940035 | for (i = 0; i < dstW; i++) { |
289 | 7917712 | int xx = (xDstInSrc - (filterSize - 2) * (1LL<<16)) / (1 << 17); | |
290 | int j; | ||
291 | 7917712 | (*filterPos)[i] = xx; | |
292 |
2/2✓ Branch 0 taken 45820956 times.
✓ Branch 1 taken 7917712 times.
|
53738668 | for (j = 0; j < filterSize; j++) { |
293 | 45820956 | int64_t d = (FFABS(((int64_t)xx * (1 << 17)) - xDstInSrc)) << 13; | |
294 | double floatd; | ||
295 | int64_t coeff; | ||
296 | |||
297 |
2/2✓ Branch 0 taken 13190281 times.
✓ Branch 1 taken 32630675 times.
|
45820956 | if (xInc > 1 << 16) |
298 | 13190281 | d = d * dstW / srcW; | |
299 | 45820956 | floatd = d * (1.0 / (1 << 30)); | |
300 | |||
301 |
2/2✓ Branch 0 taken 45131529 times.
✓ Branch 1 taken 689427 times.
|
45820956 | if (flags & SWS_BICUBIC) { |
302 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 45131529 times.
|
45131529 | int64_t B = (param[0] != SWS_PARAM_DEFAULT ? param[0] : 0) * (1 << 24); |
303 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 45131529 times.
|
45131529 | int64_t C = (param[1] != SWS_PARAM_DEFAULT ? param[1] : 0.6) * (1 << 24); |
304 | |||
305 |
2/2✓ Branch 0 taken 7999819 times.
✓ Branch 1 taken 37131710 times.
|
45131529 | if (d >= 1LL << 31) { |
306 | 7999819 | coeff = 0.0; | |
307 | } else { | ||
308 | 37131710 | int64_t dd = (d * d) >> 30; | |
309 | 37131710 | int64_t ddd = (dd * d) >> 30; | |
310 | |||
311 |
2/2✓ Branch 0 taken 18578740 times.
✓ Branch 1 taken 18552970 times.
|
37131710 | if (d < 1LL << 30) |
312 | 18578740 | coeff = (12 * (1 << 24) - 9 * B - 6 * C) * ddd + | |
313 | 18578740 | (-18 * (1 << 24) + 12 * B + 6 * C) * dd + | |
314 | 18578740 | (6 * (1 << 24) - 2 * B) * (1 << 30); | |
315 | else | ||
316 | 18552970 | coeff = (-B - 6 * C) * ddd + | |
317 | 18552970 | (6 * B + 30 * C) * dd + | |
318 | 18552970 | (-12 * B - 48 * C) * d + | |
319 | 18552970 | (8 * B + 24 * C) * (1 << 30); | |
320 | } | ||
321 | 45131529 | coeff /= (1LL<<54)/fone; | |
322 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 689427 times.
|
689427 | } else if (flags & SWS_X) { |
323 | ✗ | double A = param[0] != SWS_PARAM_DEFAULT ? param[0] : 1.0; | |
324 | double c; | ||
325 | |||
326 | ✗ | if (floatd < 1.0) | |
327 | ✗ | c = cos(floatd * M_PI); | |
328 | else | ||
329 | ✗ | c = -1.0; | |
330 | ✗ | if (c < 0.0) | |
331 | ✗ | c = -pow(-c, A); | |
332 | else | ||
333 | ✗ | c = pow(c, A); | |
334 | ✗ | coeff = (c * 0.5 + 0.5) * fone; | |
335 |
2/2✓ Branch 0 taken 288927 times.
✓ Branch 1 taken 400500 times.
|
689427 | } else if (flags & SWS_AREA) { |
336 | 288927 | int64_t d2 = d - (1 << 29); | |
337 |
2/2✓ Branch 0 taken 218924 times.
✓ Branch 1 taken 70003 times.
|
288927 | if (d2 * xInc < -(1LL << (29 + 16))) |
338 | 218924 | coeff = 1.0 * (1LL << (30 + 16)); | |
339 |
2/2✓ Branch 0 taken 60908 times.
✓ Branch 1 taken 9095 times.
|
70003 | else if (d2 * xInc < (1LL << (29 + 16))) |
340 | 60908 | coeff = -d2 * xInc + (1LL << (29 + 16)); | |
341 | else | ||
342 | 9095 | coeff = 0.0; | |
343 | 288927 | coeff *= fone >> (30 + 16); | |
344 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 400500 times.
|
400500 | } else if (flags & SWS_GAUSS) { |
345 | ✗ | double p = param[0] != SWS_PARAM_DEFAULT ? param[0] : 3.0; | |
346 | ✗ | coeff = exp2(-p * floatd * floatd) * fone; | |
347 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 400500 times.
|
400500 | } else if (flags & SWS_SINC) { |
348 | ✗ | coeff = (d ? sin(floatd * M_PI) / (floatd * M_PI) : 1.0) * fone; | |
349 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 400500 times.
|
400500 | } else if (flags & SWS_LANCZOS) { |
350 | ✗ | double p = param[0] != SWS_PARAM_DEFAULT ? param[0] : 3.0; | |
351 | ✗ | coeff = (d ? sin(floatd * M_PI) * sin(floatd * M_PI / p) / | |
352 | ✗ | (floatd * floatd * M_PI * M_PI / p) : 1.0) * fone; | |
353 | ✗ | if (floatd > p) | |
354 | ✗ | coeff = 0; | |
355 |
1/2✓ Branch 0 taken 400500 times.
✗ Branch 1 not taken.
|
400500 | } else if (flags & SWS_BILINEAR) { |
356 | 400500 | coeff = (1 << 30) - d; | |
357 |
2/2✓ Branch 0 taken 48380 times.
✓ Branch 1 taken 352120 times.
|
400500 | if (coeff < 0) |
358 | 48380 | coeff = 0; | |
359 | 400500 | coeff *= fone >> 30; | |
360 | ✗ | } else if (flags & SWS_SPLINE) { | |
361 | ✗ | double p = -2.196152422706632; | |
362 | ✗ | coeff = getSplineCoeff(1.0, 0.0, p, -p - 1.0, floatd) * fone; | |
363 | } else { | ||
364 | ✗ | av_assert0(0); | |
365 | } | ||
366 | |||
367 | 45820956 | filter[i * filterSize + j] = coeff; | |
368 | 45820956 | xx++; | |
369 | } | ||
370 | 7917712 | xDstInSrc += 2LL * xInc; | |
371 | } | ||
372 | } | ||
373 | |||
374 | /* apply src & dst Filter to filter -> filter2 | ||
375 | * av_free(filter); | ||
376 | */ | ||
377 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 105120 times.
|
105120 | av_assert0(filterSize > 0); |
378 | 105120 | filter2Size = filterSize; | |
379 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 105120 times.
|
105120 | if (srcFilter) |
380 | ✗ | filter2Size += srcFilter->length - 1; | |
381 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 105120 times.
|
105120 | if (dstFilter) |
382 | ✗ | filter2Size += dstFilter->length - 1; | |
383 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 105120 times.
|
105120 | av_assert0(filter2Size > 0); |
384 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 105120 times.
|
105120 | if (!FF_ALLOCZ_TYPED_ARRAY(filter2, dstW * filter2Size)) |
385 | ✗ | goto nomem; | |
386 |
2/2✓ Branch 0 taken 38077862 times.
✓ Branch 1 taken 105120 times.
|
38182982 | for (i = 0; i < dstW; i++) { |
387 | int j, k; | ||
388 | |||
389 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 38077862 times.
|
38077862 | if (srcFilter) { |
390 | ✗ | for (k = 0; k < srcFilter->length; k++) { | |
391 | ✗ | for (j = 0; j < filterSize; j++) | |
392 | ✗ | filter2[i * filter2Size + k + j] += | |
393 | ✗ | srcFilter->coeff[k] * filter[i * filterSize + j]; | |
394 | } | ||
395 | } else { | ||
396 |
2/2✓ Branch 0 taken 76138342 times.
✓ Branch 1 taken 38077862 times.
|
114216204 | for (j = 0; j < filterSize; j++) |
397 | 76138342 | filter2[i * filter2Size + j] = filter[i * filterSize + j]; | |
398 | } | ||
399 | // FIXME dstFilter | ||
400 | |||
401 | 38077862 | (*filterPos)[i] += (filterSize - 1) / 2 - (filter2Size - 1) / 2; | |
402 | } | ||
403 | 105120 | av_freep(&filter); | |
404 | |||
405 | /* try to reduce the filter-size (step1 find size and shift left) */ | ||
406 | // Assume it is near normalized (*0.5 or *2.0 is OK but * 0.001 is not). | ||
407 | 105120 | minFilterSize = 0; | |
408 |
2/2✓ Branch 0 taken 38077862 times.
✓ Branch 1 taken 105120 times.
|
38182982 | for (i = dstW - 1; i >= 0; i--) { |
409 | 38077862 | int min = filter2Size; | |
410 | int j; | ||
411 | 38077862 | int64_t cutOff = 0.0; | |
412 | |||
413 | /* get rid of near zero elements on the left by shifting left */ | ||
414 |
1/2✓ Branch 0 taken 41511657 times.
✗ Branch 1 not taken.
|
41511657 | for (j = 0; j < filter2Size; j++) { |
415 | int k; | ||
416 | 41511657 | cutOff += FFABS(filter2[i * filter2Size]); | |
417 | |||
418 |
2/2✓ Branch 0 taken 38075041 times.
✓ Branch 1 taken 3436616 times.
|
41511657 | if (cutOff > SWS_MAX_REDUCE_CUTOFF * fone) |
419 | 38075041 | break; | |
420 | |||
421 | /* preserve monotonicity because the core can't handle the | ||
422 | * filter otherwise */ | ||
423 |
4/4✓ Branch 0 taken 3422075 times.
✓ Branch 1 taken 14541 times.
✓ Branch 2 taken 2821 times.
✓ Branch 3 taken 3419254 times.
|
3436616 | if (i < dstW - 1 && (*filterPos)[i] >= (*filterPos)[i + 1]) |
424 | 2821 | break; | |
425 | |||
426 | // move filter coefficients left | ||
427 |
2/2✓ Branch 0 taken 14593501 times.
✓ Branch 1 taken 3433795 times.
|
18027296 | for (k = 1; k < filter2Size; k++) |
428 | 14593501 | filter2[i * filter2Size + k - 1] = filter2[i * filter2Size + k]; | |
429 | 3433795 | filter2[i * filter2Size + k - 1] = 0; | |
430 | 3433795 | (*filterPos)[i]++; | |
431 | } | ||
432 | |||
433 | 38077862 | cutOff = 0; | |
434 | /* count near zeros on the right */ | ||
435 |
2/2✓ Branch 0 taken 16196680 times.
✓ Branch 1 taken 30003836 times.
|
46200516 | for (j = filter2Size - 1; j > 0; j--) { |
436 | 16196680 | cutOff += FFABS(filter2[i * filter2Size + j]); | |
437 | |||
438 |
2/2✓ Branch 0 taken 8074026 times.
✓ Branch 1 taken 8122654 times.
|
16196680 | if (cutOff > SWS_MAX_REDUCE_CUTOFF * fone) |
439 | 8074026 | break; | |
440 | 8122654 | min--; | |
441 | } | ||
442 | |||
443 |
2/2✓ Branch 0 taken 105812 times.
✓ Branch 1 taken 37972050 times.
|
38077862 | if (min > minFilterSize) |
444 | 105812 | minFilterSize = min; | |
445 | } | ||
446 | |||
447 | if (PPC_ALTIVEC(cpu_flags)) { | ||
448 | // we can handle the special case 4, so we don't want to go the full 8 | ||
449 | if (minFilterSize < 5) | ||
450 | filterAlign = 4; | ||
451 | |||
452 | /* We really don't want to waste our time doing useless computation, so | ||
453 | * fall back on the scalar C code for very small filters. | ||
454 | * Vectorizing is worth it only if you have a decent-sized vector. */ | ||
455 | if (minFilterSize < 3) | ||
456 | filterAlign = 1; | ||
457 | } | ||
458 | |||
459 |
2/2✓ Branch 0 taken 4904 times.
✓ Branch 1 taken 100216 times.
|
105120 | if (HAVE_MMX && cpu_flags & AV_CPU_FLAG_MMX || have_neon(cpu_flags)) { |
460 | // special case for unscaled vertical filtering | ||
461 |
4/4✓ Branch 0 taken 3733 times.
✓ Branch 1 taken 1171 times.
✓ Branch 2 taken 1285 times.
✓ Branch 3 taken 2448 times.
|
4904 | if (minFilterSize == 1 && filterAlign == 2) |
462 | 1285 | filterAlign = 1; | |
463 | } | ||
464 | |||
465 | if (have_lasx(cpu_flags) || have_lsx(cpu_flags)) { | ||
466 | int reNum = minFilterSize & (0x07); | ||
467 | |||
468 | if (minFilterSize < 5) | ||
469 | filterAlign = 4; | ||
470 | if (reNum < 3) | ||
471 | filterAlign = 1; | ||
472 | } | ||
473 | |||
474 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 105120 times.
|
105120 | av_assert0(minFilterSize > 0); |
475 | 105120 | filterSize = (minFilterSize + (filterAlign - 1)) & (~(filterAlign - 1)); | |
476 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 105120 times.
|
105120 | av_assert0(filterSize > 0); |
477 | 105120 | filter = av_malloc_array(dstW, filterSize * sizeof(*filter)); | |
478 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 105120 times.
|
105120 | if (!filter) |
479 | ✗ | goto nomem; | |
480 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 105120 times.
|
105120 | if (filterSize >= MAX_FILTER_SIZE * 16 / |
481 |
2/2✓ Branch 0 taken 100832 times.
✓ Branch 1 taken 4288 times.
|
105120 | ((flags & SWS_ACCURATE_RND) ? APCK_SIZE : 16)) { |
482 | ✗ | ret = RETCODE_USE_CASCADE; | |
483 | ✗ | goto fail; | |
484 | } | ||
485 | 105120 | *outFilterSize = filterSize; | |
486 | |||
487 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 105120 times.
|
105120 | if (flags & SWS_PRINT_INFO) |
488 | ✗ | av_log(NULL, AV_LOG_VERBOSE, | |
489 | "SwScaler: reducing / aligning filtersize %d -> %d\n", | ||
490 | filter2Size, filterSize); | ||
491 | /* try to reduce the filter-size (step2 reduce it) */ | ||
492 |
2/2✓ Branch 0 taken 38077862 times.
✓ Branch 1 taken 105120 times.
|
38182982 | for (i = 0; i < dstW; i++) { |
493 | int j; | ||
494 | |||
495 |
2/2✓ Branch 0 taken 78251515 times.
✓ Branch 1 taken 38077862 times.
|
116329377 | for (j = 0; j < filterSize; j++) { |
496 |
2/2✓ Branch 0 taken 10091970 times.
✓ Branch 1 taken 68159545 times.
|
78251515 | if (j >= filter2Size) |
497 | 10091970 | filter[i * filterSize + j] = 0; | |
498 | else | ||
499 | 68159545 | filter[i * filterSize + j] = filter2[i * filter2Size + j]; | |
500 |
4/4✓ Branch 0 taken 76466583 times.
✓ Branch 1 taken 1784932 times.
✓ Branch 2 taken 10056960 times.
✓ Branch 3 taken 66409623 times.
|
78251515 | if ((flags & SWS_BITEXACT) && j >= minFilterSize) |
501 | 10056960 | filter[i * filterSize + j] = 0; | |
502 | } | ||
503 | } | ||
504 | |||
505 | // FIXME try to align filterPos if possible | ||
506 | |||
507 | // fix borders | ||
508 |
2/2✓ Branch 0 taken 38077862 times.
✓ Branch 1 taken 105120 times.
|
38182982 | for (i = 0; i < dstW; i++) { |
509 | int j; | ||
510 |
2/2✓ Branch 0 taken 47473 times.
✓ Branch 1 taken 38030389 times.
|
38077862 | if ((*filterPos)[i] < 0) { |
511 | // move filter coefficients left to compensate for filterPos | ||
512 |
2/2✓ Branch 0 taken 226860 times.
✓ Branch 1 taken 47473 times.
|
274333 | for (j = 1; j < filterSize; j++) { |
513 | 226860 | int left = FFMAX(j + (*filterPos)[i], 0); | |
514 | 226860 | filter[i * filterSize + left] += filter[i * filterSize + j]; | |
515 | 226860 | filter[i * filterSize + j] = 0; | |
516 | } | ||
517 | 47473 | (*filterPos)[i]= 0; | |
518 | } | ||
519 | |||
520 |
2/2✓ Branch 0 taken 70321 times.
✓ Branch 1 taken 38007541 times.
|
38077862 | if ((*filterPos)[i] + filterSize > srcW) { |
521 | 70321 | int shift = (*filterPos)[i] + FFMIN(filterSize - srcW, 0); | |
522 | 70321 | int64_t acc = 0; | |
523 | |||
524 |
2/2✓ Branch 0 taken 368137 times.
✓ Branch 1 taken 70321 times.
|
438458 | for (j = filterSize - 1; j >= 0; j--) { |
525 |
2/2✓ Branch 0 taken 115111 times.
✓ Branch 1 taken 253026 times.
|
368137 | if ((*filterPos)[i] + j >= srcW) { |
526 | 115111 | acc += filter[i * filterSize + j]; | |
527 | 115111 | filter[i * filterSize + j] = 0; | |
528 | } | ||
529 | } | ||
530 |
2/2✓ Branch 0 taken 368137 times.
✓ Branch 1 taken 70321 times.
|
438458 | for (j = filterSize - 1; j >= 0; j--) { |
531 |
2/2✓ Branch 0 taken 115111 times.
✓ Branch 1 taken 253026 times.
|
368137 | if (j < shift) { |
532 | 115111 | filter[i * filterSize + j] = 0; | |
533 | } else { | ||
534 | 253026 | filter[i * filterSize + j] = filter[i * filterSize + j - shift]; | |
535 | } | ||
536 | } | ||
537 | |||
538 | 70321 | (*filterPos)[i]-= shift; | |
539 | 70321 | filter[i * filterSize + srcW - 1 - (*filterPos)[i]] += acc; | |
540 | } | ||
541 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 38077862 times.
|
38077862 | av_assert0((*filterPos)[i] >= 0); |
542 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 38077862 times.
|
38077862 | av_assert0((*filterPos)[i] < srcW); |
543 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 38077862 times.
|
38077862 | if ((*filterPos)[i] + filterSize > srcW) { |
544 | ✗ | for (j = 0; j < filterSize; j++) { | |
545 | ✗ | av_assert0((*filterPos)[i] + j < srcW || !filter[i * filterSize + j]); | |
546 | } | ||
547 | } | ||
548 | } | ||
549 | |||
550 | // Note the +1 is for the MMX scaler which reads over the end | ||
551 | /* align at 16 for AltiVec (needed by hScale_altivec_real) */ | ||
552 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 105120 times.
|
105120 | if (!FF_ALLOCZ_TYPED_ARRAY(*outFilter, *outFilterSize * (dstW + 3))) |
553 | ✗ | goto nomem; | |
554 | |||
555 | /* normalize & store in outFilter */ | ||
556 |
2/2✓ Branch 0 taken 38077862 times.
✓ Branch 1 taken 105120 times.
|
38182982 | for (i = 0; i < dstW; i++) { |
557 | int j; | ||
558 | 38077862 | int64_t error = 0; | |
559 | 38077862 | int64_t sum = 0; | |
560 | |||
561 |
2/2✓ Branch 0 taken 78251515 times.
✓ Branch 1 taken 38077862 times.
|
116329377 | for (j = 0; j < filterSize; j++) { |
562 | 78251515 | sum += filter[i * filterSize + j]; | |
563 | } | ||
564 | 38077862 | sum = (sum + one / 2) / one; | |
565 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 38077862 times.
|
38077862 | if (!sum) { |
566 | ✗ | av_log(NULL, AV_LOG_WARNING, "SwScaler: zero vector in scaling\n"); | |
567 | ✗ | sum = 1; | |
568 | } | ||
569 |
2/2✓ Branch 0 taken 78251515 times.
✓ Branch 1 taken 38077862 times.
|
116329377 | for (j = 0; j < *outFilterSize; j++) { |
570 | 78251515 | int64_t v = filter[i * filterSize + j] + error; | |
571 |
2/2✓ Branch 0 taken 59804663 times.
✓ Branch 1 taken 18446852 times.
|
78251515 | int intV = ROUNDED_DIV(v, sum); |
572 | 78251515 | (*outFilter)[i * (*outFilterSize) + j] = intV; | |
573 | 78251515 | error = v - intV * sum; | |
574 | } | ||
575 | } | ||
576 | |||
577 | 105120 | (*filterPos)[dstW + 0] = | |
578 | 105120 | (*filterPos)[dstW + 1] = | |
579 | 105120 | (*filterPos)[dstW + 2] = (*filterPos)[dstW - 1]; /* the MMX/SSE scaler will | |
580 | * read over the end */ | ||
581 |
2/2✓ Branch 0 taken 226156 times.
✓ Branch 1 taken 105120 times.
|
331276 | for (i = 0; i < *outFilterSize; i++) { |
582 | 226156 | int k = (dstW - 1) * (*outFilterSize) + i; | |
583 | 226156 | (*outFilter)[k + 1 * (*outFilterSize)] = | |
584 | 226156 | (*outFilter)[k + 2 * (*outFilterSize)] = | |
585 | 226156 | (*outFilter)[k + 3 * (*outFilterSize)] = (*outFilter)[k]; | |
586 | } | ||
587 | |||
588 | 105120 | ret = 0; | |
589 | 105120 | goto done; | |
590 | ✗ | nomem: | |
591 | ✗ | ret = AVERROR(ENOMEM); | |
592 | ✗ | fail: | |
593 | ✗ | if(ret < 0) | |
594 | ✗ | av_log(NULL, ret == RETCODE_USE_CASCADE ? AV_LOG_DEBUG : AV_LOG_ERROR, "sws: initFilter failed\n"); | |
595 | ✗ | done: | |
596 | 105120 | av_free(filter); | |
597 | 105120 | av_free(filter2); | |
598 | 105120 | return ret; | |
599 | } | ||
600 | |||
601 | 18575 | static void fill_rgb2yuv_table(SwsInternal *c, const int table[4], int dstRange) | |
602 | { | ||
603 | int64_t W, V, Z, Cy, Cu, Cv; | ||
604 | 18575 | int64_t vr = table[0]; | |
605 | 18575 | int64_t ub = table[1]; | |
606 | 18575 | int64_t ug = -table[2]; | |
607 | 18575 | int64_t vg = -table[3]; | |
608 | 18575 | int64_t ONE = 65536; | |
609 | 18575 | int64_t cy = ONE; | |
610 | 18575 | uint8_t *p = (uint8_t*)c->input_rgb2yuv_table; | |
611 | int i; | ||
612 | static const int8_t map[] = { | ||
613 | BY_IDX, GY_IDX, -1 , BY_IDX, BY_IDX, GY_IDX, -1 , BY_IDX, | ||
614 | RY_IDX, -1 , GY_IDX, RY_IDX, RY_IDX, -1 , GY_IDX, RY_IDX, | ||
615 | RY_IDX, GY_IDX, -1 , RY_IDX, RY_IDX, GY_IDX, -1 , RY_IDX, | ||
616 | BY_IDX, -1 , GY_IDX, BY_IDX, BY_IDX, -1 , GY_IDX, BY_IDX, | ||
617 | BU_IDX, GU_IDX, -1 , BU_IDX, BU_IDX, GU_IDX, -1 , BU_IDX, | ||
618 | RU_IDX, -1 , GU_IDX, RU_IDX, RU_IDX, -1 , GU_IDX, RU_IDX, | ||
619 | RU_IDX, GU_IDX, -1 , RU_IDX, RU_IDX, GU_IDX, -1 , RU_IDX, | ||
620 | BU_IDX, -1 , GU_IDX, BU_IDX, BU_IDX, -1 , GU_IDX, BU_IDX, | ||
621 | BV_IDX, GV_IDX, -1 , BV_IDX, BV_IDX, GV_IDX, -1 , BV_IDX, | ||
622 | RV_IDX, -1 , GV_IDX, RV_IDX, RV_IDX, -1 , GV_IDX, RV_IDX, | ||
623 | RV_IDX, GV_IDX, -1 , RV_IDX, RV_IDX, GV_IDX, -1 , RV_IDX, | ||
624 | BV_IDX, -1 , GV_IDX, BV_IDX, BV_IDX, -1 , GV_IDX, BV_IDX, | ||
625 | RY_IDX, BY_IDX, RY_IDX, BY_IDX, RY_IDX, BY_IDX, RY_IDX, BY_IDX, | ||
626 | BY_IDX, RY_IDX, BY_IDX, RY_IDX, BY_IDX, RY_IDX, BY_IDX, RY_IDX, | ||
627 | GY_IDX, -1 , GY_IDX, -1 , GY_IDX, -1 , GY_IDX, -1 , | ||
628 | -1 , GY_IDX, -1 , GY_IDX, -1 , GY_IDX, -1 , GY_IDX, | ||
629 | RU_IDX, BU_IDX, RU_IDX, BU_IDX, RU_IDX, BU_IDX, RU_IDX, BU_IDX, | ||
630 | BU_IDX, RU_IDX, BU_IDX, RU_IDX, BU_IDX, RU_IDX, BU_IDX, RU_IDX, | ||
631 | GU_IDX, -1 , GU_IDX, -1 , GU_IDX, -1 , GU_IDX, -1 , | ||
632 | -1 , GU_IDX, -1 , GU_IDX, -1 , GU_IDX, -1 , GU_IDX, | ||
633 | RV_IDX, BV_IDX, RV_IDX, BV_IDX, RV_IDX, BV_IDX, RV_IDX, BV_IDX, | ||
634 | BV_IDX, RV_IDX, BV_IDX, RV_IDX, BV_IDX, RV_IDX, BV_IDX, RV_IDX, | ||
635 | GV_IDX, -1 , GV_IDX, -1 , GV_IDX, -1 , GV_IDX, -1 , | ||
636 | -1 , GV_IDX, -1 , GV_IDX, -1 , GV_IDX, -1 , GV_IDX, //23 | ||
637 | -1 , -1 , -1 , -1 , -1 , -1 , -1 , -1 , //24 | ||
638 | -1 , -1 , -1 , -1 , -1 , -1 , -1 , -1 , //25 | ||
639 | -1 , -1 , -1 , -1 , -1 , -1 , -1 , -1 , //26 | ||
640 | -1 , -1 , -1 , -1 , -1 , -1 , -1 , -1 , //27 | ||
641 | -1 , -1 , -1 , -1 , -1 , -1 , -1 , -1 , //28 | ||
642 | -1 , -1 , -1 , -1 , -1 , -1 , -1 , -1 , //29 | ||
643 | -1 , -1 , -1 , -1 , -1 , -1 , -1 , -1 , //30 | ||
644 | -1 , -1 , -1 , -1 , -1 , -1 , -1 , -1 , //31 | ||
645 | BY_IDX, GY_IDX, RY_IDX, -1 , -1 , -1 , -1 , -1 , //32 | ||
646 | BU_IDX, GU_IDX, RU_IDX, -1 , -1 , -1 , -1 , -1 , //33 | ||
647 | BV_IDX, GV_IDX, RV_IDX, -1 , -1 , -1 , -1 , -1 , //34 | ||
648 | }; | ||
649 | |||
650 | 18575 | dstRange = 0; //FIXME range = 1 is handled elsewhere | |
651 | |||
652 |
1/2✓ Branch 0 taken 18575 times.
✗ Branch 1 not taken.
|
18575 | if (!dstRange) { |
653 | 18575 | cy = cy * 255 / 219; | |
654 | } else { | ||
655 | ✗ | vr = vr * 224 / 255; | |
656 | ✗ | ub = ub * 224 / 255; | |
657 | ✗ | ug = ug * 224 / 255; | |
658 | ✗ | vg = vg * 224 / 255; | |
659 | } | ||
660 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 18575 times.
|
18575 | W = ROUNDED_DIV(ONE*ONE*ug, ub); |
661 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 18575 times.
|
18575 | V = ROUNDED_DIV(ONE*ONE*vg, vr); |
662 | 18575 | Z = ONE*ONE-W-V; | |
663 | |||
664 |
1/2✓ Branch 0 taken 18575 times.
✗ Branch 1 not taken.
|
18575 | Cy = ROUNDED_DIV(cy*Z, ONE); |
665 |
1/2✓ Branch 0 taken 18575 times.
✗ Branch 1 not taken.
|
18575 | Cu = ROUNDED_DIV(ub*Z, ONE); |
666 |
1/2✓ Branch 0 taken 18575 times.
✗ Branch 1 not taken.
|
18575 | Cv = ROUNDED_DIV(vr*Z, ONE); |
667 | |||
668 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 18575 times.
|
18575 | c->input_rgb2yuv_table[RY_IDX] = -ROUNDED_DIV((1 << RGB2YUV_SHIFT)*V , Cy); |
669 | 18575 | c->input_rgb2yuv_table[GY_IDX] = ROUNDED_DIV((1 << RGB2YUV_SHIFT)*ONE*ONE , Cy); | |
670 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 18575 times.
|
18575 | c->input_rgb2yuv_table[BY_IDX] = -ROUNDED_DIV((1 << RGB2YUV_SHIFT)*W , Cy); |
671 | |||
672 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 18575 times.
|
18575 | c->input_rgb2yuv_table[RU_IDX] = ROUNDED_DIV((1 << RGB2YUV_SHIFT)*V , Cu); |
673 | 18575 | c->input_rgb2yuv_table[GU_IDX] = -ROUNDED_DIV((1 << RGB2YUV_SHIFT)*ONE*ONE , Cu); | |
674 |
1/2✓ Branch 0 taken 18575 times.
✗ Branch 1 not taken.
|
18575 | c->input_rgb2yuv_table[BU_IDX] = ROUNDED_DIV((1 << RGB2YUV_SHIFT)*(Z+W) , Cu); |
675 | |||
676 |
1/2✓ Branch 0 taken 18575 times.
✗ Branch 1 not taken.
|
18575 | c->input_rgb2yuv_table[RV_IDX] = ROUNDED_DIV((1 << RGB2YUV_SHIFT)*(V+Z) , Cv); |
677 | 18575 | c->input_rgb2yuv_table[GV_IDX] = -ROUNDED_DIV((1 << RGB2YUV_SHIFT)*ONE*ONE , Cv); | |
678 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 18575 times.
|
18575 | c->input_rgb2yuv_table[BV_IDX] = ROUNDED_DIV((1 << RGB2YUV_SHIFT)*W , Cv); |
679 | |||
680 |
1/2✓ Branch 0 taken 18575 times.
✗ Branch 1 not taken.
|
18575 | if(/*!dstRange && */!memcmp(table, ff_yuv2rgb_coeffs[SWS_CS_DEFAULT], sizeof(ff_yuv2rgb_coeffs[SWS_CS_DEFAULT]))) { |
681 | 18575 | c->input_rgb2yuv_table[BY_IDX] = ((int)(0.114 * 219 / 255 * (1 << RGB2YUV_SHIFT) + 0.5)); | |
682 | 18575 | c->input_rgb2yuv_table[BV_IDX] = (-(int)(0.081 * 224 / 255 * (1 << RGB2YUV_SHIFT) + 0.5)); | |
683 | 18575 | c->input_rgb2yuv_table[BU_IDX] = ((int)(0.500 * 224 / 255 * (1 << RGB2YUV_SHIFT) + 0.5)); | |
684 | 18575 | c->input_rgb2yuv_table[GY_IDX] = ((int)(0.587 * 219 / 255 * (1 << RGB2YUV_SHIFT) + 0.5)); | |
685 | 18575 | c->input_rgb2yuv_table[GV_IDX] = (-(int)(0.419 * 224 / 255 * (1 << RGB2YUV_SHIFT) + 0.5)); | |
686 | 18575 | c->input_rgb2yuv_table[GU_IDX] = (-(int)(0.331 * 224 / 255 * (1 << RGB2YUV_SHIFT) + 0.5)); | |
687 | 18575 | c->input_rgb2yuv_table[RY_IDX] = ((int)(0.299 * 219 / 255 * (1 << RGB2YUV_SHIFT) + 0.5)); | |
688 | 18575 | c->input_rgb2yuv_table[RV_IDX] = ((int)(0.500 * 224 / 255 * (1 << RGB2YUV_SHIFT) + 0.5)); | |
689 | 18575 | c->input_rgb2yuv_table[RU_IDX] = (-(int)(0.169 * 224 / 255 * (1 << RGB2YUV_SHIFT) + 0.5)); | |
690 | } | ||
691 |
2/2✓ Branch 0 taken 5201000 times.
✓ Branch 1 taken 18575 times.
|
5219575 | for(i=0; i<FF_ARRAY_ELEMS(map); i++) |
692 |
2/2✓ Branch 0 taken 2841975 times.
✓ Branch 1 taken 2359025 times.
|
5201000 | AV_WL16(p + 16*4 + 2*i, map[i] >= 0 ? c->input_rgb2yuv_table[map[i]] : 0); |
693 | 18575 | } | |
694 | |||
695 | #if CONFIG_SMALL | ||
696 | static void init_xyz_tables(uint16_t xyzgamma_tab[4096], uint16_t xyzgammainv_tab[65536], | ||
697 | uint16_t rgbgamma_tab[65536], uint16_t rgbgammainv_tab[4096]) | ||
698 | #else | ||
699 | static uint16_t xyzgamma_tab[4096], rgbgammainv_tab[4096]; | ||
700 | static uint16_t rgbgamma_tab[65536], xyzgammainv_tab[65536]; | ||
701 | 37 | static av_cold void init_xyz_tables(void) | |
702 | #endif | ||
703 | { | ||
704 | 37 | double xyzgamma = XYZ_GAMMA; | |
705 | 37 | double rgbgamma = 1.0 / RGB_GAMMA; | |
706 | 37 | double xyzgammainv = 1.0 / XYZ_GAMMA; | |
707 | 37 | double rgbgammainv = RGB_GAMMA; | |
708 | |||
709 | /* set input gamma vectors */ | ||
710 |
2/2✓ Branch 0 taken 151552 times.
✓ Branch 1 taken 37 times.
|
151589 | for (int i = 0; i < 4096; i++) { |
711 | 151552 | xyzgamma_tab[i] = lrint(pow(i / 4095.0, xyzgamma) * 65535.0); | |
712 | 151552 | rgbgammainv_tab[i] = lrint(pow(i / 4095.0, rgbgammainv) * 65535.0); | |
713 | } | ||
714 | |||
715 | /* set output gamma vectors */ | ||
716 |
2/2✓ Branch 0 taken 2424832 times.
✓ Branch 1 taken 37 times.
|
2424869 | for (int i = 0; i < 65536; i++) { |
717 | 2424832 | rgbgamma_tab[i] = lrint(pow(i / 65535.0, rgbgamma) * 4095.0); | |
718 | 2424832 | xyzgammainv_tab[i] = lrint(pow(i / 65535.0, xyzgammainv) * 4095.0); | |
719 | } | ||
720 | 37 | } | |
721 | |||
722 | 150 | static int fill_xyztables(SwsInternal *c) | |
723 | { | ||
724 | static const int16_t xyz2rgb_matrix[3][4] = { | ||
725 | {13270, -6295, -2041}, | ||
726 | {-3969, 7682, 170}, | ||
727 | { 228, -835, 4329} }; | ||
728 | static const int16_t rgb2xyz_matrix[3][4] = { | ||
729 | {1689, 1464, 739}, | ||
730 | { 871, 2929, 296}, | ||
731 | { 79, 488, 3891} }; | ||
732 | |||
733 |
2/2✓ Branch 0 taken 100 times.
✓ Branch 1 taken 50 times.
|
150 | if (c->xyzgamma) |
734 | 100 | return 0; | |
735 | |||
736 | 50 | memcpy(c->xyz2rgb_matrix, xyz2rgb_matrix, sizeof(c->xyz2rgb_matrix)); | |
737 | 50 | memcpy(c->rgb2xyz_matrix, rgb2xyz_matrix, sizeof(c->rgb2xyz_matrix)); | |
738 | |||
739 | #if CONFIG_SMALL | ||
740 | c->xyzgamma = av_malloc(sizeof(uint16_t) * 2 * (4096 + 65536)); | ||
741 | if (!c->xyzgamma) | ||
742 | return AVERROR(ENOMEM); | ||
743 | c->rgbgammainv = c->xyzgamma + 4096; | ||
744 | c->rgbgamma = c->rgbgammainv + 4096; | ||
745 | c->xyzgammainv = c->rgbgamma + 65536; | ||
746 | init_xyz_tables(c->xyzgamma, c->xyzgammainv, c->rgbgamma, c->rgbgammainv); | ||
747 | #else | ||
748 | 50 | c->xyzgamma = xyzgamma_tab; | |
749 | 50 | c->rgbgamma = rgbgamma_tab; | |
750 | 50 | c->xyzgammainv = xyzgammainv_tab; | |
751 | 50 | c->rgbgammainv = rgbgammainv_tab; | |
752 | |||
753 | static AVOnce xyz_init_static_once = AV_ONCE_INIT; | ||
754 | 50 | ff_thread_once(&xyz_init_static_once, init_xyz_tables); | |
755 | #endif | ||
756 | 50 | return 0; | |
757 | } | ||
758 | |||
759 | 19012 | static int handle_jpeg(enum AVPixelFormat *format) | |
760 | { | ||
761 |
7/7✓ Branch 0 taken 95 times.
✓ Branch 1 taken 16 times.
✓ Branch 2 taken 53 times.
✓ Branch 3 taken 62 times.
✓ Branch 4 taken 44 times.
✓ Branch 5 taken 417 times.
✓ Branch 6 taken 18325 times.
|
19012 | switch (*format) { |
762 | 95 | case AV_PIX_FMT_YUVJ420P: | |
763 | 95 | *format = AV_PIX_FMT_YUV420P; | |
764 | 95 | return 1; | |
765 | 16 | case AV_PIX_FMT_YUVJ411P: | |
766 | 16 | *format = AV_PIX_FMT_YUV411P; | |
767 | 16 | return 1; | |
768 | 53 | case AV_PIX_FMT_YUVJ422P: | |
769 | 53 | *format = AV_PIX_FMT_YUV422P; | |
770 | 53 | return 1; | |
771 | 62 | case AV_PIX_FMT_YUVJ444P: | |
772 | 62 | *format = AV_PIX_FMT_YUV444P; | |
773 | 62 | return 1; | |
774 | 44 | case AV_PIX_FMT_YUVJ440P: | |
775 | 44 | *format = AV_PIX_FMT_YUV440P; | |
776 | 44 | return 1; | |
777 | 417 | case AV_PIX_FMT_GRAY8: | |
778 | case AV_PIX_FMT_YA8: | ||
779 | case AV_PIX_FMT_GRAY9LE: | ||
780 | case AV_PIX_FMT_GRAY9BE: | ||
781 | case AV_PIX_FMT_GRAY10LE: | ||
782 | case AV_PIX_FMT_GRAY10BE: | ||
783 | case AV_PIX_FMT_GRAY12LE: | ||
784 | case AV_PIX_FMT_GRAY12BE: | ||
785 | case AV_PIX_FMT_GRAY14LE: | ||
786 | case AV_PIX_FMT_GRAY14BE: | ||
787 | case AV_PIX_FMT_GRAY16LE: | ||
788 | case AV_PIX_FMT_GRAY16BE: | ||
789 | case AV_PIX_FMT_YA16BE: | ||
790 | case AV_PIX_FMT_YA16LE: | ||
791 | 417 | return 1; | |
792 | 18325 | default: | |
793 | 18325 | return 0; | |
794 | } | ||
795 | } | ||
796 | |||
797 | 184100 | static int handle_0alpha(enum AVPixelFormat *format) | |
798 | { | ||
799 |
5/5✓ Branch 0 taken 19 times.
✓ Branch 1 taken 51 times.
✓ Branch 2 taken 19 times.
✓ Branch 3 taken 19 times.
✓ Branch 4 taken 183992 times.
|
184100 | switch (*format) { |
800 | 19 | case AV_PIX_FMT_0BGR : *format = AV_PIX_FMT_ABGR ; return 1; | |
801 | 51 | case AV_PIX_FMT_BGR0 : *format = AV_PIX_FMT_BGRA ; return 4; | |
802 | 19 | case AV_PIX_FMT_0RGB : *format = AV_PIX_FMT_ARGB ; return 1; | |
803 | 19 | case AV_PIX_FMT_RGB0 : *format = AV_PIX_FMT_RGBA ; return 4; | |
804 | 183992 | default: return 0; | |
805 | } | ||
806 | } | ||
807 | |||
808 | 184100 | static int handle_xyz(enum AVPixelFormat *format) | |
809 | { | ||
810 |
3/3✓ Branch 0 taken 14 times.
✓ Branch 1 taken 38 times.
✓ Branch 2 taken 184048 times.
|
184100 | switch (*format) { |
811 | 14 | case AV_PIX_FMT_XYZ12BE : *format = AV_PIX_FMT_RGB48BE; return 1; | |
812 | 38 | case AV_PIX_FMT_XYZ12LE : *format = AV_PIX_FMT_RGB48LE; return 1; | |
813 | 184048 | default: return 0; | |
814 | } | ||
815 | } | ||
816 | |||
817 | 92050 | static int handle_formats(SwsContext *sws) | |
818 | { | ||
819 | 92050 | SwsInternal *c = sws_internal(sws); | |
820 | 92050 | c->src0Alpha |= handle_0alpha(&sws->src_format); | |
821 | 92050 | c->dst0Alpha |= handle_0alpha(&sws->dst_format); | |
822 | 92050 | c->srcXYZ |= handle_xyz(&sws->src_format); | |
823 | 92050 | c->dstXYZ |= handle_xyz(&sws->dst_format); | |
824 |
4/4✓ Branch 0 taken 92008 times.
✓ Branch 1 taken 42 times.
✓ Branch 2 taken 108 times.
✓ Branch 3 taken 91900 times.
|
92050 | if (c->srcXYZ || c->dstXYZ) |
825 | 150 | return fill_xyztables(c); | |
826 | else | ||
827 | 91900 | return 0; | |
828 | } | ||
829 | |||
830 | 132840 | static int range_override_needed(enum AVPixelFormat format) | |
831 | { | ||
832 |
4/4✓ Branch 1 taken 49377 times.
✓ Branch 2 taken 83463 times.
✓ Branch 4 taken 44900 times.
✓ Branch 5 taken 4477 times.
|
132840 | return !isYUV(format) && !isGray(format); |
833 | } | ||
834 | |||
835 | 60254 | int sws_setColorspaceDetails(SwsContext *sws, const int inv_table[4], | |
836 | int srcRange, const int table[4], int dstRange, | ||
837 | int brightness, int contrast, int saturation) | ||
838 | { | ||
839 | 60254 | SwsInternal *c = sws_internal(sws); | |
840 | const AVPixFmtDescriptor *desc_dst; | ||
841 | const AVPixFmtDescriptor *desc_src; | ||
842 | 60254 | int ret, need_reinit = 0; | |
843 | |||
844 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 60254 times.
|
60254 | if (c->nb_slice_ctx) { |
845 | ✗ | int parent_ret = 0; | |
846 | ✗ | for (int i = 0; i < c->nb_slice_ctx; i++) { | |
847 | ✗ | int ret = sws_setColorspaceDetails(c->slice_ctx[i], inv_table, | |
848 | srcRange, table, dstRange, | ||
849 | brightness, contrast, saturation); | ||
850 | ✗ | if (ret < 0) | |
851 | ✗ | parent_ret = ret; | |
852 | } | ||
853 | |||
854 | ✗ | return parent_ret; | |
855 | } | ||
856 | |||
857 | 60254 | ret = handle_formats(sws); | |
858 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 60254 times.
|
60254 | if (ret < 0) |
859 | ✗ | return ret; | |
860 | 60254 | desc_dst = av_pix_fmt_desc_get(sws->dst_format); | |
861 | 60254 | desc_src = av_pix_fmt_desc_get(sws->src_format); | |
862 | |||
863 |
2/2✓ Branch 1 taken 23543 times.
✓ Branch 2 taken 36711 times.
|
60254 | if(range_override_needed(sws->dst_format)) |
864 | 23543 | dstRange = 0; | |
865 |
2/2✓ Branch 1 taken 18252 times.
✓ Branch 2 taken 42002 times.
|
60254 | if(range_override_needed(sws->src_format)) |
866 | 18252 | srcRange = 0; | |
867 | |||
868 |
2/2✓ Branch 0 taken 59164 times.
✓ Branch 1 taken 1090 times.
|
60254 | if (sws->src_range != srcRange || |
869 |
2/2✓ Branch 0 taken 57610 times.
✓ Branch 1 taken 1554 times.
|
59164 | sws->dst_range != dstRange || |
870 |
1/2✓ Branch 0 taken 57610 times.
✗ Branch 1 not taken.
|
57610 | c->brightness != brightness || |
871 |
2/2✓ Branch 0 taken 28458 times.
✓ Branch 1 taken 29152 times.
|
57610 | c->contrast != contrast || |
872 |
1/2✓ Branch 0 taken 28458 times.
✗ Branch 1 not taken.
|
28458 | c->saturation != saturation || |
873 |
2/2✓ Branch 0 taken 28316 times.
✓ Branch 1 taken 142 times.
|
28458 | memcmp(c->srcColorspaceTable, inv_table, sizeof(int) * 4) || |
874 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 28316 times.
|
28316 | memcmp(c->dstColorspaceTable, table, sizeof(int) * 4) |
875 | ) | ||
876 | 31938 | need_reinit = 1; | |
877 | |||
878 | 60254 | memmove(c->srcColorspaceTable, inv_table, sizeof(int) * 4); | |
879 | 60254 | memmove(c->dstColorspaceTable, table, sizeof(int) * 4); | |
880 | |||
881 | |||
882 | |||
883 | 60254 | c->brightness = brightness; | |
884 | 60254 | c->contrast = contrast; | |
885 | 60254 | c->saturation = saturation; | |
886 | 60254 | sws->src_range = srcRange; | |
887 | 60254 | sws->dst_range = dstRange; | |
888 | |||
889 |
2/2✓ Branch 0 taken 31938 times.
✓ Branch 1 taken 28316 times.
|
60254 | if (need_reinit) |
890 | 31938 | ff_sws_init_range_convert(c); | |
891 | |||
892 | 60254 | c->dstFormatBpp = av_get_bits_per_pixel(desc_dst); | |
893 | 60254 | c->srcFormatBpp = av_get_bits_per_pixel(desc_src); | |
894 | |||
895 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 60254 times.
|
60254 | if (c->cascaded_context[c->cascaded_mainindex]) |
896 | ✗ | return sws_setColorspaceDetails(c->cascaded_context[c->cascaded_mainindex],inv_table, srcRange,table, dstRange, brightness, contrast, saturation); | |
897 | |||
898 |
2/2✓ Branch 0 taken 28316 times.
✓ Branch 1 taken 31938 times.
|
60254 | if (!need_reinit) |
899 | 28316 | return 0; | |
900 | |||
901 |
8/8✓ Branch 1 taken 14410 times.
✓ Branch 2 taken 17528 times.
✓ Branch 4 taken 1118 times.
✓ Branch 5 taken 13292 times.
✓ Branch 7 taken 5789 times.
✓ Branch 8 taken 12857 times.
✓ Branch 10 taken 506 times.
✓ Branch 11 taken 5283 times.
|
31938 | if ((isYUV(sws->dst_format) || isGray(sws->dst_format)) && (isYUV(sws->src_format) || isGray(sws->src_format))) { |
902 |
1/2✓ Branch 0 taken 13363 times.
✗ Branch 1 not taken.
|
13363 | if (!c->cascaded_context[0] && |
903 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 13362 times.
|
13363 | memcmp(c->dstColorspaceTable, c->srcColorspaceTable, sizeof(int) * 4) && |
904 |
4/8✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 1 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 1 times.
✗ Branch 7 not taken.
|
1 | sws->src_w && sws->src_h && sws->dst_w && sws->dst_h) { |
905 | enum AVPixelFormat tmp_format; | ||
906 | int tmp_width, tmp_height; | ||
907 | 1 | int srcW = sws->src_w; | |
908 | 1 | int srcH = sws->src_h; | |
909 | 1 | int dstW = sws->dst_w; | |
910 | 1 | int dstH = sws->dst_h; | |
911 | int ret; | ||
912 | 1 | av_log(c, AV_LOG_VERBOSE, "YUV color matrix differs for YUV->YUV, using intermediate RGB to convert\n"); | |
913 | |||
914 |
2/4✓ Branch 1 taken 1 times.
✗ Branch 2 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 1 times.
|
1 | if (isNBPS(sws->dst_format) || is16BPS(sws->dst_format)) { |
915 | ✗ | if (isALPHA(sws->src_format) && isALPHA(sws->dst_format)) { | |
916 | ✗ | tmp_format = AV_PIX_FMT_BGRA64; | |
917 | } else { | ||
918 | ✗ | tmp_format = AV_PIX_FMT_BGR48; | |
919 | } | ||
920 | } else { | ||
921 |
1/4✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
|
1 | if (isALPHA(sws->src_format) && isALPHA(sws->dst_format)) { |
922 | ✗ | tmp_format = AV_PIX_FMT_BGRA; | |
923 | } else { | ||
924 | 1 | tmp_format = AV_PIX_FMT_BGR24; | |
925 | } | ||
926 | } | ||
927 | |||
928 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
|
1 | if (srcW*srcH > dstW*dstH) { |
929 | ✗ | tmp_width = dstW; | |
930 | ✗ | tmp_height = dstH; | |
931 | } else { | ||
932 | 1 | tmp_width = srcW; | |
933 | 1 | tmp_height = srcH; | |
934 | } | ||
935 | |||
936 | 1 | ret = av_image_alloc(c->cascaded_tmp[0], c->cascaded_tmpStride[0], | |
937 | tmp_width, tmp_height, tmp_format, 64); | ||
938 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
|
1 | if (ret < 0) |
939 | ✗ | return ret; | |
940 | |||
941 | 2 | c->cascaded_context[0] = alloc_set_opts(srcW, srcH, sws->src_format, | |
942 | tmp_width, tmp_height, tmp_format, | ||
943 | 1 | sws->flags, sws->scaler_params); | |
944 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
|
1 | if (!c->cascaded_context[0]) |
945 | ✗ | return -1; | |
946 | |||
947 | 1 | c->cascaded_context[0]->alpha_blend = sws->alpha_blend; | |
948 | 1 | ret = sws_init_context(c->cascaded_context[0], NULL , NULL); | |
949 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
|
1 | if (ret < 0) |
950 | ✗ | return ret; | |
951 | //we set both src and dst depending on that the RGB side will be ignored | ||
952 | 1 | sws_setColorspaceDetails(c->cascaded_context[0], inv_table, | |
953 | srcRange, table, dstRange, | ||
954 | brightness, contrast, saturation); | ||
955 | |||
956 | 2 | c->cascaded_context[1] = alloc_set_opts(tmp_width, tmp_height, tmp_format, | |
957 | 1 | dstW, dstH, sws->dst_format, | |
958 | 1 | sws->flags, sws->scaler_params); | |
959 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
|
1 | if (!c->cascaded_context[1]) |
960 | ✗ | return -1; | |
961 | 1 | c->cascaded_context[1]->src_range = srcRange; | |
962 | 1 | c->cascaded_context[1]->dst_range = dstRange; | |
963 | 1 | ret = sws_init_context(c->cascaded_context[1], NULL , NULL); | |
964 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
|
1 | if (ret < 0) |
965 | ✗ | return ret; | |
966 | 1 | sws_setColorspaceDetails(c->cascaded_context[1], inv_table, | |
967 | srcRange, table, dstRange, | ||
968 | 0, 1 << 16, 1 << 16); | ||
969 | 1 | return 0; | |
970 | } | ||
971 | //We do not support this combination currently, we need to cascade more contexts to compensate | ||
972 |
1/4✗ Branch 0 not taken.
✓ Branch 1 taken 13362 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
|
13362 | if (c->cascaded_context[0] && memcmp(c->dstColorspaceTable, c->srcColorspaceTable, sizeof(int) * 4)) |
973 | ✗ | return -1; //AVERROR_PATCHWELCOME; | |
974 | 13362 | return 0; | |
975 | } | ||
976 | |||
977 |
4/4✓ Branch 1 taken 13712 times.
✓ Branch 2 taken 4863 times.
✓ Branch 4 taken 13292 times.
✓ Branch 5 taken 420 times.
|
18575 | if (!isYUV(sws->dst_format) && !isGray(sws->dst_format)) { |
978 | 13292 | ff_yuv2rgb_c_init_tables(c, inv_table, srcRange, brightness, | |
979 | contrast, saturation); | ||
980 | // FIXME factorize | ||
981 | |||
982 | #if ARCH_PPC | ||
983 | ff_yuv2rgb_init_tables_ppc(c, inv_table, brightness, | ||
984 | contrast, saturation); | ||
985 | #endif | ||
986 | } | ||
987 | |||
988 | 18575 | fill_rgb2yuv_table(c, table, dstRange); | |
989 | |||
990 | 18575 | return 0; | |
991 | } | ||
992 | |||
993 | 6166 | int sws_getColorspaceDetails(SwsContext *sws, int **inv_table, | |
994 | int *srcRange, int **table, int *dstRange, | ||
995 | int *brightness, int *contrast, int *saturation) | ||
996 | { | ||
997 | 6166 | SwsInternal *c = sws_internal(sws); | |
998 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 6166 times.
|
6166 | if (!c) |
999 | ✗ | return -1; | |
1000 | |||
1001 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 6166 times.
|
6166 | if (c->nb_slice_ctx) { |
1002 | ✗ | return sws_getColorspaceDetails(c->slice_ctx[0], inv_table, srcRange, | |
1003 | table, dstRange, brightness, contrast, | ||
1004 | saturation); | ||
1005 | } | ||
1006 | |||
1007 | 6166 | *inv_table = c->srcColorspaceTable; | |
1008 | 6166 | *table = c->dstColorspaceTable; | |
1009 |
2/2✓ Branch 1 taken 5076 times.
✓ Branch 2 taken 1090 times.
|
6166 | *srcRange = range_override_needed(sws->src_format) ? 1 : sws->src_range; |
1010 |
2/2✓ Branch 1 taken 4151 times.
✓ Branch 2 taken 2015 times.
|
6166 | *dstRange = range_override_needed(sws->dst_format) ? 1 : sws->dst_range; |
1011 | 6166 | *brightness = c->brightness; | |
1012 | 6166 | *contrast = c->contrast; | |
1013 | 6166 | *saturation = c->saturation; | |
1014 | |||
1015 | 6166 | return 0; | |
1016 | } | ||
1017 | |||
1018 | 42651 | SwsContext *sws_alloc_context(void) | |
1019 | { | ||
1020 | 42651 | SwsInternal *c = (SwsInternal *) av_mallocz(sizeof(SwsInternal)); | |
1021 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 42651 times.
|
42651 | if (!c) |
1022 | ✗ | return NULL; | |
1023 | |||
1024 | 42651 | c->opts.av_class = &ff_sws_context_class; | |
1025 | 42651 | av_opt_set_defaults(c); | |
1026 | 42651 | atomic_init(&c->stride_unaligned_warned, 0); | |
1027 | 42651 | atomic_init(&c->data_unaligned_warned, 0); | |
1028 | |||
1029 | 42651 | return &c->opts; | |
1030 | } | ||
1031 | |||
1032 | ✗ | static uint16_t * alloc_gamma_tbl(double e) | |
1033 | { | ||
1034 | ✗ | int i = 0; | |
1035 | uint16_t * tbl; | ||
1036 | ✗ | tbl = (uint16_t*)av_malloc(sizeof(uint16_t) * 1 << 16); | |
1037 | ✗ | if (!tbl) | |
1038 | ✗ | return NULL; | |
1039 | |||
1040 | ✗ | for (i = 0; i < 65536; ++i) { | |
1041 | ✗ | tbl[i] = pow(i / 65535.0, e) * 65535.0; | |
1042 | } | ||
1043 | ✗ | return tbl; | |
1044 | } | ||
1045 | |||
1046 | 1485 | static enum AVPixelFormat alphaless_fmt(enum AVPixelFormat fmt) | |
1047 | { | ||
1048 |
19/42✓ Branch 0 taken 12 times.
✓ Branch 1 taken 12 times.
✓ Branch 2 taken 2 times.
✓ Branch 3 taken 220 times.
✓ Branch 4 taken 20 times.
✓ Branch 5 taken 364 times.
✓ Branch 6 taken 3 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 51 times.
✓ Branch 9 taken 1 times.
✗ Branch 10 not taken.
✓ Branch 11 taken 1 times.
✗ Branch 12 not taken.
✗ Branch 13 not taken.
✗ Branch 14 not taken.
✓ Branch 15 taken 1 times.
✓ Branch 16 taken 10 times.
✓ Branch 17 taken 1 times.
✓ Branch 18 taken 10 times.
✓ Branch 19 taken 1 times.
✗ Branch 20 not taken.
✓ Branch 21 taken 20 times.
✗ Branch 22 not taken.
✗ Branch 23 not taken.
✗ Branch 24 not taken.
✗ Branch 25 not taken.
✗ Branch 26 not taken.
✗ Branch 27 not taken.
✗ Branch 28 not taken.
✗ Branch 29 not taken.
✗ Branch 30 not taken.
✗ Branch 31 not taken.
✗ Branch 32 not taken.
✗ Branch 33 not taken.
✗ Branch 34 not taken.
✗ Branch 35 not taken.
✗ Branch 36 not taken.
✗ Branch 37 not taken.
✗ Branch 38 not taken.
✓ Branch 39 taken 10 times.
✓ Branch 40 taken 4 times.
✓ Branch 41 taken 742 times.
|
1485 | switch(fmt) { |
1049 | 12 | case AV_PIX_FMT_ARGB: return AV_PIX_FMT_RGB24; | |
1050 | 12 | case AV_PIX_FMT_RGBA: return AV_PIX_FMT_RGB24; | |
1051 | 2 | case AV_PIX_FMT_ABGR: return AV_PIX_FMT_BGR24; | |
1052 | 220 | case AV_PIX_FMT_BGRA: return AV_PIX_FMT_BGR24; | |
1053 | 20 | case AV_PIX_FMT_YA8: return AV_PIX_FMT_GRAY8; | |
1054 | |||
1055 | 364 | case AV_PIX_FMT_YUVA420P: return AV_PIX_FMT_YUV420P; | |
1056 | 3 | case AV_PIX_FMT_YUVA422P: return AV_PIX_FMT_YUV422P; | |
1057 | ✗ | case AV_PIX_FMT_YUVA444P: return AV_PIX_FMT_YUV444P; | |
1058 | |||
1059 | 51 | case AV_PIX_FMT_GBRAP: return AV_PIX_FMT_GBRP; | |
1060 | |||
1061 | 1 | case AV_PIX_FMT_GBRAP10LE: return AV_PIX_FMT_GBRP10; | |
1062 | ✗ | case AV_PIX_FMT_GBRAP10BE: return AV_PIX_FMT_GBRP10; | |
1063 | |||
1064 | 1 | case AV_PIX_FMT_GBRAP12LE: return AV_PIX_FMT_GBRP12; | |
1065 | ✗ | case AV_PIX_FMT_GBRAP12BE: return AV_PIX_FMT_GBRP12; | |
1066 | |||
1067 | ✗ | case AV_PIX_FMT_GBRAP14LE: return AV_PIX_FMT_GBRP14; | |
1068 | ✗ | case AV_PIX_FMT_GBRAP14BE: return AV_PIX_FMT_GBRP14; | |
1069 | |||
1070 | 1 | case AV_PIX_FMT_GBRAP16LE: return AV_PIX_FMT_GBRP16; | |
1071 | 10 | case AV_PIX_FMT_GBRAP16BE: return AV_PIX_FMT_GBRP16; | |
1072 | |||
1073 | 1 | case AV_PIX_FMT_RGBA64LE: return AV_PIX_FMT_RGB48; | |
1074 | 10 | case AV_PIX_FMT_RGBA64BE: return AV_PIX_FMT_RGB48; | |
1075 | 1 | case AV_PIX_FMT_BGRA64LE: return AV_PIX_FMT_BGR48; | |
1076 | ✗ | case AV_PIX_FMT_BGRA64BE: return AV_PIX_FMT_BGR48; | |
1077 | |||
1078 | 20 | case AV_PIX_FMT_YA16BE: return AV_PIX_FMT_GRAY16; | |
1079 | ✗ | case AV_PIX_FMT_YA16LE: return AV_PIX_FMT_GRAY16; | |
1080 | |||
1081 | ✗ | case AV_PIX_FMT_YUVA420P9BE: return AV_PIX_FMT_YUV420P9; | |
1082 | ✗ | case AV_PIX_FMT_YUVA422P9BE: return AV_PIX_FMT_YUV422P9; | |
1083 | ✗ | case AV_PIX_FMT_YUVA444P9BE: return AV_PIX_FMT_YUV444P9; | |
1084 | ✗ | case AV_PIX_FMT_YUVA420P9LE: return AV_PIX_FMT_YUV420P9; | |
1085 | ✗ | case AV_PIX_FMT_YUVA422P9LE: return AV_PIX_FMT_YUV422P9; | |
1086 | ✗ | case AV_PIX_FMT_YUVA444P9LE: return AV_PIX_FMT_YUV444P9; | |
1087 | ✗ | case AV_PIX_FMT_YUVA420P10BE: return AV_PIX_FMT_YUV420P10; | |
1088 | ✗ | case AV_PIX_FMT_YUVA422P10BE: return AV_PIX_FMT_YUV422P10; | |
1089 | ✗ | case AV_PIX_FMT_YUVA444P10BE: return AV_PIX_FMT_YUV444P10; | |
1090 | ✗ | case AV_PIX_FMT_YUVA420P10LE: return AV_PIX_FMT_YUV420P10; | |
1091 | ✗ | case AV_PIX_FMT_YUVA422P10LE: return AV_PIX_FMT_YUV422P10; | |
1092 | ✗ | case AV_PIX_FMT_YUVA444P10LE: return AV_PIX_FMT_YUV444P10; | |
1093 | ✗ | case AV_PIX_FMT_YUVA420P16BE: return AV_PIX_FMT_YUV420P16; | |
1094 | ✗ | case AV_PIX_FMT_YUVA422P16BE: return AV_PIX_FMT_YUV422P16; | |
1095 | ✗ | case AV_PIX_FMT_YUVA444P16BE: return AV_PIX_FMT_YUV444P16; | |
1096 | ✗ | case AV_PIX_FMT_YUVA420P16LE: return AV_PIX_FMT_YUV420P16; | |
1097 | 10 | case AV_PIX_FMT_YUVA422P16LE: return AV_PIX_FMT_YUV422P16; | |
1098 | 4 | case AV_PIX_FMT_YUVA444P16LE: return AV_PIX_FMT_YUV444P16; | |
1099 | |||
1100 | // case AV_PIX_FMT_AYUV64LE: | ||
1101 | // case AV_PIX_FMT_AYUV64BE: | ||
1102 | // case AV_PIX_FMT_PAL8: | ||
1103 | 742 | default: return AV_PIX_FMT_NONE; | |
1104 | } | ||
1105 | } | ||
1106 | |||
1107 | 31796 | av_cold int ff_sws_init_single_context(SwsContext *sws, SwsFilter *srcFilter, | |
1108 | SwsFilter *dstFilter) | ||
1109 | { | ||
1110 | int i; | ||
1111 | int usesVFilter, usesHFilter; | ||
1112 | int unscaled; | ||
1113 | 31796 | SwsInternal *c = sws_internal(sws); | |
1114 | 31796 | SwsFilter dummyFilter = { NULL, NULL, NULL, NULL }; | |
1115 | 31796 | int srcW = sws->src_w; | |
1116 | 31796 | int srcH = sws->src_h; | |
1117 | 31796 | int dstW = sws->dst_w; | |
1118 | 31796 | int dstH = sws->dst_h; | |
1119 | 31796 | int dst_stride = FFALIGN(dstW * sizeof(int16_t) + 66, 16); | |
1120 | int flags, cpu_flags; | ||
1121 | enum AVPixelFormat srcFormat, dstFormat; | ||
1122 | const AVPixFmtDescriptor *desc_src; | ||
1123 | const AVPixFmtDescriptor *desc_dst; | ||
1124 | 31796 | int ret = 0; | |
1125 | enum AVPixelFormat tmpFmt; | ||
1126 | static const float float_mult = 1.0f / 255.0f; | ||
1127 | |||
1128 | 31796 | cpu_flags = av_get_cpu_flags(); | |
1129 | 31796 | flags = sws->flags; | |
1130 | 31796 | emms_c(); | |
1131 | |||
1132 |
4/4✓ Branch 0 taken 30925 times.
✓ Branch 1 taken 871 times.
✓ Branch 2 taken 30826 times.
✓ Branch 3 taken 99 times.
|
31796 | unscaled = (srcW == dstW && srcH == dstH); |
1133 | |||
1134 |
3/6✓ Branch 0 taken 31796 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 31796 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 31796 times.
✗ Branch 5 not taken.
|
31796 | if (!c->contrast && !c->saturation && !c->dstFormatBpp) |
1135 | 31796 | sws_setColorspaceDetails(sws, ff_yuv2rgb_coeffs[SWS_CS_DEFAULT], sws->src_range, | |
1136 | ff_yuv2rgb_coeffs[SWS_CS_DEFAULT], | ||
1137 | sws->dst_range, 0, 1 << 16, 1 << 16); | ||
1138 | |||
1139 | 31796 | ret = handle_formats(sws); | |
1140 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 31796 times.
|
31796 | if (ret < 0) |
1141 | ✗ | return ret; | |
1142 | 31796 | srcFormat = sws->src_format; | |
1143 | 31796 | dstFormat = sws->dst_format; | |
1144 | 31796 | desc_src = av_pix_fmt_desc_get(srcFormat); | |
1145 | 31796 | desc_dst = av_pix_fmt_desc_get(dstFormat); | |
1146 | |||
1147 | // If the source has no alpha then disable alpha blendaway | ||
1148 |
2/2✓ Branch 0 taken 30 times.
✓ Branch 1 taken 31766 times.
|
31796 | if (c->src0Alpha) |
1149 | 30 | sws->alpha_blend = SWS_ALPHA_BLEND_NONE; | |
1150 | |||
1151 |
5/6✓ Branch 0 taken 30826 times.
✓ Branch 1 taken 970 times.
✓ Branch 3 taken 13 times.
✓ Branch 4 taken 30813 times.
✓ Branch 5 taken 13 times.
✗ Branch 6 not taken.
|
31809 | if (!(unscaled && sws_isSupportedEndiannessConversion(srcFormat) && |
1152 | 13 | av_pix_fmt_swap_endianness(srcFormat) == dstFormat)) { | |
1153 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 31796 times.
|
31796 | if (!sws_isSupportedInput(srcFormat)) { |
1154 | ✗ | av_log(c, AV_LOG_ERROR, "%s is not supported as input pixel format\n", | |
1155 | av_get_pix_fmt_name(srcFormat)); | ||
1156 | ✗ | return AVERROR(EINVAL); | |
1157 | } | ||
1158 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 31796 times.
|
31796 | if (!sws_isSupportedOutput(dstFormat)) { |
1159 | ✗ | av_log(c, AV_LOG_ERROR, "%s is not supported as output pixel format\n", | |
1160 | av_get_pix_fmt_name(dstFormat)); | ||
1161 | ✗ | return AVERROR(EINVAL); | |
1162 | } | ||
1163 | } | ||
1164 | av_assert2(desc_src && desc_dst); | ||
1165 | |||
1166 | 31796 | i = flags & (SWS_POINT | | |
1167 | SWS_AREA | | ||
1168 | SWS_BILINEAR | | ||
1169 | SWS_FAST_BILINEAR | | ||
1170 | SWS_BICUBIC | | ||
1171 | SWS_X | | ||
1172 | SWS_GAUSS | | ||
1173 | SWS_LANCZOS | | ||
1174 | SWS_SINC | | ||
1175 | SWS_SPLINE | | ||
1176 | SWS_BICUBLIN); | ||
1177 | |||
1178 | /* provide a default scaler if not set by caller */ | ||
1179 |
2/2✓ Branch 0 taken 3084 times.
✓ Branch 1 taken 28712 times.
|
31796 | if (!i) { |
1180 |
3/4✓ Branch 0 taken 2 times.
✓ Branch 1 taken 3082 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 2 times.
|
3084 | if (dstW < srcW && dstH < srcH) |
1181 | ✗ | flags |= SWS_BICUBIC; | |
1182 |
1/4✗ Branch 0 not taken.
✓ Branch 1 taken 3084 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
|
3084 | else if (dstW > srcW && dstH > srcH) |
1183 | ✗ | flags |= SWS_BICUBIC; | |
1184 | else | ||
1185 | 3084 | flags |= SWS_BICUBIC; | |
1186 | 3084 | sws->flags = flags; | |
1187 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 28712 times.
|
28712 | } else if (i & (i - 1)) { |
1188 | ✗ | av_log(c, AV_LOG_ERROR, | |
1189 | "Exactly one scaler algorithm must be chosen, got %X\n", i); | ||
1190 | ✗ | return AVERROR(EINVAL); | |
1191 | } | ||
1192 | /* sanity check */ | ||
1193 |
4/8✓ Branch 0 taken 31796 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 31796 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 31796 times.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✓ Branch 7 taken 31796 times.
|
31796 | if (srcW < 1 || srcH < 1 || dstW < 1 || dstH < 1) { |
1194 | /* FIXME check if these are enough and try to lower them after | ||
1195 | * fixing the relevant parts of the code */ | ||
1196 | ✗ | av_log(c, AV_LOG_ERROR, "%dx%d -> %dx%d is invalid scaling dimension\n", | |
1197 | srcW, srcH, dstW, dstH); | ||
1198 | ✗ | return AVERROR(EINVAL); | |
1199 | } | ||
1200 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 31796 times.
|
31796 | if (flags & SWS_FAST_BILINEAR) { |
1201 | ✗ | if (srcW < 8 || dstW < 8) { | |
1202 | ✗ | flags ^= SWS_FAST_BILINEAR | SWS_BILINEAR; | |
1203 | ✗ | sws->flags = flags; | |
1204 | } | ||
1205 | } | ||
1206 | |||
1207 |
1/2✓ Branch 0 taken 31796 times.
✗ Branch 1 not taken.
|
31796 | if (!dstFilter) |
1208 | 31796 | dstFilter = &dummyFilter; | |
1209 |
1/2✓ Branch 0 taken 31796 times.
✗ Branch 1 not taken.
|
31796 | if (!srcFilter) |
1210 | 31796 | srcFilter = &dummyFilter; | |
1211 | |||
1212 | 31796 | c->lumXInc = (((int64_t)srcW << 16) + (dstW >> 1)) / dstW; | |
1213 | 31796 | c->lumYInc = (((int64_t)srcH << 16) + (dstH >> 1)) / dstH; | |
1214 | 31796 | c->dstFormatBpp = av_get_bits_per_pixel(desc_dst); | |
1215 | 31796 | c->srcFormatBpp = av_get_bits_per_pixel(desc_src); | |
1216 | 31796 | c->vRounder = 4 * 0x0001000100010001ULL; | |
1217 | |||
1218 | ✗ | usesVFilter = (srcFilter->lumV && srcFilter->lumV->length > 1) || | |
1219 |
1/4✗ Branch 0 not taken.
✓ Branch 1 taken 31796 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
|
31796 | (srcFilter->chrV && srcFilter->chrV->length > 1) || |
1220 |
2/6✗ Branch 0 not taken.
✓ Branch 1 taken 31796 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 31796 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
|
95388 | (dstFilter->lumV && dstFilter->lumV->length > 1) || |
1221 |
1/4✗ Branch 0 not taken.
✓ Branch 1 taken 31796 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
|
31796 | (dstFilter->chrV && dstFilter->chrV->length > 1); |
1222 | ✗ | usesHFilter = (srcFilter->lumH && srcFilter->lumH->length > 1) || | |
1223 |
1/4✗ Branch 0 not taken.
✓ Branch 1 taken 31796 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
|
31796 | (srcFilter->chrH && srcFilter->chrH->length > 1) || |
1224 |
2/6✗ Branch 0 not taken.
✓ Branch 1 taken 31796 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 31796 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
|
95388 | (dstFilter->lumH && dstFilter->lumH->length > 1) || |
1225 |
1/4✗ Branch 0 not taken.
✓ Branch 1 taken 31796 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
|
31796 | (dstFilter->chrH && dstFilter->chrH->length > 1); |
1226 | |||
1227 | 31796 | av_pix_fmt_get_chroma_sub_sample(srcFormat, &c->chrSrcHSubSample, &c->chrSrcVSubSample); | |
1228 | 31796 | av_pix_fmt_get_chroma_sub_sample(dstFormat, &c->chrDstHSubSample, &c->chrDstVSubSample); | |
1229 | |||
1230 | 31796 | c->dst_slice_align = 1 << c->chrDstVSubSample; | |
1231 | |||
1232 |
4/4✓ Branch 1 taken 13281 times.
✓ Branch 2 taken 18515 times.
✓ Branch 3 taken 6418 times.
✓ Branch 4 taken 6863 times.
|
31796 | if (isAnyRGB(dstFormat) && !(flags&SWS_FULL_CHR_H_INT)) { |
1233 |
2/2✓ Branch 0 taken 49 times.
✓ Branch 1 taken 6369 times.
|
6418 | if (dstW&1) { |
1234 | 49 | av_log(c, AV_LOG_DEBUG, "Forcing full internal H chroma due to odd output size\n"); | |
1235 | 49 | flags |= SWS_FULL_CHR_H_INT; | |
1236 | 49 | sws->flags = flags; | |
1237 | } | ||
1238 | |||
1239 |
2/2✓ Branch 0 taken 1330 times.
✓ Branch 1 taken 5088 times.
|
6418 | if ( c->chrSrcHSubSample == 0 |
1240 |
2/2✓ Branch 0 taken 1192 times.
✓ Branch 1 taken 138 times.
|
1330 | && c->chrSrcVSubSample == 0 |
1241 |
1/2✓ Branch 0 taken 1192 times.
✗ Branch 1 not taken.
|
1192 | && sws->dither != SWS_DITHER_BAYER //SWS_FULL_CHR_H_INT is currently not supported with SWS_DITHER_BAYER |
1242 |
1/2✓ Branch 0 taken 1192 times.
✗ Branch 1 not taken.
|
1192 | && !(sws->flags & SWS_FAST_BILINEAR) |
1243 | ) { | ||
1244 | 1192 | av_log(c, AV_LOG_DEBUG, "Forcing full internal H chroma due to input having non subsampled chroma\n"); | |
1245 | 1192 | flags |= SWS_FULL_CHR_H_INT; | |
1246 | 1192 | sws->flags = flags; | |
1247 | } | ||
1248 | } | ||
1249 | |||
1250 |
2/2✓ Branch 0 taken 21316 times.
✓ Branch 1 taken 10480 times.
|
31796 | if (sws->dither == SWS_DITHER_AUTO) { |
1251 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 21316 times.
|
21316 | if (flags & SWS_ERROR_DIFFUSION) |
1252 | ✗ | sws->dither = SWS_DITHER_ED; | |
1253 | } | ||
1254 | |||
1255 |
4/4✓ Branch 0 taken 31743 times.
✓ Branch 1 taken 53 times.
✓ Branch 2 taken 31689 times.
✓ Branch 3 taken 54 times.
|
31796 | if(dstFormat == AV_PIX_FMT_BGR4_BYTE || |
1256 |
2/2✓ Branch 0 taken 31619 times.
✓ Branch 1 taken 70 times.
|
31689 | dstFormat == AV_PIX_FMT_RGB4_BYTE || |
1257 |
2/2✓ Branch 0 taken 56 times.
✓ Branch 1 taken 31563 times.
|
31619 | dstFormat == AV_PIX_FMT_BGR8 || |
1258 | dstFormat == AV_PIX_FMT_RGB8) { | ||
1259 |
1/2✓ Branch 0 taken 233 times.
✗ Branch 1 not taken.
|
233 | if (sws->dither == SWS_DITHER_AUTO) |
1260 |
2/2✓ Branch 0 taken 11 times.
✓ Branch 1 taken 222 times.
|
233 | sws->dither = (flags & SWS_FULL_CHR_H_INT) ? SWS_DITHER_ED : SWS_DITHER_BAYER; |
1261 |
2/2✓ Branch 0 taken 222 times.
✓ Branch 1 taken 11 times.
|
233 | if (!(flags & SWS_FULL_CHR_H_INT)) { |
1262 |
4/8✓ Branch 0 taken 222 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 222 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 222 times.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✓ Branch 7 taken 222 times.
|
222 | if (sws->dither == SWS_DITHER_ED || sws->dither == SWS_DITHER_A_DITHER || sws->dither == SWS_DITHER_X_DITHER || sws->dither == SWS_DITHER_NONE) { |
1263 | ✗ | av_log(c, AV_LOG_DEBUG, | |
1264 | "Desired dithering only supported in full chroma interpolation for destination format '%s'\n", | ||
1265 | av_get_pix_fmt_name(dstFormat)); | ||
1266 | ✗ | flags |= SWS_FULL_CHR_H_INT; | |
1267 | ✗ | sws->flags = flags; | |
1268 | } | ||
1269 | } | ||
1270 |
2/2✓ Branch 0 taken 11 times.
✓ Branch 1 taken 222 times.
|
233 | if (flags & SWS_FULL_CHR_H_INT) { |
1271 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 11 times.
|
11 | if (sws->dither == SWS_DITHER_BAYER) { |
1272 | ✗ | av_log(c, AV_LOG_DEBUG, | |
1273 | "Ordered dither is not supported in full chroma interpolation for destination format '%s'\n", | ||
1274 | av_get_pix_fmt_name(dstFormat)); | ||
1275 | ✗ | sws->dither = SWS_DITHER_ED; | |
1276 | } | ||
1277 | } | ||
1278 | } | ||
1279 |
2/2✓ Branch 1 taken 4828 times.
✓ Branch 2 taken 26968 times.
|
31796 | if (isPlanarRGB(dstFormat)) { |
1280 |
2/2✓ Branch 0 taken 642 times.
✓ Branch 1 taken 4186 times.
|
4828 | if (!(flags & SWS_FULL_CHR_H_INT)) { |
1281 | 642 | av_log(c, AV_LOG_DEBUG, | |
1282 | "%s output is not supported with half chroma resolution, switching to full\n", | ||
1283 | av_get_pix_fmt_name(dstFormat)); | ||
1284 | 642 | flags |= SWS_FULL_CHR_H_INT; | |
1285 | 642 | sws->flags = flags; | |
1286 | } | ||
1287 | } | ||
1288 | |||
1289 | /* reuse chroma for 2 pixels RGB/BGR unless user wants full | ||
1290 | * chroma interpolation */ | ||
1291 |
3/4✓ Branch 0 taken 8701 times.
✓ Branch 1 taken 23095 times.
✓ Branch 2 taken 8701 times.
✗ Branch 3 not taken.
|
40497 | if (flags & SWS_FULL_CHR_H_INT && |
1292 |
2/2✓ Branch 1 taken 3873 times.
✓ Branch 2 taken 4828 times.
|
17402 | isAnyRGB(dstFormat) && |
1293 |
2/2✓ Branch 1 taken 3871 times.
✓ Branch 2 taken 2 times.
|
12574 | !isPlanarRGB(dstFormat) && |
1294 |
2/2✓ Branch 0 taken 3870 times.
✓ Branch 1 taken 1 times.
|
3871 | dstFormat != AV_PIX_FMT_RGBA64LE && |
1295 |
2/2✓ Branch 0 taken 3868 times.
✓ Branch 1 taken 2 times.
|
3870 | dstFormat != AV_PIX_FMT_RGBA64BE && |
1296 |
2/2✓ Branch 0 taken 3867 times.
✓ Branch 1 taken 1 times.
|
3868 | dstFormat != AV_PIX_FMT_BGRA64LE && |
1297 |
2/2✓ Branch 0 taken 3153 times.
✓ Branch 1 taken 714 times.
|
3867 | dstFormat != AV_PIX_FMT_BGRA64BE && |
1298 |
2/2✓ Branch 0 taken 3150 times.
✓ Branch 1 taken 3 times.
|
3153 | dstFormat != AV_PIX_FMT_RGB48LE && |
1299 |
2/2✓ Branch 0 taken 3148 times.
✓ Branch 1 taken 2 times.
|
3150 | dstFormat != AV_PIX_FMT_RGB48BE && |
1300 |
2/2✓ Branch 0 taken 3147 times.
✓ Branch 1 taken 1 times.
|
3148 | dstFormat != AV_PIX_FMT_BGR48LE && |
1301 |
2/2✓ Branch 0 taken 3094 times.
✓ Branch 1 taken 53 times.
|
3147 | dstFormat != AV_PIX_FMT_BGR48BE && |
1302 |
2/2✓ Branch 0 taken 3080 times.
✓ Branch 1 taken 14 times.
|
3094 | dstFormat != AV_PIX_FMT_RGBA && |
1303 |
2/2✓ Branch 0 taken 2540 times.
✓ Branch 1 taken 540 times.
|
3080 | dstFormat != AV_PIX_FMT_ARGB && |
1304 |
2/2✓ Branch 0 taken 2536 times.
✓ Branch 1 taken 4 times.
|
2540 | dstFormat != AV_PIX_FMT_BGRA && |
1305 |
2/2✓ Branch 0 taken 827 times.
✓ Branch 1 taken 1709 times.
|
2536 | dstFormat != AV_PIX_FMT_ABGR && |
1306 |
2/2✓ Branch 0 taken 687 times.
✓ Branch 1 taken 140 times.
|
827 | dstFormat != AV_PIX_FMT_RGB24 && |
1307 |
2/2✓ Branch 0 taken 685 times.
✓ Branch 1 taken 2 times.
|
687 | dstFormat != AV_PIX_FMT_BGR24 && |
1308 |
2/2✓ Branch 0 taken 683 times.
✓ Branch 1 taken 2 times.
|
685 | dstFormat != AV_PIX_FMT_BGR4_BYTE && |
1309 |
2/2✓ Branch 0 taken 679 times.
✓ Branch 1 taken 4 times.
|
683 | dstFormat != AV_PIX_FMT_RGB4_BYTE && |
1310 |
2/2✓ Branch 0 taken 676 times.
✓ Branch 1 taken 3 times.
|
679 | dstFormat != AV_PIX_FMT_BGR8 && |
1311 |
2/2✓ Branch 0 taken 565 times.
✓ Branch 1 taken 111 times.
|
676 | dstFormat != AV_PIX_FMT_RGB8 && |
1312 |
2/2✓ Branch 0 taken 454 times.
✓ Branch 1 taken 111 times.
|
565 | dstFormat != AV_PIX_FMT_X2RGB10LE && |
1313 | dstFormat != AV_PIX_FMT_X2BGR10LE | ||
1314 | ) { | ||
1315 | 454 | av_log(c, AV_LOG_WARNING, | |
1316 | "full chroma interpolation for destination format '%s' not yet implemented\n", | ||
1317 | av_get_pix_fmt_name(dstFormat)); | ||
1318 | 454 | flags &= ~SWS_FULL_CHR_H_INT; | |
1319 | 454 | sws->flags = flags; | |
1320 | } | ||
1321 |
4/4✓ Branch 1 taken 13281 times.
✓ Branch 2 taken 18515 times.
✓ Branch 3 taken 5034 times.
✓ Branch 4 taken 8247 times.
|
31796 | if (isAnyRGB(dstFormat) && !(flags & SWS_FULL_CHR_H_INT)) |
1322 | 5034 | c->chrDstHSubSample = 1; | |
1323 | |||
1324 | // drop some chroma lines if the user wants it | ||
1325 | 31796 | c->vChrDrop = (flags & SWS_SRC_V_CHR_DROP_MASK) >> | |
1326 | SWS_SRC_V_CHR_DROP_SHIFT; | ||
1327 | 31796 | c->chrSrcVSubSample += c->vChrDrop; | |
1328 | |||
1329 | /* drop every other pixel for chroma calculation unless user | ||
1330 | * wants full chroma */ | ||
1331 |
7/8✓ Branch 1 taken 8333 times.
✓ Branch 2 taken 23463 times.
✓ Branch 3 taken 7979 times.
✓ Branch 4 taken 354 times.
✓ Branch 5 taken 7979 times.
✗ Branch 6 not taken.
✓ Branch 7 taken 7978 times.
✓ Branch 8 taken 1 times.
|
31796 | if (isAnyRGB(srcFormat) && !(srcW & 1) && !(flags & SWS_FULL_CHR_H_INP) && |
1332 |
3/4✓ Branch 0 taken 7977 times.
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 7977 times.
✗ Branch 3 not taken.
|
7978 | srcFormat != AV_PIX_FMT_RGB8 && srcFormat != AV_PIX_FMT_BGR8 && |
1333 |
3/4✓ Branch 0 taken 7977 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 7976 times.
✓ Branch 3 taken 1 times.
|
7977 | srcFormat != AV_PIX_FMT_RGB4 && srcFormat != AV_PIX_FMT_BGR4 && |
1334 |
4/4✓ Branch 0 taken 7975 times.
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 7974 times.
✓ Branch 3 taken 1 times.
|
7976 | srcFormat != AV_PIX_FMT_RGB4_BYTE && srcFormat != AV_PIX_FMT_BGR4_BYTE && |
1335 |
4/4✓ Branch 0 taken 7972 times.
✓ Branch 1 taken 2 times.
✓ Branch 2 taken 7861 times.
✓ Branch 3 taken 111 times.
|
7974 | srcFormat != AV_PIX_FMT_GBRP9BE && srcFormat != AV_PIX_FMT_GBRP9LE && |
1336 |
4/4✓ Branch 0 taken 6844 times.
✓ Branch 1 taken 1017 times.
✓ Branch 2 taken 6843 times.
✓ Branch 3 taken 1 times.
|
7861 | srcFormat != AV_PIX_FMT_GBRP10BE && srcFormat != AV_PIX_FMT_GBRP10LE && |
1337 |
4/4✓ Branch 0 taken 6841 times.
✓ Branch 1 taken 2 times.
✓ Branch 2 taken 6730 times.
✓ Branch 3 taken 111 times.
|
6843 | srcFormat != AV_PIX_FMT_GBRAP10BE && srcFormat != AV_PIX_FMT_GBRAP10LE && |
1338 |
4/4✓ Branch 0 taken 5728 times.
✓ Branch 1 taken 1002 times.
✓ Branch 2 taken 5727 times.
✓ Branch 3 taken 1 times.
|
6730 | srcFormat != AV_PIX_FMT_GBRP12BE && srcFormat != AV_PIX_FMT_GBRP12LE && |
1339 |
4/4✓ Branch 0 taken 5725 times.
✓ Branch 1 taken 2 times.
✓ Branch 2 taken 5724 times.
✓ Branch 3 taken 1 times.
|
5727 | srcFormat != AV_PIX_FMT_GBRAP12BE && srcFormat != AV_PIX_FMT_GBRAP12LE && |
1340 |
4/4✓ Branch 0 taken 5723 times.
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 5722 times.
✓ Branch 3 taken 1 times.
|
5724 | srcFormat != AV_PIX_FMT_GBRAP14BE && srcFormat != AV_PIX_FMT_GBRAP14LE && |
1341 |
4/4✓ Branch 0 taken 5720 times.
✓ Branch 1 taken 2 times.
✓ Branch 2 taken 5569 times.
✓ Branch 3 taken 151 times.
|
5722 | srcFormat != AV_PIX_FMT_GBRP14BE && srcFormat != AV_PIX_FMT_GBRP14LE && |
1342 |
4/4✓ Branch 0 taken 5241 times.
✓ Branch 1 taken 328 times.
✓ Branch 2 taken 5230 times.
✓ Branch 3 taken 11 times.
|
5569 | srcFormat != AV_PIX_FMT_GBRP16BE && srcFormat != AV_PIX_FMT_GBRP16LE && |
1343 |
4/4✓ Branch 0 taken 5226 times.
✓ Branch 1 taken 4 times.
✓ Branch 2 taken 5225 times.
✓ Branch 3 taken 1 times.
|
5230 | srcFormat != AV_PIX_FMT_GBRAP16BE && srcFormat != AV_PIX_FMT_GBRAP16LE && |
1344 |
4/4✓ Branch 0 taken 5193 times.
✓ Branch 1 taken 32 times.
✓ Branch 2 taken 5192 times.
✓ Branch 3 taken 1 times.
|
5225 | srcFormat != AV_PIX_FMT_GBRPF32BE && srcFormat != AV_PIX_FMT_GBRPF32LE && |
1345 |
3/4✓ Branch 0 taken 5191 times.
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 5191 times.
✗ Branch 3 not taken.
|
5192 | srcFormat != AV_PIX_FMT_GBRAPF32BE && srcFormat != AV_PIX_FMT_GBRAPF32LE && |
1346 |
3/4✓ Branch 0 taken 4972 times.
✓ Branch 1 taken 219 times.
✓ Branch 2 taken 4972 times.
✗ Branch 3 not taken.
|
5191 | srcFormat != AV_PIX_FMT_GBRPF16BE && srcFormat != AV_PIX_FMT_GBRPF16LE && |
1347 |
2/2✓ Branch 0 taken 4927 times.
✓ Branch 1 taken 45 times.
|
4972 | srcFormat != AV_PIX_FMT_GBRAPF16BE && srcFormat != AV_PIX_FMT_GBRAPF16LE && |
1348 |
2/2✓ Branch 0 taken 3432 times.
✓ Branch 1 taken 1495 times.
|
4927 | ((dstW >> c->chrDstHSubSample) <= (srcW >> 1) || |
1349 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 3432 times.
|
3432 | (flags & SWS_FAST_BILINEAR))) |
1350 | 1495 | c->chrSrcHSubSample = 1; | |
1351 | |||
1352 | // Note the AV_CEIL_RSHIFT is so that we always round toward +inf. | ||
1353 | 31796 | c->chrSrcW = AV_CEIL_RSHIFT(srcW, c->chrSrcHSubSample); | |
1354 | 31796 | c->chrSrcH = AV_CEIL_RSHIFT(srcH, c->chrSrcVSubSample); | |
1355 | 31796 | c->chrDstW = AV_CEIL_RSHIFT(dstW, c->chrDstHSubSample); | |
1356 | 31796 | c->chrDstH = AV_CEIL_RSHIFT(dstH, c->chrDstVSubSample); | |
1357 | |||
1358 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 31796 times.
|
31796 | if (!FF_ALLOCZ_TYPED_ARRAY(c->formatConvBuffer, FFALIGN(srcW * 2 + 78, 16) * 2)) |
1359 | ✗ | goto nomem; | |
1360 | |||
1361 | 31796 | c->srcBpc = desc_src->comp[0].depth; | |
1362 |
2/2✓ Branch 0 taken 635 times.
✓ Branch 1 taken 31161 times.
|
31796 | if (c->srcBpc < 8) |
1363 | 635 | c->srcBpc = 8; | |
1364 | 31796 | c->dstBpc = desc_dst->comp[0].depth; | |
1365 |
2/2✓ Branch 0 taken 2064 times.
✓ Branch 1 taken 29732 times.
|
31796 | if (c->dstBpc < 8) |
1366 | 2064 | c->dstBpc = 8; | |
1367 |
4/4✓ Branch 1 taken 23463 times.
✓ Branch 2 taken 8333 times.
✓ Branch 3 taken 827 times.
✓ Branch 4 taken 22636 times.
|
31796 | if (isAnyRGB(srcFormat) || srcFormat == AV_PIX_FMT_PAL8) |
1368 | 9160 | c->srcBpc = 16; | |
1369 |
2/2✓ Branch 0 taken 5377 times.
✓ Branch 1 taken 26419 times.
|
31796 | if (c->dstBpc == 16) |
1370 | 5377 | dst_stride <<= 1; | |
1371 | |||
1372 |
6/6✓ Branch 0 taken 2854 times.
✓ Branch 1 taken 28942 times.
✓ Branch 2 taken 2762 times.
✓ Branch 3 taken 92 times.
✓ Branch 4 taken 2497 times.
✓ Branch 5 taken 265 times.
|
31796 | if (INLINE_MMXEXT(cpu_flags) && c->srcBpc == 8 && c->dstBpc <= 14) { |
1373 |
2/2✓ Branch 0 taken 1562 times.
✓ Branch 1 taken 935 times.
|
2497 | c->canMMXEXTBeUsed = dstW >= srcW && (dstW & 31) == 0 && |
1374 |
3/4✓ Branch 0 taken 2497 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1518 times.
✓ Branch 3 taken 44 times.
|
6512 | c->chrDstW >= c->chrSrcW && |
1375 |
1/2✓ Branch 0 taken 1518 times.
✗ Branch 1 not taken.
|
1518 | (srcW & 15) == 0; |
1376 |
7/8✓ Branch 0 taken 979 times.
✓ Branch 1 taken 1518 times.
✓ Branch 2 taken 979 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 891 times.
✓ Branch 5 taken 88 times.
✓ Branch 6 taken 165 times.
✓ Branch 7 taken 726 times.
|
2497 | if (!c->canMMXEXTBeUsed && dstW >= srcW && c->chrDstW >= c->chrSrcW && (srcW & 15) == 0 |
1377 | |||
1378 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 165 times.
|
165 | && (flags & SWS_FAST_BILINEAR)) { |
1379 | ✗ | if (flags & SWS_PRINT_INFO) | |
1380 | ✗ | av_log(c, AV_LOG_INFO, | |
1381 | "output width is not a multiple of 32 -> no MMXEXT scaler\n"); | ||
1382 | } | ||
1383 |
4/8✓ Branch 0 taken 2497 times.
✗ Branch 1 not taken.
✓ Branch 3 taken 2497 times.
✗ Branch 4 not taken.
✓ Branch 6 taken 2497 times.
✗ Branch 7 not taken.
✗ Branch 9 not taken.
✓ Branch 10 taken 2497 times.
|
2497 | if (usesHFilter || isNBPS(sws->src_format) || is16BPS(sws->src_format) || isAnyRGB(sws->src_format)) |
1384 | ✗ | c->canMMXEXTBeUsed = 0; | |
1385 | } else | ||
1386 | 29299 | c->canMMXEXTBeUsed = 0; | |
1387 | |||
1388 | 31796 | c->chrXInc = (((int64_t)c->chrSrcW << 16) + (c->chrDstW >> 1)) / c->chrDstW; | |
1389 | 31796 | c->chrYInc = (((int64_t)c->chrSrcH << 16) + (c->chrDstH >> 1)) / c->chrDstH; | |
1390 | |||
1391 | /* Match pixel 0 of the src to pixel 0 of dst and match pixel n-2 of src | ||
1392 | * to pixel n-2 of dst, but only for the FAST_BILINEAR mode otherwise do | ||
1393 | * correct scaling. | ||
1394 | * n-2 is the last chrominance sample available. | ||
1395 | * This is not perfect, but no one should notice the difference, the more | ||
1396 | * correct variant would be like the vertical one, but that would require | ||
1397 | * some special code for the first and last pixel */ | ||
1398 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 31796 times.
|
31796 | if (flags & SWS_FAST_BILINEAR) { |
1399 | ✗ | if (c->canMMXEXTBeUsed) { | |
1400 | ✗ | c->lumXInc += 20; | |
1401 | ✗ | c->chrXInc += 20; | |
1402 | } | ||
1403 | // we don't use the x86 asm scaler if MMX is available | ||
1404 | ✗ | else if (INLINE_MMX(cpu_flags) && c->dstBpc <= 14) { | |
1405 | ✗ | c->lumXInc = ((int64_t)(srcW - 2) << 16) / (dstW - 2) - 20; | |
1406 | ✗ | c->chrXInc = ((int64_t)(c->chrSrcW - 2) << 16) / (c->chrDstW - 2) - 20; | |
1407 | } | ||
1408 | } | ||
1409 | |||
1410 | // hardcoded for now | ||
1411 | 31796 | c->gamma_value = 2.2; | |
1412 | 31796 | tmpFmt = AV_PIX_FMT_RGBA64LE; | |
1413 | |||
1414 |
3/8✓ Branch 0 taken 970 times.
✓ Branch 1 taken 30826 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 970 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
|
31796 | if (!unscaled && sws->gamma_flag && (srcFormat != tmpFmt || dstFormat != tmpFmt)) { |
1415 | SwsInternal *c2; | ||
1416 | ✗ | c->cascaded_context[0] = NULL; | |
1417 | |||
1418 | ✗ | ret = av_image_alloc(c->cascaded_tmp[0], c->cascaded_tmpStride[0], | |
1419 | srcW, srcH, tmpFmt, 64); | ||
1420 | ✗ | if (ret < 0) | |
1421 | ✗ | return ret; | |
1422 | |||
1423 | ✗ | c->cascaded_context[0] = sws_getContext(srcW, srcH, srcFormat, | |
1424 | srcW, srcH, tmpFmt, | ||
1425 | flags, NULL, NULL, | ||
1426 | ✗ | sws->scaler_params); | |
1427 | ✗ | if (!c->cascaded_context[0]) { | |
1428 | ✗ | return AVERROR(ENOMEM); | |
1429 | } | ||
1430 | |||
1431 | ✗ | c->cascaded_context[1] = sws_getContext(srcW, srcH, tmpFmt, | |
1432 | dstW, dstH, tmpFmt, | ||
1433 | flags, srcFilter, dstFilter, | ||
1434 | ✗ | sws->scaler_params); | |
1435 | |||
1436 | ✗ | if (!c->cascaded_context[1]) | |
1437 | ✗ | return AVERROR(ENOMEM); | |
1438 | |||
1439 | ✗ | c2 = sws_internal(c->cascaded_context[1]); | |
1440 | ✗ | c2->is_internal_gamma = 1; | |
1441 | ✗ | c2->gamma = alloc_gamma_tbl( c->gamma_value); | |
1442 | ✗ | c2->inv_gamma = alloc_gamma_tbl(1.f/c->gamma_value); | |
1443 | ✗ | if (!c2->gamma || !c2->inv_gamma) | |
1444 | ✗ | return AVERROR(ENOMEM); | |
1445 | |||
1446 | // is_internal_flag is set after creating the context | ||
1447 | // to properly create the gamma convert FilterDescriptor | ||
1448 | // we have to re-initialize it | ||
1449 | ✗ | ff_free_filters(c2); | |
1450 | ✗ | if ((ret = ff_init_filters(c2)) < 0) { | |
1451 | ✗ | sws_freeContext(c->cascaded_context[1]); | |
1452 | ✗ | c->cascaded_context[1] = NULL; | |
1453 | ✗ | return ret; | |
1454 | } | ||
1455 | |||
1456 | ✗ | c->cascaded_context[2] = NULL; | |
1457 | ✗ | if (dstFormat != tmpFmt) { | |
1458 | ✗ | ret = av_image_alloc(c->cascaded_tmp[1], c->cascaded_tmpStride[1], | |
1459 | dstW, dstH, tmpFmt, 64); | ||
1460 | ✗ | if (ret < 0) | |
1461 | ✗ | return ret; | |
1462 | |||
1463 | ✗ | c->cascaded_context[2] = sws_getContext(dstW, dstH, tmpFmt, | |
1464 | dstW, dstH, dstFormat, | ||
1465 | flags, NULL, NULL, | ||
1466 | ✗ | sws->scaler_params); | |
1467 | ✗ | if (!c->cascaded_context[2]) | |
1468 | ✗ | return AVERROR(ENOMEM); | |
1469 | } | ||
1470 | ✗ | return 0; | |
1471 | } | ||
1472 | |||
1473 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 31796 times.
|
31796 | if (isBayer(srcFormat)) { |
1474 | ✗ | if (!unscaled || | |
1475 | ✗ | (dstFormat != AV_PIX_FMT_RGB24 && dstFormat != AV_PIX_FMT_YUV420P && | |
1476 | dstFormat != AV_PIX_FMT_RGB48)) { | ||
1477 | ✗ | enum AVPixelFormat tmpFormat = isBayer16BPS(srcFormat) ? AV_PIX_FMT_RGB48 : AV_PIX_FMT_RGB24; | |
1478 | |||
1479 | ✗ | ret = av_image_alloc(c->cascaded_tmp[0], c->cascaded_tmpStride[0], | |
1480 | srcW, srcH, tmpFormat, 64); | ||
1481 | ✗ | if (ret < 0) | |
1482 | ✗ | return ret; | |
1483 | |||
1484 | ✗ | c->cascaded_context[0] = sws_getContext(srcW, srcH, srcFormat, | |
1485 | srcW, srcH, tmpFormat, | ||
1486 | flags, srcFilter, NULL, | ||
1487 | ✗ | sws->scaler_params); | |
1488 | ✗ | if (!c->cascaded_context[0]) | |
1489 | ✗ | return AVERROR(ENOMEM); | |
1490 | |||
1491 | ✗ | c->cascaded_context[1] = sws_getContext(srcW, srcH, tmpFormat, | |
1492 | dstW, dstH, dstFormat, | ||
1493 | flags, NULL, dstFilter, | ||
1494 | ✗ | sws->scaler_params); | |
1495 | ✗ | if (!c->cascaded_context[1]) | |
1496 | ✗ | return AVERROR(ENOMEM); | |
1497 | ✗ | return 0; | |
1498 | } | ||
1499 | } | ||
1500 | |||
1501 |
6/6✓ Branch 0 taken 30826 times.
✓ Branch 1 taken 970 times.
✓ Branch 2 taken 11027 times.
✓ Branch 3 taken 19799 times.
✓ Branch 4 taken 17 times.
✓ Branch 5 taken 11010 times.
|
31796 | if (unscaled && c->srcBpc == 8 && dstFormat == AV_PIX_FMT_GRAYF32){ |
1502 |
2/2✓ Branch 0 taken 4352 times.
✓ Branch 1 taken 17 times.
|
4369 | for (i = 0; i < 256; ++i){ |
1503 | 4352 | c->uint2float_lut[i] = (float)i * float_mult; | |
1504 | } | ||
1505 | } | ||
1506 | |||
1507 | // float will be converted to uint16_t | ||
1508 |
6/6✓ Branch 0 taken 31795 times.
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 2 times.
✓ Branch 3 taken 31793 times.
✓ Branch 4 taken 1 times.
✓ Branch 5 taken 2 times.
|
31796 | if ((srcFormat == AV_PIX_FMT_GRAYF32BE || srcFormat == AV_PIX_FMT_GRAYF32LE) && |
1509 |
4/8✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 1 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 1 times.
✗ Branch 7 not taken.
|
1 | (!unscaled || unscaled && dstFormat != srcFormat && (srcFormat != AV_PIX_FMT_GRAYF32 || |
1510 | dstFormat != AV_PIX_FMT_GRAY8))){ | ||
1511 | 3 | c->srcBpc = 16; | |
1512 | } | ||
1513 | |||
1514 |
4/4✓ Branch 1 taken 2399 times.
✓ Branch 2 taken 29397 times.
✓ Branch 4 taken 1485 times.
✓ Branch 5 taken 914 times.
|
31796 | if (CONFIG_SWSCALE_ALPHA && isALPHA(srcFormat) && !isALPHA(dstFormat)) { |
1515 | 1485 | enum AVPixelFormat tmpFormat = alphaless_fmt(srcFormat); | |
1516 | |||
1517 |
3/4✓ Branch 0 taken 743 times.
✓ Branch 1 taken 742 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 743 times.
|
1485 | if (tmpFormat != AV_PIX_FMT_NONE && sws->alpha_blend != SWS_ALPHA_BLEND_NONE) { |
1518 | ✗ | if (!unscaled || | |
1519 | ✗ | dstFormat != tmpFormat || | |
1520 | ✗ | usesHFilter || usesVFilter || | |
1521 | ✗ | sws->src_range != sws->dst_range | |
1522 | ) { | ||
1523 | ✗ | c->cascaded_mainindex = 1; | |
1524 | ✗ | ret = av_image_alloc(c->cascaded_tmp[0], c->cascaded_tmpStride[0], | |
1525 | srcW, srcH, tmpFormat, 64); | ||
1526 | ✗ | if (ret < 0) | |
1527 | ✗ | return ret; | |
1528 | |||
1529 | ✗ | c->cascaded_context[0] = alloc_set_opts(srcW, srcH, srcFormat, | |
1530 | srcW, srcH, tmpFormat, | ||
1531 | ✗ | flags, sws->scaler_params); | |
1532 | ✗ | if (!c->cascaded_context[0]) | |
1533 | ✗ | return AVERROR(EINVAL); | |
1534 | ✗ | c->cascaded_context[0]->alpha_blend = sws->alpha_blend; | |
1535 | ✗ | ret = sws_init_context(c->cascaded_context[0], NULL , NULL); | |
1536 | ✗ | if (ret < 0) | |
1537 | ✗ | return ret; | |
1538 | |||
1539 | ✗ | c->cascaded_context[1] = alloc_set_opts(srcW, srcH, tmpFormat, | |
1540 | dstW, dstH, dstFormat, | ||
1541 | ✗ | flags, sws->scaler_params); | |
1542 | ✗ | if (!c->cascaded_context[1]) | |
1543 | ✗ | return AVERROR(EINVAL); | |
1544 | |||
1545 | ✗ | c->cascaded_context[1]->src_range = sws->src_range; | |
1546 | ✗ | c->cascaded_context[1]->dst_range = sws->dst_range; | |
1547 | ✗ | ret = sws_init_context(c->cascaded_context[1], srcFilter , dstFilter); | |
1548 | ✗ | if (ret < 0) | |
1549 | ✗ | return ret; | |
1550 | |||
1551 | ✗ | return 0; | |
1552 | } | ||
1553 | } | ||
1554 | } | ||
1555 | |||
1556 | /* alpha blend special case, note this has been split via cascaded contexts if its scaled */ | ||
1557 |
4/6✓ Branch 0 taken 30826 times.
✓ Branch 1 taken 970 times.
✓ Branch 2 taken 30826 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 30826 times.
✗ Branch 5 not taken.
|
31796 | if (unscaled && !usesHFilter && !usesVFilter && |
1558 |
1/4✗ Branch 0 not taken.
✓ Branch 1 taken 30826 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
|
30826 | sws->alpha_blend != SWS_ALPHA_BLEND_NONE && |
1559 | ✗ | isALPHA(srcFormat) && | |
1560 | ✗ | (sws->src_range == sws->dst_range || isAnyRGB(dstFormat)) && | |
1561 | ✗ | alphaless_fmt(srcFormat) == dstFormat | |
1562 | ) { | ||
1563 | ✗ | c->convert_unscaled = ff_sws_alphablendaway; | |
1564 | |||
1565 | ✗ | if (flags & SWS_PRINT_INFO) | |
1566 | ✗ | av_log(c, AV_LOG_INFO, | |
1567 | "using alpha blendaway %s -> %s special converter\n", | ||
1568 | av_get_pix_fmt_name(srcFormat), av_get_pix_fmt_name(dstFormat)); | ||
1569 | ✗ | return 0; | |
1570 | } | ||
1571 | |||
1572 | /* unscaled special cases */ | ||
1573 |
4/6✓ Branch 0 taken 30826 times.
✓ Branch 1 taken 970 times.
✓ Branch 2 taken 30826 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 30826 times.
✗ Branch 5 not taken.
|
31796 | if (unscaled && !usesHFilter && !usesVFilter && |
1574 |
5/6✓ Branch 0 taken 3117 times.
✓ Branch 1 taken 27709 times.
✓ Branch 3 taken 2460 times.
✓ Branch 4 taken 657 times.
✓ Branch 5 taken 2460 times.
✗ Branch 6 not taken.
|
33286 | (sws->src_range == sws->dst_range || isAnyRGB(dstFormat) || |
1575 |
2/4✓ Branch 2 taken 2460 times.
✗ Branch 3 not taken.
✗ Branch 5 not taken.
✓ Branch 6 taken 2460 times.
|
4920 | isFloat(srcFormat) || isFloat(dstFormat) || isBayer(srcFormat))){ |
1576 | |||
1577 | 28366 | ff_get_unscaled_swscale(c); | |
1578 | |||
1579 |
2/2✓ Branch 0 taken 5516 times.
✓ Branch 1 taken 22850 times.
|
28366 | if (c->convert_unscaled) { |
1580 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 5516 times.
|
5516 | if (flags & SWS_PRINT_INFO) |
1581 | ✗ | av_log(c, AV_LOG_INFO, | |
1582 | "using unscaled %s -> %s special converter\n", | ||
1583 | av_get_pix_fmt_name(srcFormat), av_get_pix_fmt_name(dstFormat)); | ||
1584 | 5516 | return 0; | |
1585 | } | ||
1586 | } | ||
1587 | |||
1588 | #if HAVE_MMAP && HAVE_MPROTECT && defined(MAP_ANONYMOUS) | ||
1589 | #define USE_MMAP 1 | ||
1590 | #else | ||
1591 | #define USE_MMAP 0 | ||
1592 | #endif | ||
1593 | |||
1594 | /* precalculate horizontal scaler filter coefficients */ | ||
1595 | { | ||
1596 | #if HAVE_MMXEXT_INLINE | ||
1597 | // can't downscale !!! | ||
1598 |
3/4✓ Branch 0 taken 792 times.
✓ Branch 1 taken 25488 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 792 times.
|
26280 | if (c->canMMXEXTBeUsed && (flags & SWS_FAST_BILINEAR)) { |
1599 | ✗ | c->lumMmxextFilterCodeSize = ff_init_hscaler_mmxext(dstW, c->lumXInc, NULL, | |
1600 | NULL, NULL, 8); | ||
1601 | ✗ | c->chrMmxextFilterCodeSize = ff_init_hscaler_mmxext(c->chrDstW, c->chrXInc, | |
1602 | NULL, NULL, NULL, 4); | ||
1603 | |||
1604 | #if USE_MMAP | ||
1605 | ✗ | c->lumMmxextFilterCode = mmap(NULL, c->lumMmxextFilterCodeSize, | |
1606 | PROT_READ | PROT_WRITE, | ||
1607 | MAP_PRIVATE | MAP_ANONYMOUS, | ||
1608 | -1, 0); | ||
1609 | ✗ | c->chrMmxextFilterCode = mmap(NULL, c->chrMmxextFilterCodeSize, | |
1610 | PROT_READ | PROT_WRITE, | ||
1611 | MAP_PRIVATE | MAP_ANONYMOUS, | ||
1612 | -1, 0); | ||
1613 | #elif HAVE_VIRTUALALLOC | ||
1614 | c->lumMmxextFilterCode = VirtualAlloc(NULL, | ||
1615 | c->lumMmxextFilterCodeSize, | ||
1616 | MEM_COMMIT, | ||
1617 | PAGE_EXECUTE_READWRITE); | ||
1618 | c->chrMmxextFilterCode = VirtualAlloc(NULL, | ||
1619 | c->chrMmxextFilterCodeSize, | ||
1620 | MEM_COMMIT, | ||
1621 | PAGE_EXECUTE_READWRITE); | ||
1622 | #else | ||
1623 | c->lumMmxextFilterCode = av_malloc(c->lumMmxextFilterCodeSize); | ||
1624 | c->chrMmxextFilterCode = av_malloc(c->chrMmxextFilterCodeSize); | ||
1625 | #endif | ||
1626 | |||
1627 | #ifdef MAP_ANONYMOUS | ||
1628 | ✗ | if (c->lumMmxextFilterCode == MAP_FAILED || c->chrMmxextFilterCode == MAP_FAILED) | |
1629 | #else | ||
1630 | if (!c->lumMmxextFilterCode || !c->chrMmxextFilterCode) | ||
1631 | #endif | ||
1632 | { | ||
1633 | ✗ | av_log(c, AV_LOG_ERROR, "Failed to allocate MMX2FilterCode\n"); | |
1634 | ✗ | return AVERROR(ENOMEM); | |
1635 | } | ||
1636 | |||
1637 | ✗ | if (!FF_ALLOCZ_TYPED_ARRAY(c->hLumFilter, dstW / 8 + 8) || | |
1638 | ✗ | !FF_ALLOCZ_TYPED_ARRAY(c->hChrFilter, c->chrDstW / 4 + 8) || | |
1639 | ✗ | !FF_ALLOCZ_TYPED_ARRAY(c->hLumFilterPos, dstW / 2 / 8 + 8) || | |
1640 | ✗ | !FF_ALLOCZ_TYPED_ARRAY(c->hChrFilterPos, c->chrDstW / 2 / 4 + 8)) | |
1641 | ✗ | goto nomem; | |
1642 | |||
1643 | ✗ | ff_init_hscaler_mmxext( dstW, c->lumXInc, c->lumMmxextFilterCode, | |
1644 | c->hLumFilter, (uint32_t*)c->hLumFilterPos, 8); | ||
1645 | ✗ | ff_init_hscaler_mmxext(c->chrDstW, c->chrXInc, c->chrMmxextFilterCode, | |
1646 | c->hChrFilter, (uint32_t*)c->hChrFilterPos, 4); | ||
1647 | |||
1648 | #if USE_MMAP | ||
1649 | ✗ | if ( mprotect(c->lumMmxextFilterCode, c->lumMmxextFilterCodeSize, PROT_EXEC | PROT_READ) == -1 | |
1650 | ✗ | || mprotect(c->chrMmxextFilterCode, c->chrMmxextFilterCodeSize, PROT_EXEC | PROT_READ) == -1) { | |
1651 | ✗ | av_log(c, AV_LOG_ERROR, "mprotect failed, cannot use fast bilinear scaler\n"); | |
1652 | ✗ | ret = AVERROR(EINVAL); | |
1653 | ✗ | goto fail; | |
1654 | } | ||
1655 | #endif | ||
1656 | } else | ||
1657 | #endif /* HAVE_MMXEXT_INLINE */ | ||
1658 | { | ||
1659 |
2/2✓ Branch 0 taken 1226 times.
✓ Branch 1 taken 25054 times.
|
26280 | const int filterAlign = X86_MMX(cpu_flags) ? 4 : |
1660 | PPC_ALTIVEC(cpu_flags) ? 8 : | ||
1661 | have_neon(cpu_flags) ? 4 : | ||
1662 | have_lsx(cpu_flags) ? 8 : | ||
1663 | have_lasx(cpu_flags) ? 8 : 1; | ||
1664 | |||
1665 |
1/2✗ Branch 3 not taken.
✓ Branch 4 taken 26280 times.
|
52560 | if ((ret = initFilter(&c->hLumFilter, &c->hLumFilterPos, |
1666 | &c->hLumFilterSize, c->lumXInc, | ||
1667 | srcW, dstW, filterAlign, 1 << 14, | ||
1668 | 26280 | (flags & SWS_BICUBLIN) ? (flags | SWS_BICUBIC) : flags, | |
1669 | cpu_flags, srcFilter->lumH, dstFilter->lumH, | ||
1670 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 26280 times.
|
26280 | sws->scaler_params, |
1671 | get_local_pos(c, 0, 0, 0), | ||
1672 | get_local_pos(c, 0, 0, 0))) < 0) | ||
1673 | ✗ | goto fail; | |
1674 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 26280 times.
|
26280 | if (ff_shuffle_filter_coefficients(c, c->hLumFilterPos, c->hLumFilterSize, c->hLumFilter, dstW) < 0) |
1675 | ✗ | goto nomem; | |
1676 |
1/2✗ Branch 3 not taken.
✓ Branch 4 taken 26280 times.
|
52560 | if ((ret = initFilter(&c->hChrFilter, &c->hChrFilterPos, |
1677 | &c->hChrFilterSize, c->chrXInc, | ||
1678 | c->chrSrcW, c->chrDstW, filterAlign, 1 << 14, | ||
1679 | 26280 | (flags & SWS_BICUBLIN) ? (flags | SWS_BILINEAR) : flags, | |
1680 | cpu_flags, srcFilter->chrH, dstFilter->chrH, | ||
1681 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 26280 times.
|
26280 | sws->scaler_params, |
1682 | get_local_pos(c, c->chrSrcHSubSample, sws->src_h_chr_pos, 0), | ||
1683 | get_local_pos(c, c->chrDstHSubSample, sws->dst_h_chr_pos, 0))) < 0) | ||
1684 | ✗ | goto fail; | |
1685 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 26280 times.
|
26280 | if (ff_shuffle_filter_coefficients(c, c->hChrFilterPos, c->hChrFilterSize, c->hChrFilter, c->chrDstW) < 0) |
1686 | ✗ | goto nomem; | |
1687 | } | ||
1688 | } // initialize horizontal stuff | ||
1689 | |||
1690 | /* precalculate vertical scaler filter coefficients */ | ||
1691 | { | ||
1692 |
2/2✓ Branch 0 taken 1226 times.
✓ Branch 1 taken 25054 times.
|
26280 | const int filterAlign = X86_MMX(cpu_flags) ? 2 : |
1693 | PPC_ALTIVEC(cpu_flags) ? 8 : | ||
1694 | have_neon(cpu_flags) ? 2 : 1; | ||
1695 | |||
1696 |
1/2✗ Branch 3 not taken.
✓ Branch 4 taken 26280 times.
|
52560 | if ((ret = initFilter(&c->vLumFilter, &c->vLumFilterPos, &c->vLumFilterSize, |
1697 | c->lumYInc, srcH, dstH, filterAlign, (1 << 12), | ||
1698 | 26280 | (flags & SWS_BICUBLIN) ? (flags | SWS_BICUBIC) : flags, | |
1699 | cpu_flags, srcFilter->lumV, dstFilter->lumV, | ||
1700 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 26280 times.
|
26280 | sws->scaler_params, |
1701 | get_local_pos(c, 0, 0, 1), | ||
1702 | get_local_pos(c, 0, 0, 1))) < 0) | ||
1703 | ✗ | goto fail; | |
1704 |
1/2✗ Branch 3 not taken.
✓ Branch 4 taken 26280 times.
|
52560 | if ((ret = initFilter(&c->vChrFilter, &c->vChrFilterPos, &c->vChrFilterSize, |
1705 | c->chrYInc, c->chrSrcH, c->chrDstH, | ||
1706 | filterAlign, (1 << 12), | ||
1707 | 26280 | (flags & SWS_BICUBLIN) ? (flags | SWS_BILINEAR) : flags, | |
1708 | cpu_flags, srcFilter->chrV, dstFilter->chrV, | ||
1709 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 26280 times.
|
26280 | sws->scaler_params, |
1710 | get_local_pos(c, c->chrSrcVSubSample, sws->src_v_chr_pos, 1), | ||
1711 | get_local_pos(c, c->chrDstVSubSample, sws->dst_v_chr_pos, 1))) < 0) | ||
1712 | |||
1713 | ✗ | goto fail; | |
1714 | |||
1715 | #if HAVE_ALTIVEC | ||
1716 | if (!FF_ALLOC_TYPED_ARRAY(c->vYCoeffsBank, c->vLumFilterSize * sws->dst_h) || | ||
1717 | !FF_ALLOC_TYPED_ARRAY(c->vCCoeffsBank, c->vChrFilterSize * c->chrDstH)) | ||
1718 | goto nomem; | ||
1719 | |||
1720 | for (i = 0; i < c->vLumFilterSize * sws->dst_h; i++) { | ||
1721 | int j; | ||
1722 | short *p = (short *)&c->vYCoeffsBank[i]; | ||
1723 | for (j = 0; j < 8; j++) | ||
1724 | p[j] = c->vLumFilter[i]; | ||
1725 | } | ||
1726 | |||
1727 | for (i = 0; i < c->vChrFilterSize * c->chrDstH; i++) { | ||
1728 | int j; | ||
1729 | short *p = (short *)&c->vCCoeffsBank[i]; | ||
1730 | for (j = 0; j < 8; j++) | ||
1731 | p[j] = c->vChrFilter[i]; | ||
1732 | } | ||
1733 | #endif | ||
1734 | } | ||
1735 | |||
1736 |
2/2✓ Branch 0 taken 105120 times.
✓ Branch 1 taken 26280 times.
|
131400 | for (i = 0; i < 4; i++) |
1737 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 105120 times.
|
105120 | if (!FF_ALLOCZ_TYPED_ARRAY(c->dither_error[i], sws->dst_w + 3)) |
1738 | ✗ | goto nomem; | |
1739 | |||
1740 |
4/4✓ Branch 1 taken 629 times.
✓ Branch 2 taken 25651 times.
✓ Branch 4 taken 358 times.
✓ Branch 5 taken 271 times.
|
26280 | c->needAlpha = (CONFIG_SWSCALE_ALPHA && isALPHA(sws->src_format) && isALPHA(sws->dst_format)) ? 1 : 0; |
1741 | |||
1742 | // 64 / c->scalingBpp is the same as 16 / sizeof(scaling_intermediate) | ||
1743 | 26280 | c->uv_off = (dst_stride>>1) + 64 / (c->dstBpc &~ 7); | |
1744 | 26280 | c->uv_offx2 = dst_stride + 16; | |
1745 | |||
1746 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 26280 times.
|
26280 | av_assert0(c->chrDstH <= dstH); |
1747 | |||
1748 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 26280 times.
|
26280 | if (flags & SWS_PRINT_INFO) { |
1749 | ✗ | const char *scaler = NULL, *cpucaps; | |
1750 | |||
1751 | ✗ | for (i = 0; i < FF_ARRAY_ELEMS(scale_algorithms); i++) { | |
1752 | ✗ | if (flags & scale_algorithms[i].flag) { | |
1753 | ✗ | scaler = scale_algorithms[i].description; | |
1754 | ✗ | break; | |
1755 | } | ||
1756 | } | ||
1757 | ✗ | if (!scaler) | |
1758 | ✗ | scaler = "ehh flags invalid?!"; | |
1759 | ✗ | av_log(c, AV_LOG_INFO, "%s scaler, from %s to %s%s ", | |
1760 | scaler, | ||
1761 | av_get_pix_fmt_name(srcFormat), | ||
1762 | ✗ | dstFormat == AV_PIX_FMT_BGR555 || dstFormat == AV_PIX_FMT_BGR565 || | |
1763 | ✗ | dstFormat == AV_PIX_FMT_RGB444BE || dstFormat == AV_PIX_FMT_RGB444LE || | |
1764 | ✗ | dstFormat == AV_PIX_FMT_BGR444BE || dstFormat == AV_PIX_FMT_BGR444LE ? | |
1765 | "dithered " : "", | ||
1766 | av_get_pix_fmt_name(dstFormat)); | ||
1767 | |||
1768 | ✗ | if (INLINE_MMXEXT(cpu_flags)) | |
1769 | ✗ | cpucaps = "MMXEXT"; | |
1770 | ✗ | else if (INLINE_MMX(cpu_flags)) | |
1771 | ✗ | cpucaps = "MMX"; | |
1772 | else if (PPC_ALTIVEC(cpu_flags)) | ||
1773 | cpucaps = "AltiVec"; | ||
1774 | else | ||
1775 | ✗ | cpucaps = "C"; | |
1776 | |||
1777 | ✗ | av_log(c, AV_LOG_INFO, "using %s\n", cpucaps); | |
1778 | |||
1779 | ✗ | av_log(c, AV_LOG_VERBOSE, "%dx%d -> %dx%d\n", srcW, srcH, dstW, dstH); | |
1780 | ✗ | av_log(c, AV_LOG_DEBUG, | |
1781 | "lum srcW=%d srcH=%d dstW=%d dstH=%d xInc=%d yInc=%d\n", | ||
1782 | sws->src_w, sws->src_h, sws->dst_w, sws->dst_h, c->lumXInc, c->lumYInc); | ||
1783 | ✗ | av_log(c, AV_LOG_DEBUG, | |
1784 | "chr srcW=%d srcH=%d dstW=%d dstH=%d xInc=%d yInc=%d\n", | ||
1785 | c->chrSrcW, c->chrSrcH, c->chrDstW, c->chrDstH, | ||
1786 | c->chrXInc, c->chrYInc); | ||
1787 | } | ||
1788 | |||
1789 | 26280 | ff_sws_init_scale(c); | |
1790 | |||
1791 | 26280 | return ff_init_filters(c); | |
1792 | ✗ | nomem: | |
1793 | ✗ | ret = AVERROR(ENOMEM); | |
1794 | ✗ | fail: // FIXME replace things by appropriate error codes | |
1795 | ✗ | if (ret == RETCODE_USE_CASCADE) { | |
1796 | ✗ | int tmpW = sqrt(srcW * (int64_t)dstW); | |
1797 | ✗ | int tmpH = sqrt(srcH * (int64_t)dstH); | |
1798 | ✗ | enum AVPixelFormat tmpFormat = AV_PIX_FMT_YUV420P; | |
1799 | |||
1800 | ✗ | if (isALPHA(srcFormat)) | |
1801 | ✗ | tmpFormat = AV_PIX_FMT_YUVA420P; | |
1802 | |||
1803 | ✗ | if (srcW*(int64_t)srcH <= 4LL*dstW*dstH) | |
1804 | ✗ | return AVERROR(EINVAL); | |
1805 | |||
1806 | ✗ | ret = av_image_alloc(c->cascaded_tmp[0], c->cascaded_tmpStride[0], | |
1807 | tmpW, tmpH, tmpFormat, 64); | ||
1808 | ✗ | if (ret < 0) | |
1809 | ✗ | return ret; | |
1810 | |||
1811 | ✗ | c->cascaded_context[0] = sws_getContext(srcW, srcH, srcFormat, | |
1812 | tmpW, tmpH, tmpFormat, | ||
1813 | flags, srcFilter, NULL, | ||
1814 | ✗ | sws->scaler_params); | |
1815 | ✗ | if (!c->cascaded_context[0]) | |
1816 | ✗ | return AVERROR(ENOMEM); | |
1817 | |||
1818 | ✗ | c->cascaded_context[1] = sws_getContext(tmpW, tmpH, tmpFormat, | |
1819 | dstW, dstH, dstFormat, | ||
1820 | flags, NULL, dstFilter, | ||
1821 | ✗ | sws->scaler_params); | |
1822 | ✗ | if (!c->cascaded_context[1]) | |
1823 | ✗ | return AVERROR(ENOMEM); | |
1824 | ✗ | return 0; | |
1825 | } | ||
1826 | ✗ | return ret; | |
1827 | } | ||
1828 | |||
1829 | ✗ | static int context_init_threaded(SwsContext *sws, | |
1830 | SwsFilter *src_filter, SwsFilter *dst_filter) | ||
1831 | { | ||
1832 | ✗ | SwsInternal *c = sws_internal(sws); | |
1833 | int ret; | ||
1834 | |||
1835 | ✗ | ret = avpriv_slicethread_create(&c->slicethread, (void*) sws, | |
1836 | ff_sws_slice_worker, NULL, sws->threads); | ||
1837 | ✗ | if (ret == AVERROR(ENOSYS)) { | |
1838 | ✗ | sws->threads = 1; | |
1839 | ✗ | return 0; | |
1840 | ✗ | } else if (ret < 0) | |
1841 | ✗ | return ret; | |
1842 | |||
1843 | ✗ | sws->threads = ret; | |
1844 | |||
1845 | ✗ | c->slice_ctx = av_calloc(sws->threads, sizeof(*c->slice_ctx)); | |
1846 | ✗ | c->slice_err = av_calloc(sws->threads, sizeof(*c->slice_err)); | |
1847 | ✗ | if (!c->slice_ctx || !c->slice_err) | |
1848 | ✗ | return AVERROR(ENOMEM); | |
1849 | |||
1850 | ✗ | for (int i = 0; i < sws->threads; i++) { | |
1851 | SwsContext *slice; | ||
1852 | ✗ | slice = c->slice_ctx[i] = sws_alloc_context(); | |
1853 | ✗ | if (!slice) | |
1854 | ✗ | return AVERROR(ENOMEM); | |
1855 | ✗ | sws_internal(slice)->parent = sws; | |
1856 | ✗ | c->nb_slice_ctx++; | |
1857 | |||
1858 | ✗ | ret = av_opt_copy(slice, sws); | |
1859 | ✗ | if (ret < 0) | |
1860 | ✗ | return ret; | |
1861 | ✗ | slice->threads = 1; | |
1862 | |||
1863 | ✗ | ret = ff_sws_init_single_context(slice, src_filter, dst_filter); | |
1864 | ✗ | if (ret < 0) | |
1865 | ✗ | return ret; | |
1866 | |||
1867 | ✗ | if (slice->dither == SWS_DITHER_ED) { | |
1868 | ✗ | av_log(c, AV_LOG_VERBOSE, | |
1869 | "Error-diffusion dither is in use, scaling will be single-threaded."); | ||
1870 | ✗ | break; | |
1871 | } | ||
1872 | } | ||
1873 | |||
1874 | ✗ | return 0; | |
1875 | } | ||
1876 | |||
1877 | 9506 | av_cold int sws_init_context(SwsContext *sws, SwsFilter *srcFilter, | |
1878 | SwsFilter *dstFilter) | ||
1879 | { | ||
1880 | 9506 | SwsInternal *c = sws_internal(sws); | |
1881 | static AVOnce rgb2rgb_once = AV_ONCE_INIT; | ||
1882 | enum AVPixelFormat src_format, dst_format; | ||
1883 | int ret; | ||
1884 | |||
1885 | 9506 | c->frame_src = av_frame_alloc(); | |
1886 | 9506 | c->frame_dst = av_frame_alloc(); | |
1887 |
2/4✓ Branch 0 taken 9506 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 9506 times.
|
9506 | if (!c->frame_src || !c->frame_dst) |
1888 | ✗ | return AVERROR(ENOMEM); | |
1889 | |||
1890 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 9506 times.
|
9506 | if (ff_thread_once(&rgb2rgb_once, ff_sws_rgb2rgb_init) != 0) |
1891 | ✗ | return AVERROR_UNKNOWN; | |
1892 | |||
1893 | 9506 | src_format = sws->src_format; | |
1894 | 9506 | dst_format = sws->dst_format; | |
1895 | 9506 | sws->src_range |= handle_jpeg(&sws->src_format); | |
1896 | 9506 | sws->dst_range |= handle_jpeg(&sws->dst_format); | |
1897 | |||
1898 |
4/4✓ Branch 0 taken 9414 times.
✓ Branch 1 taken 92 times.
✓ Branch 2 taken 173 times.
✓ Branch 3 taken 9241 times.
|
9506 | if (src_format != sws->src_format || dst_format != sws->dst_format) |
1899 | 265 | av_log(c, AV_LOG_WARNING, "deprecated pixel format used, make sure you did set range correctly\n"); | |
1900 | |||
1901 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 9506 times.
|
9506 | if (sws->threads != 1) { |
1902 | ✗ | ret = context_init_threaded(sws, srcFilter, dstFilter); | |
1903 | ✗ | if (ret < 0 || sws->threads > 1) | |
1904 | ✗ | return ret; | |
1905 | // threading disabled in this build, init as single-threaded | ||
1906 | } | ||
1907 | |||
1908 | 9506 | return ff_sws_init_single_context(sws, srcFilter, dstFilter); | |
1909 | } | ||
1910 | |||
1911 | 3143 | SwsContext *sws_getContext(int srcW, int srcH, enum AVPixelFormat srcFormat, | |
1912 | int dstW, int dstH, enum AVPixelFormat dstFormat, | ||
1913 | int flags, SwsFilter *srcFilter, | ||
1914 | SwsFilter *dstFilter, const double *param) | ||
1915 | { | ||
1916 | SwsContext *sws; | ||
1917 | |||
1918 | 3143 | sws = alloc_set_opts(srcW, srcH, srcFormat, | |
1919 | dstW, dstH, dstFormat, | ||
1920 | flags, param); | ||
1921 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 3143 times.
|
3143 | if (!sws) |
1922 | ✗ | return NULL; | |
1923 | |||
1924 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 3143 times.
|
3143 | if (sws_init_context(sws, srcFilter, dstFilter) < 0) { |
1925 | ✗ | sws_freeContext(sws); | |
1926 | ✗ | return NULL; | |
1927 | } | ||
1928 | |||
1929 | 3143 | return sws; | |
1930 | } | ||
1931 | |||
1932 | ✗ | static int isnan_vec(SwsVector *a) | |
1933 | { | ||
1934 | int i; | ||
1935 | ✗ | for (i=0; i<a->length; i++) | |
1936 | ✗ | if (isnan(a->coeff[i])) | |
1937 | ✗ | return 1; | |
1938 | ✗ | return 0; | |
1939 | } | ||
1940 | |||
1941 | ✗ | static void makenan_vec(SwsVector *a) | |
1942 | { | ||
1943 | int i; | ||
1944 | ✗ | for (i=0; i<a->length; i++) | |
1945 | ✗ | a->coeff[i] = NAN; | |
1946 | ✗ | } | |
1947 | |||
1948 | ✗ | SwsVector *sws_allocVec(int length) | |
1949 | { | ||
1950 | SwsVector *vec; | ||
1951 | |||
1952 | ✗ | if(length <= 0 || length > INT_MAX/ sizeof(double)) | |
1953 | ✗ | return NULL; | |
1954 | |||
1955 | ✗ | vec = av_malloc(sizeof(SwsVector)); | |
1956 | ✗ | if (!vec) | |
1957 | ✗ | return NULL; | |
1958 | ✗ | vec->length = length; | |
1959 | ✗ | vec->coeff = av_malloc(sizeof(double) * length); | |
1960 | ✗ | if (!vec->coeff) | |
1961 | ✗ | av_freep(&vec); | |
1962 | ✗ | return vec; | |
1963 | } | ||
1964 | |||
1965 | ✗ | SwsVector *sws_getGaussianVec(double variance, double quality) | |
1966 | { | ||
1967 | ✗ | const int length = (int)(variance * quality + 0.5) | 1; | |
1968 | int i; | ||
1969 | ✗ | double middle = (length - 1) * 0.5; | |
1970 | SwsVector *vec; | ||
1971 | |||
1972 | ✗ | if(variance < 0 || quality < 0) | |
1973 | ✗ | return NULL; | |
1974 | |||
1975 | ✗ | vec = sws_allocVec(length); | |
1976 | |||
1977 | ✗ | if (!vec) | |
1978 | ✗ | return NULL; | |
1979 | |||
1980 | ✗ | for (i = 0; i < length; i++) { | |
1981 | ✗ | double dist = i - middle; | |
1982 | ✗ | vec->coeff[i] = exp(-dist * dist / (2 * variance * variance)) / | |
1983 | ✗ | sqrt(2 * variance * M_PI); | |
1984 | } | ||
1985 | |||
1986 | ✗ | sws_normalizeVec(vec, 1.0); | |
1987 | |||
1988 | ✗ | return vec; | |
1989 | } | ||
1990 | |||
1991 | /** | ||
1992 | * Allocate and return a vector with length coefficients, all | ||
1993 | * with the same value c. | ||
1994 | */ | ||
1995 | static | ||
1996 | ✗ | SwsVector *sws_getConstVec(double c, int length) | |
1997 | { | ||
1998 | int i; | ||
1999 | ✗ | SwsVector *vec = sws_allocVec(length); | |
2000 | |||
2001 | ✗ | if (!vec) | |
2002 | ✗ | return NULL; | |
2003 | |||
2004 | ✗ | for (i = 0; i < length; i++) | |
2005 | ✗ | vec->coeff[i] = c; | |
2006 | |||
2007 | ✗ | return vec; | |
2008 | } | ||
2009 | |||
2010 | /** | ||
2011 | * Allocate and return a vector with just one coefficient, with | ||
2012 | * value 1.0. | ||
2013 | */ | ||
2014 | static | ||
2015 | ✗ | SwsVector *sws_getIdentityVec(void) | |
2016 | { | ||
2017 | ✗ | return sws_getConstVec(1.0, 1); | |
2018 | } | ||
2019 | |||
2020 | ✗ | static double sws_dcVec(SwsVector *a) | |
2021 | { | ||
2022 | int i; | ||
2023 | ✗ | double sum = 0; | |
2024 | |||
2025 | ✗ | for (i = 0; i < a->length; i++) | |
2026 | ✗ | sum += a->coeff[i]; | |
2027 | |||
2028 | ✗ | return sum; | |
2029 | } | ||
2030 | |||
2031 | ✗ | void sws_scaleVec(SwsVector *a, double scalar) | |
2032 | { | ||
2033 | int i; | ||
2034 | |||
2035 | ✗ | for (i = 0; i < a->length; i++) | |
2036 | ✗ | a->coeff[i] *= scalar; | |
2037 | ✗ | } | |
2038 | |||
2039 | ✗ | void sws_normalizeVec(SwsVector *a, double height) | |
2040 | { | ||
2041 | ✗ | sws_scaleVec(a, height / sws_dcVec(a)); | |
2042 | ✗ | } | |
2043 | |||
2044 | ✗ | static SwsVector *sws_sumVec(SwsVector *a, SwsVector *b) | |
2045 | { | ||
2046 | ✗ | int length = FFMAX(a->length, b->length); | |
2047 | int i; | ||
2048 | ✗ | SwsVector *vec = sws_getConstVec(0.0, length); | |
2049 | |||
2050 | ✗ | if (!vec) | |
2051 | ✗ | return NULL; | |
2052 | |||
2053 | ✗ | for (i = 0; i < a->length; i++) | |
2054 | ✗ | vec->coeff[i + (length - 1) / 2 - (a->length - 1) / 2] += a->coeff[i]; | |
2055 | ✗ | for (i = 0; i < b->length; i++) | |
2056 | ✗ | vec->coeff[i + (length - 1) / 2 - (b->length - 1) / 2] += b->coeff[i]; | |
2057 | |||
2058 | ✗ | return vec; | |
2059 | } | ||
2060 | |||
2061 | /* shift left / or right if "shift" is negative */ | ||
2062 | ✗ | static SwsVector *sws_getShiftedVec(SwsVector *a, int shift) | |
2063 | { | ||
2064 | ✗ | int length = a->length + FFABS(shift) * 2; | |
2065 | int i; | ||
2066 | ✗ | SwsVector *vec = sws_getConstVec(0.0, length); | |
2067 | |||
2068 | ✗ | if (!vec) | |
2069 | ✗ | return NULL; | |
2070 | |||
2071 | ✗ | for (i = 0; i < a->length; i++) { | |
2072 | ✗ | vec->coeff[i + (length - 1) / 2 - | |
2073 | ✗ | (a->length - 1) / 2 - shift] = a->coeff[i]; | |
2074 | } | ||
2075 | |||
2076 | ✗ | return vec; | |
2077 | } | ||
2078 | |||
2079 | static | ||
2080 | ✗ | void sws_shiftVec(SwsVector *a, int shift) | |
2081 | { | ||
2082 | ✗ | SwsVector *shifted = sws_getShiftedVec(a, shift); | |
2083 | ✗ | if (!shifted) { | |
2084 | ✗ | makenan_vec(a); | |
2085 | ✗ | return; | |
2086 | } | ||
2087 | ✗ | av_free(a->coeff); | |
2088 | ✗ | a->coeff = shifted->coeff; | |
2089 | ✗ | a->length = shifted->length; | |
2090 | ✗ | av_free(shifted); | |
2091 | } | ||
2092 | |||
2093 | static | ||
2094 | ✗ | void sws_addVec(SwsVector *a, SwsVector *b) | |
2095 | { | ||
2096 | ✗ | SwsVector *sum = sws_sumVec(a, b); | |
2097 | ✗ | if (!sum) { | |
2098 | ✗ | makenan_vec(a); | |
2099 | ✗ | return; | |
2100 | } | ||
2101 | ✗ | av_free(a->coeff); | |
2102 | ✗ | a->coeff = sum->coeff; | |
2103 | ✗ | a->length = sum->length; | |
2104 | ✗ | av_free(sum); | |
2105 | } | ||
2106 | |||
2107 | /** | ||
2108 | * Print with av_log() a textual representation of the vector a | ||
2109 | * if log_level <= av_log_level. | ||
2110 | */ | ||
2111 | static | ||
2112 | ✗ | void sws_printVec2(SwsVector *a, AVClass *log_ctx, int log_level) | |
2113 | { | ||
2114 | int i; | ||
2115 | ✗ | double max = 0; | |
2116 | ✗ | double min = 0; | |
2117 | double range; | ||
2118 | |||
2119 | ✗ | for (i = 0; i < a->length; i++) | |
2120 | ✗ | if (a->coeff[i] > max) | |
2121 | ✗ | max = a->coeff[i]; | |
2122 | |||
2123 | ✗ | for (i = 0; i < a->length; i++) | |
2124 | ✗ | if (a->coeff[i] < min) | |
2125 | ✗ | min = a->coeff[i]; | |
2126 | |||
2127 | ✗ | range = max - min; | |
2128 | |||
2129 | ✗ | for (i = 0; i < a->length; i++) { | |
2130 | ✗ | int x = (int)((a->coeff[i] - min) * 60.0 / range + 0.5); | |
2131 | ✗ | av_log(log_ctx, log_level, "%1.3f ", a->coeff[i]); | |
2132 | ✗ | for (; x > 0; x--) | |
2133 | ✗ | av_log(log_ctx, log_level, " "); | |
2134 | ✗ | av_log(log_ctx, log_level, "|\n"); | |
2135 | } | ||
2136 | ✗ | } | |
2137 | |||
2138 | ✗ | void sws_freeVec(SwsVector *a) | |
2139 | { | ||
2140 | ✗ | if (!a) | |
2141 | ✗ | return; | |
2142 | ✗ | av_freep(&a->coeff); | |
2143 | ✗ | a->length = 0; | |
2144 | ✗ | av_free(a); | |
2145 | } | ||
2146 | |||
2147 | ✗ | void sws_freeFilter(SwsFilter *filter) | |
2148 | { | ||
2149 | ✗ | if (!filter) | |
2150 | ✗ | return; | |
2151 | |||
2152 | ✗ | sws_freeVec(filter->lumH); | |
2153 | ✗ | sws_freeVec(filter->lumV); | |
2154 | ✗ | sws_freeVec(filter->chrH); | |
2155 | ✗ | sws_freeVec(filter->chrV); | |
2156 | ✗ | av_free(filter); | |
2157 | } | ||
2158 | |||
2159 | ✗ | SwsFilter *sws_getDefaultFilter(float lumaGBlur, float chromaGBlur, | |
2160 | float lumaSharpen, float chromaSharpen, | ||
2161 | float chromaHShift, float chromaVShift, | ||
2162 | int verbose) | ||
2163 | { | ||
2164 | ✗ | SwsFilter *filter = av_malloc(sizeof(SwsFilter)); | |
2165 | ✗ | if (!filter) | |
2166 | ✗ | return NULL; | |
2167 | |||
2168 | ✗ | if (lumaGBlur != 0.0) { | |
2169 | ✗ | filter->lumH = sws_getGaussianVec(lumaGBlur, 3.0); | |
2170 | ✗ | filter->lumV = sws_getGaussianVec(lumaGBlur, 3.0); | |
2171 | } else { | ||
2172 | ✗ | filter->lumH = sws_getIdentityVec(); | |
2173 | ✗ | filter->lumV = sws_getIdentityVec(); | |
2174 | } | ||
2175 | |||
2176 | ✗ | if (chromaGBlur != 0.0) { | |
2177 | ✗ | filter->chrH = sws_getGaussianVec(chromaGBlur, 3.0); | |
2178 | ✗ | filter->chrV = sws_getGaussianVec(chromaGBlur, 3.0); | |
2179 | } else { | ||
2180 | ✗ | filter->chrH = sws_getIdentityVec(); | |
2181 | ✗ | filter->chrV = sws_getIdentityVec(); | |
2182 | } | ||
2183 | |||
2184 | ✗ | if (!filter->lumH || !filter->lumV || !filter->chrH || !filter->chrV) | |
2185 | ✗ | goto fail; | |
2186 | |||
2187 | ✗ | if (chromaSharpen != 0.0) { | |
2188 | ✗ | SwsVector *id = sws_getIdentityVec(); | |
2189 | ✗ | if (!id) | |
2190 | ✗ | goto fail; | |
2191 | ✗ | sws_scaleVec(filter->chrH, -chromaSharpen); | |
2192 | ✗ | sws_scaleVec(filter->chrV, -chromaSharpen); | |
2193 | ✗ | sws_addVec(filter->chrH, id); | |
2194 | ✗ | sws_addVec(filter->chrV, id); | |
2195 | ✗ | sws_freeVec(id); | |
2196 | } | ||
2197 | |||
2198 | ✗ | if (lumaSharpen != 0.0) { | |
2199 | ✗ | SwsVector *id = sws_getIdentityVec(); | |
2200 | ✗ | if (!id) | |
2201 | ✗ | goto fail; | |
2202 | ✗ | sws_scaleVec(filter->lumH, -lumaSharpen); | |
2203 | ✗ | sws_scaleVec(filter->lumV, -lumaSharpen); | |
2204 | ✗ | sws_addVec(filter->lumH, id); | |
2205 | ✗ | sws_addVec(filter->lumV, id); | |
2206 | ✗ | sws_freeVec(id); | |
2207 | } | ||
2208 | |||
2209 | ✗ | if (chromaHShift != 0.0) | |
2210 | ✗ | sws_shiftVec(filter->chrH, (int)(chromaHShift + 0.5)); | |
2211 | |||
2212 | ✗ | if (chromaVShift != 0.0) | |
2213 | ✗ | sws_shiftVec(filter->chrV, (int)(chromaVShift + 0.5)); | |
2214 | |||
2215 | ✗ | sws_normalizeVec(filter->chrH, 1.0); | |
2216 | ✗ | sws_normalizeVec(filter->chrV, 1.0); | |
2217 | ✗ | sws_normalizeVec(filter->lumH, 1.0); | |
2218 | ✗ | sws_normalizeVec(filter->lumV, 1.0); | |
2219 | |||
2220 | ✗ | if (isnan_vec(filter->chrH) || | |
2221 | ✗ | isnan_vec(filter->chrV) || | |
2222 | ✗ | isnan_vec(filter->lumH) || | |
2223 | ✗ | isnan_vec(filter->lumV)) | |
2224 | ✗ | goto fail; | |
2225 | |||
2226 | ✗ | if (verbose) | |
2227 | ✗ | sws_printVec2(filter->chrH, NULL, AV_LOG_DEBUG); | |
2228 | ✗ | if (verbose) | |
2229 | ✗ | sws_printVec2(filter->lumH, NULL, AV_LOG_DEBUG); | |
2230 | |||
2231 | ✗ | return filter; | |
2232 | |||
2233 | ✗ | fail: | |
2234 | ✗ | sws_freeVec(filter->lumH); | |
2235 | ✗ | sws_freeVec(filter->lumV); | |
2236 | ✗ | sws_freeVec(filter->chrH); | |
2237 | ✗ | sws_freeVec(filter->chrV); | |
2238 | ✗ | av_freep(&filter); | |
2239 | ✗ | return NULL; | |
2240 | } | ||
2241 | |||
2242 | 170605 | void sws_freeContext(SwsContext *sws) | |
2243 | { | ||
2244 | 170605 | SwsInternal *c = sws_internal(sws); | |
2245 | int i; | ||
2246 |
2/2✓ Branch 0 taken 127954 times.
✓ Branch 1 taken 42651 times.
|
170605 | if (!c) |
2247 | 127954 | return; | |
2248 | |||
2249 |
2/2✓ Branch 0 taken 85302 times.
✓ Branch 1 taken 42651 times.
|
127953 | for (i = 0; i < FF_ARRAY_ELEMS(c->graph); i++) |
2250 | 85302 | ff_sws_graph_free(&c->graph[i]); | |
2251 | |||
2252 |
2/2✓ Branch 0 taken 22290 times.
✓ Branch 1 taken 42651 times.
|
64941 | for (i = 0; i < c->nb_slice_ctx; i++) |
2253 | 22290 | sws_freeContext(c->slice_ctx[i]); | |
2254 | 42651 | av_freep(&c->slice_ctx); | |
2255 | 42651 | av_freep(&c->slice_err); | |
2256 | |||
2257 | 42651 | avpriv_slicethread_free(&c->slicethread); | |
2258 | |||
2259 |
2/2✓ Branch 0 taken 170604 times.
✓ Branch 1 taken 42651 times.
|
213255 | for (i = 0; i < 4; i++) |
2260 | 170604 | av_freep(&c->dither_error[i]); | |
2261 | |||
2262 | 42651 | av_frame_free(&c->frame_src); | |
2263 | 42651 | av_frame_free(&c->frame_dst); | |
2264 | |||
2265 | 42651 | av_freep(&c->src_ranges.ranges); | |
2266 | |||
2267 | 42651 | av_freep(&c->vLumFilter); | |
2268 | 42651 | av_freep(&c->vChrFilter); | |
2269 | 42651 | av_freep(&c->hLumFilter); | |
2270 | 42651 | av_freep(&c->hChrFilter); | |
2271 | #if HAVE_ALTIVEC | ||
2272 | av_freep(&c->vYCoeffsBank); | ||
2273 | av_freep(&c->vCCoeffsBank); | ||
2274 | #endif | ||
2275 | |||
2276 | 42651 | av_freep(&c->vLumFilterPos); | |
2277 | 42651 | av_freep(&c->vChrFilterPos); | |
2278 | 42651 | av_freep(&c->hLumFilterPos); | |
2279 | 42651 | av_freep(&c->hChrFilterPos); | |
2280 | |||
2281 | #if HAVE_MMX_INLINE | ||
2282 | #if USE_MMAP | ||
2283 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 42651 times.
|
42651 | if (c->lumMmxextFilterCode) |
2284 | ✗ | munmap(c->lumMmxextFilterCode, c->lumMmxextFilterCodeSize); | |
2285 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 42651 times.
|
42651 | if (c->chrMmxextFilterCode) |
2286 | ✗ | munmap(c->chrMmxextFilterCode, c->chrMmxextFilterCodeSize); | |
2287 | #elif HAVE_VIRTUALALLOC | ||
2288 | if (c->lumMmxextFilterCode) | ||
2289 | VirtualFree(c->lumMmxextFilterCode, 0, MEM_RELEASE); | ||
2290 | if (c->chrMmxextFilterCode) | ||
2291 | VirtualFree(c->chrMmxextFilterCode, 0, MEM_RELEASE); | ||
2292 | #else | ||
2293 | av_free(c->lumMmxextFilterCode); | ||
2294 | av_free(c->chrMmxextFilterCode); | ||
2295 | #endif | ||
2296 | 42651 | c->lumMmxextFilterCode = NULL; | |
2297 | 42651 | c->chrMmxextFilterCode = NULL; | |
2298 | #endif /* HAVE_MMX_INLINE */ | ||
2299 | |||
2300 | 42651 | av_freep(&c->yuvTable); | |
2301 | 42651 | av_freep(&c->formatConvBuffer); | |
2302 | |||
2303 | 42651 | sws_freeContext(c->cascaded_context[0]); | |
2304 | 42651 | sws_freeContext(c->cascaded_context[1]); | |
2305 | 42651 | sws_freeContext(c->cascaded_context[2]); | |
2306 | 42651 | memset(c->cascaded_context, 0, sizeof(c->cascaded_context)); | |
2307 | 42651 | av_freep(&c->cascaded_tmp[0][0]); | |
2308 | 42651 | av_freep(&c->cascaded_tmp[1][0]); | |
2309 | |||
2310 | 42651 | av_freep(&c->gamma); | |
2311 | 42651 | av_freep(&c->inv_gamma); | |
2312 | #if CONFIG_SMALL | ||
2313 | av_freep(&c->xyzgamma); | ||
2314 | #endif | ||
2315 | |||
2316 | 42651 | av_freep(&c->rgb0_scratch); | |
2317 | 42651 | av_freep(&c->xyz_scratch); | |
2318 | |||
2319 | 42651 | ff_free_filters(c); | |
2320 | |||
2321 | 42651 | av_free(c); | |
2322 | } | ||
2323 | |||
2324 | 17023 | void sws_free_context(SwsContext **pctx) | |
2325 | { | ||
2326 | 17023 | SwsContext *ctx = *pctx; | |
2327 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 17023 times.
|
17023 | if (!ctx) |
2328 | ✗ | return; | |
2329 | |||
2330 | 17023 | sws_freeContext(ctx); | |
2331 | 17023 | *pctx = NULL; | |
2332 | } | ||
2333 | |||
2334 | ✗ | SwsContext *sws_getCachedContext(SwsContext *prev, int srcW, | |
2335 | int srcH, enum AVPixelFormat srcFormat, | ||
2336 | int dstW, int dstH, | ||
2337 | enum AVPixelFormat dstFormat, int flags, | ||
2338 | SwsFilter *srcFilter, | ||
2339 | SwsFilter *dstFilter, | ||
2340 | const double *param) | ||
2341 | { | ||
2342 | SwsContext *sws; | ||
2343 | static const double default_param[2] = { SWS_PARAM_DEFAULT, | ||
2344 | SWS_PARAM_DEFAULT }; | ||
2345 | |||
2346 | ✗ | if (!param) | |
2347 | ✗ | param = default_param; | |
2348 | |||
2349 | ✗ | if (prev && (prev->src_w == srcW && | |
2350 | ✗ | prev->src_h == srcH && | |
2351 | ✗ | prev->src_format == srcFormat && | |
2352 | ✗ | prev->dst_w == dstW && | |
2353 | ✗ | prev->dst_h == dstH && | |
2354 | ✗ | prev->dst_format == dstFormat && | |
2355 | ✗ | prev->flags == flags && | |
2356 | ✗ | prev->scaler_params[0] == param[0] && | |
2357 | ✗ | prev->scaler_params[1] == param[1])) { | |
2358 | ✗ | return prev; | |
2359 | } | ||
2360 | |||
2361 | ✗ | if (!(sws = sws_alloc_context())) { | |
2362 | ✗ | sws_free_context(&prev); | |
2363 | ✗ | return NULL; | |
2364 | } | ||
2365 | |||
2366 | ✗ | if (prev) { | |
2367 | ✗ | av_opt_copy(sws, prev); | |
2368 | ✗ | sws_free_context(&prev); | |
2369 | } | ||
2370 | |||
2371 | ✗ | sws->src_w = srcW; | |
2372 | ✗ | sws->src_h = srcH; | |
2373 | ✗ | sws->src_format = srcFormat; | |
2374 | ✗ | sws->dst_w = dstW; | |
2375 | ✗ | sws->dst_h = dstH; | |
2376 | ✗ | sws->dst_format = dstFormat; | |
2377 | ✗ | sws->flags = flags; | |
2378 | ✗ | sws->scaler_params[0] = param[0]; | |
2379 | ✗ | sws->scaler_params[1] = param[1]; | |
2380 | |||
2381 | ✗ | if (sws_init_context(sws, srcFilter, dstFilter) < 0) | |
2382 | ✗ | sws_free_context(&sws); | |
2383 | |||
2384 | ✗ | return sws; | |
2385 | } | ||
2386 | |||
2387 | ✗ | int ff_range_add(RangeList *rl, unsigned int start, unsigned int len) | |
2388 | { | ||
2389 | Range *tmp; | ||
2390 | unsigned int idx; | ||
2391 | |||
2392 | /* find the first existing range after the new one */ | ||
2393 | ✗ | for (idx = 0; idx < rl->nb_ranges; idx++) | |
2394 | ✗ | if (rl->ranges[idx].start > start) | |
2395 | ✗ | break; | |
2396 | |||
2397 | /* check for overlap */ | ||
2398 | ✗ | if (idx > 0) { | |
2399 | ✗ | Range *prev = &rl->ranges[idx - 1]; | |
2400 | ✗ | if (prev->start + prev->len > start) | |
2401 | ✗ | return AVERROR(EINVAL); | |
2402 | } | ||
2403 | ✗ | if (idx < rl->nb_ranges) { | |
2404 | ✗ | Range *next = &rl->ranges[idx]; | |
2405 | ✗ | if (start + len > next->start) | |
2406 | ✗ | return AVERROR(EINVAL); | |
2407 | } | ||
2408 | |||
2409 | ✗ | tmp = av_fast_realloc(rl->ranges, &rl->ranges_allocated, | |
2410 | ✗ | (rl->nb_ranges + 1) * sizeof(*rl->ranges)); | |
2411 | ✗ | if (!tmp) | |
2412 | ✗ | return AVERROR(ENOMEM); | |
2413 | ✗ | rl->ranges = tmp; | |
2414 | |||
2415 | ✗ | memmove(rl->ranges + idx + 1, rl->ranges + idx, | |
2416 | ✗ | sizeof(*rl->ranges) * (rl->nb_ranges - idx)); | |
2417 | ✗ | rl->ranges[idx].start = start; | |
2418 | ✗ | rl->ranges[idx].len = len; | |
2419 | ✗ | rl->nb_ranges++; | |
2420 | |||
2421 | /* merge ranges */ | ||
2422 | ✗ | if (idx > 0) { | |
2423 | ✗ | Range *prev = &rl->ranges[idx - 1]; | |
2424 | ✗ | Range *cur = &rl->ranges[idx]; | |
2425 | ✗ | if (prev->start + prev->len == cur->start) { | |
2426 | ✗ | prev->len += cur->len; | |
2427 | ✗ | memmove(rl->ranges + idx - 1, rl->ranges + idx, | |
2428 | ✗ | sizeof(*rl->ranges) * (rl->nb_ranges - idx)); | |
2429 | ✗ | rl->nb_ranges--; | |
2430 | ✗ | idx--; | |
2431 | } | ||
2432 | } | ||
2433 | ✗ | if (idx < rl->nb_ranges - 1) { | |
2434 | ✗ | Range *cur = &rl->ranges[idx]; | |
2435 | ✗ | Range *next = &rl->ranges[idx + 1]; | |
2436 | ✗ | if (cur->start + cur->len == next->start) { | |
2437 | ✗ | cur->len += next->len; | |
2438 | ✗ | memmove(rl->ranges + idx, rl->ranges + idx + 1, | |
2439 | ✗ | sizeof(*rl->ranges) * (rl->nb_ranges - idx - 1)); | |
2440 | ✗ | rl->nb_ranges--; | |
2441 | } | ||
2442 | } | ||
2443 | |||
2444 | ✗ | return 0; | |
2445 | } | ||
2446 |