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