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