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