FFmpeg coverage

Directory: ../../../ffmpeg/
File: src/libswscale/graph.c
Date: 2025-11-28 06:05:02
Exec Total Coverage
Lines: 366 453 80.8%
Functions: 26 29 89.7%
Branches: 180 254 70.9%
Line Branch Exec Source
1 /*
2 * Copyright (C) 2024 Niklas Haas
3 *
4 * This file is part of FFmpeg.
5 *
6 * FFmpeg is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * FFmpeg is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with FFmpeg; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19 */
20
21 #include "libavutil/avassert.h"
22 #include "libavutil/error.h"
23 #include "libavutil/imgutils.h"
24 #include "libavutil/macros.h"
25 #include "libavutil/mem.h"
26 #include "libavutil/opt.h"
27 #include "libavutil/pixdesc.h"
28 #include "libavutil/slicethread.h"
29
30 #include "libswscale/swscale.h"
31 #include "libswscale/format.h"
32
33 #include "cms.h"
34 #include "lut3d.h"
35 #include "swscale_internal.h"
36 #include "graph.h"
37 #include "ops.h"
38
39 41650 static int pass_alloc_output(SwsPass *pass)
40 {
41
3/4
✓ Branch 0 taken 1353 times.
✓ Branch 1 taken 40297 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 1353 times.
 41650 if (!pass || pass->output.fmt != AV_PIX_FMT_NONE)
42 40297 return 0;
43 1353 pass->output.fmt = pass->format;
44 1353 return av_image_alloc(pass->output.data, pass->output.linesize, pass->width,
45 1353 pass->num_slices * pass->slice_h, pass->format, 64);
46 }
47
48 41650 SwsPass *ff_sws_graph_add_pass(SwsGraph *graph, enum AVPixelFormat fmt,
49 int width, int height, SwsPass *input,
50 int align, void *priv, sws_filter_run_t run)
51 {
52 int ret;
53 41650 SwsPass *pass = av_mallocz(sizeof(*pass));
54
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 41650 times.
 41650 if (!pass)
55 ✗ return NULL;
56
57 41650 pass->graph = graph;
58 41650 pass->run = run;
59 41650 pass->priv = priv;
60 41650 pass->format = fmt;
61 41650 pass->width = width;
62 41650 pass->height = height;
63 41650 pass->input = input;
64 41650 pass->output.fmt = AV_PIX_FMT_NONE;
65
66 41650 ret = pass_alloc_output(input);
67
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 41650 times.
 41650 if (ret < 0) {
68 ✗ av_free(pass);
69 ✗ return NULL;
70 }
71
72
2/2
✓ Branch 0 taken 55 times.
✓ Branch 1 taken 41595 times.
 41650 if (!align) {
73 55 pass->slice_h = pass->height;
74 55 pass->num_slices = 1;
75 } else {
76 41595 pass->slice_h = (pass->height + graph->num_threads - 1) / graph->num_threads;
77 41595 pass->slice_h = FFALIGN(pass->slice_h, align);
78 41595 pass->num_slices = (pass->height + pass->slice_h - 1) / pass->slice_h;
79 }
80
81 41650 ret = av_dynarray_add_nofree(&graph->passes, &graph->num_passes, pass);
82
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 41650 times.
 41650 if (ret < 0)
83 ✗ av_freep(&pass);
84 41650 return pass;
85 }
86
87 /* Wrapper around ff_sws_graph_add_pass() that chains a pass "in-place" */
88 1352 static int pass_append(SwsGraph *graph, enum AVPixelFormat fmt, int w, int h,
89 SwsPass **pass, int align, void *priv, sws_filter_run_t run)
90 {
91 1352 SwsPass *new = ff_sws_graph_add_pass(graph, fmt, w, h, *pass, align, priv, run);
92
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1352 times.
 1352 if (!new)
93 ✗ return AVERROR(ENOMEM);
94 1352 *pass = new;
95 1352 return 0;
96 }
97
98 130 static void run_copy(const SwsImg *out_base, const SwsImg *in_base,
99 int y, int h, const SwsPass *pass)
100 {
101 130 SwsImg in = ff_sws_img_shift(in_base, y);
102 130 SwsImg out = ff_sws_img_shift(out_base, y);
103
104
3/4
✓ Branch 0 taken 520 times.
✓ Branch 1 taken 130 times.
✓ Branch 2 taken 520 times.
✗ Branch 3 not taken.
 650 for (int i = 0; i < FF_ARRAY_ELEMS(out.data) && out.data[i]; i++) {
105 520 const int lines = h >> ff_fmt_vshift(in.fmt, i);
106 av_assert1(in.data[i]);
107
108
1/2
✓ Branch 0 taken 520 times.
✗ Branch 1 not taken.
 520 if (in.linesize[i] == out.linesize[i]) {
109 520 memcpy(out.data[i], in.data[i], lines * out.linesize[i]);
110 } else {
111 ✗ const int linesize = FFMIN(out.linesize[i], in.linesize[i]);
112 ✗ for (int j = 0; j < lines; j++) {
113 ✗ memcpy(out.data[i], in.data[i], linesize);
114 ✗ in.data[i] += in.linesize[i];
115 ✗ out.data[i] += out.linesize[i];
116 }
117 }
118 }
119 130 }
120
121 1094 static void run_rgb0(const SwsImg *out, const SwsImg *in, int y, int h,
122 const SwsPass *pass)
123 {
124 1094 SwsInternal *c = pass->priv;
125 1094 const int x0 = c->src0Alpha - 1;
126 1094 const int w4 = 4 * pass->width;
127 1094 const int src_stride = in->linesize[0];
128 1094 const int dst_stride = out->linesize[0];
129 1094 const uint8_t *src = in->data[0] + y * src_stride;
130 1094 uint8_t *dst = out->data[0] + y * dst_stride;
131
132
2/2
✓ Branch 0 taken 104502 times.
✓ Branch 1 taken 1094 times.
 105596 for (int y = 0; y < h; y++) {
133 104502 memcpy(dst, src, w4 * sizeof(*dst));
134
2/2
✓ Branch 0 taken 12453842 times.
✓ Branch 1 taken 104502 times.
 12558344 for (int x = x0; x < w4; x += 4)
135 12453842 dst[x] = 0xFF;
136
137 104502 src += src_stride;
138 104502 dst += dst_stride;
139 }
140 1094 }
141
142 3355 static void run_xyz2rgb(const SwsImg *out, const SwsImg *in, int y, int h,
143 const SwsPass *pass)
144 {
145 3355 ff_xyz12Torgb48(pass->priv, out->data[0] + y * out->linesize[0], out->linesize[0],
146 3355 in->data[0] + y * in->linesize[0], in->linesize[0],
147 3355 pass->width, h);
148 3355 }
149
150 3160 static void run_rgb2xyz(const SwsImg *out, const SwsImg *in, int y, int h,
151 const SwsPass *pass)
152 {
153 3160 ff_rgb48Toxyz12(pass->priv, out->data[0] + y * out->linesize[0], out->linesize[0],
154 3160 in->data[0] + y * in->linesize[0], in->linesize[0],
155 3160 pass->width, h);
156 3160 }
157
158 /***********************************************************************
159 * Internal ff_swscale() wrapper. This reuses the legacy scaling API. *
160 * This is considered fully deprecated, and will be replaced by a full *
161 * reimplementation ASAP. *
162 ***********************************************************************/
163
164 25757 static void free_legacy_swscale(void *priv)
165 {
166 25757 SwsContext *sws = priv;
167 25757 sws_free_context(&sws);
168 25757 }
169
170 158171 static void setup_legacy_swscale(const SwsImg *out, const SwsImg *in,
171 const SwsPass *pass)
172 {
173 158171 const SwsGraph *graph = pass->graph;
174 158171 const SwsImg *in_orig = &graph->exec.input;
175 158171 SwsContext *sws = pass->priv;
176 158171 SwsInternal *c = sws_internal(sws);
177
5/6
✓ Branch 0 taken 98126 times.
✓ Branch 1 taken 60045 times.
✓ Branch 2 taken 875 times.
✓ Branch 3 taken 97251 times.
✓ Branch 4 taken 875 times.
✗ Branch 5 not taken.
 158171 if (sws->flags & SWS_BITEXACT && sws->dither == SWS_DITHER_ED && c->dither_error[0]) {
178
2/2
✓ Branch 0 taken 3500 times.
✓ Branch 1 taken 875 times.
 4375 for (int i = 0; i < 4; i++)
179 3500 memset(c->dither_error[i], 0, sizeof(c->dither_error[0][0]) * (sws->dst_w + 2));
180 }
181
182
2/2
✓ Branch 1 taken 6071 times.
✓ Branch 2 taken 152100 times.
 158171 if (usePal(sws->src_format))
183 6071 ff_update_palette(c, (const uint32_t *) in_orig->data[1]);
184 158171 }
185
186 698180 static inline SwsContext *slice_ctx(const SwsPass *pass, int y)
187 {
188 698180 SwsContext *sws = pass->priv;
189 698180 SwsInternal *parent = sws_internal(sws);
190
2/2
✓ Branch 0 taken 90534 times.
✓ Branch 1 taken 607646 times.
 698180 if (pass->num_slices == 1)
191 90534 return sws;
192
193 av_assert1(parent->nb_slice_ctx == pass->num_slices);
194 607646 sws = parent->slice_ctx[y / pass->slice_h];
195
196
2/2
✓ Branch 1 taken 35135 times.
✓ Branch 2 taken 572511 times.
 607646 if (usePal(sws->src_format)) {
197 35135 SwsInternal *sub = sws_internal(sws);
198 35135 memcpy(sub->pal_yuv, parent->pal_yuv, sizeof(sub->pal_yuv));
199 35135 memcpy(sub->pal_rgb, parent->pal_rgb, sizeof(sub->pal_rgb));
200 }
201
202 607646 return sws;
203 }
204
205 103097 static void run_legacy_unscaled(const SwsImg *out, const SwsImg *in_base,
206 int y, int h, const SwsPass *pass)
207 {
208 103097 SwsContext *sws = slice_ctx(pass, y);
209 103097 SwsInternal *c = sws_internal(sws);
210 103097 const SwsImg in = ff_sws_img_shift(in_base, y);
211
212 103097 c->convert_unscaled(c, (const uint8_t *const *) in.data, in.linesize, y, h,
213 103097 out->data, out->linesize);
214 103097 }
215
216 595083 static void run_legacy_swscale(const SwsImg *out_base, const SwsImg *in,
217 int y, int h, const SwsPass *pass)
218 {
219 595083 SwsContext *sws = slice_ctx(pass, y);
220 595083 SwsInternal *c = sws_internal(sws);
221 595083 const SwsImg out = ff_sws_img_shift(out_base, y);
222
223 595083 ff_swscale(c, (const uint8_t *const *) in->data, in->linesize, 0,
224 sws->src_h, out.data, out.linesize, y, h);
225 595083 }
226
227 51512 static void get_chroma_pos(SwsGraph *graph, int *h_chr_pos, int *v_chr_pos,
228 const SwsFormat *fmt)
229 {
230 51512 enum AVChromaLocation chroma_loc = fmt->loc;
231 51512 const int sub_x = fmt->desc->log2_chroma_w;
232 51512 const int sub_y = fmt->desc->log2_chroma_h;
233 int x_pos, y_pos;
234
235 /* Explicitly default to center siting for compatibility with swscale */
236
2/2
✓ Branch 0 taken 51511 times.
✓ Branch 1 taken 1 times.
 51512 if (chroma_loc == AVCHROMA_LOC_UNSPECIFIED) {
237 51511 chroma_loc = AVCHROMA_LOC_CENTER;
238
4/4
✓ Branch 0 taken 45445 times.
✓ Branch 1 taken 6066 times.
✓ Branch 2 taken 240 times.
✓ Branch 3 taken 45205 times.
 51511 graph->incomplete |= sub_x || sub_y;
239 }
240
241 /* av_chroma_location_enum_to_pos() always gives us values in the range from
242 * 0 to 256, but we need to adjust this to the true value range of the
243 * subsampling grid, which may be larger for h/v_sub > 1 */
244 51512 av_chroma_location_enum_to_pos(&x_pos, &y_pos, chroma_loc);
245 51512 x_pos *= (1 << sub_x) - 1;
246 51512 y_pos *= (1 << sub_y) - 1;
247
248 /* Fix vertical chroma position for interlaced frames */
249
3/4
✓ Branch 0 taken 4888 times.
✓ Branch 1 taken 46624 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 4888 times.
 51512 if (sub_y && fmt->interlaced) {
250 /* When vertically subsampling, chroma samples are effectively only
251 * placed next to even rows. To access them from the odd field, we need
252 * to account for this shift by offsetting the distance of one luma row.
253 *
254 * For 4x vertical subsampling (v_sub == 2), they are only placed
255 * next to every *other* even row, so we need to shift by three luma
256 * rows to get to the chroma sample. */
257 ✗ if (graph->field == FIELD_BOTTOM)
258 ✗ y_pos += (256 << sub_y) - 256;
259
260 /* Luma row distance is doubled for fields, so halve offsets */
261 ✗ y_pos >>= 1;
262 }
263
264 /* Explicitly strip chroma offsets when not subsampling, because it
265 * interferes with the operation of flags like SWS_FULL_CHR_H_INP */
266
2/2
✓ Branch 0 taken 6067 times.
✓ Branch 1 taken 45445 times.
 51512 *h_chr_pos = sub_x ? x_pos : -513;
267
2/2
✓ Branch 0 taken 4888 times.
✓ Branch 1 taken 46624 times.
 51512 *v_chr_pos = sub_y ? y_pos : -513;
268 51512 }
269
270 103024 static void legacy_chr_pos(SwsGraph *graph, int *chr_pos, int override, int *warned)
271 {
272
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 103024 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 103024 if (override == -513 || override == *chr_pos)
273 103024 return;
274
275 ✗ if (!*warned) {
276 ✗ av_log(NULL, AV_LOG_WARNING,
277 "Setting chroma position directly is deprecated, make sure "
278 "the frame is tagged with the correct chroma location.\n");
279 ✗ *warned = 1;
280 }
281
282 ✗ *chr_pos = override;
283 }
284
285 /* Takes over ownership of `sws` */
286 25758 static int init_legacy_subpass(SwsGraph *graph, SwsContext *sws,
287 SwsPass *input, SwsPass **output)
288 {
289 25758 SwsInternal *c = sws_internal(sws);
290 25758 const int src_w = sws->src_w, src_h = sws->src_h;
291 25758 const int dst_w = sws->dst_w, dst_h = sws->dst_h;
292
4/4
✓ Branch 0 taken 25302 times.
✓ Branch 1 taken 456 times.
✓ Branch 2 taken 25292 times.
✓ Branch 3 taken 10 times.
 25758 const int unscaled = src_w == dst_w && src_h == dst_h;
293 25758 int align = c->dst_slice_align;
294 25758 SwsPass *pass = NULL;
295 int ret;
296
297
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 25757 times.
 25758 if (c->cascaded_context[0]) {
298
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
 1 const int num_cascaded = c->cascaded_context[2] ? 3 : 2;
299
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 1 times.
 3 for (int i = 0; i < num_cascaded; i++) {
300 2 const int is_last = i + 1 == num_cascaded;
301
302 /* Steal cascaded context, so we can manage its lifetime independently */
303 2 SwsContext *sub = c->cascaded_context[i];
304 2 c->cascaded_context[i] = NULL;
305
306
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 1 times.
 2 ret = init_legacy_subpass(graph, sub, input, is_last ? output : &input);
307
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
 2 if (ret < 0)
308 ✗ break;
309 }
310
311 1 sws_free_context(&sws);
312 1 return ret;
313 }
314
315
3/4
✓ Branch 0 taken 55 times.
✓ Branch 1 taken 25702 times.
✓ Branch 2 taken 55 times.
✗ Branch 3 not taken.
 25757 if (sws->dither == SWS_DITHER_ED && !c->convert_unscaled)
316 55 align = 0; /* disable slice threading */
317
318
6/6
✓ Branch 0 taken 585 times.
✓ Branch 1 taken 25172 times.
✓ Branch 2 taken 581 times.
✓ Branch 3 taken 4 times.
✓ Branch 5 taken 526 times.
✓ Branch 6 taken 55 times.
 25757 if (c->src0Alpha && !c->dst0Alpha && isALPHA(sws->dst_format)) {
319 526 ret = pass_append(graph, AV_PIX_FMT_RGBA, src_w, src_h, &input, 1, c, run_rgb0);
320
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 526 times.
 526 if (ret < 0) {
321 ✗ sws_free_context(&sws);
322 ✗ return ret;
323 }
324 }
325
326
6/6
✓ Branch 0 taken 532 times.
✓ Branch 1 taken 25225 times.
✓ Branch 2 taken 4 times.
✓ Branch 3 taken 528 times.
✓ Branch 4 taken 2 times.
✓ Branch 5 taken 2 times.
 25757 if (c->srcXYZ && !(c->dstXYZ && unscaled)) {
327 530 ret = pass_append(graph, AV_PIX_FMT_RGB48, src_w, src_h, &input, 1, c, run_xyz2rgb);
328
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 530 times.
 530 if (ret < 0) {
329 ✗ sws_free_context(&sws);
330 ✗ return ret;
331 }
332 }
333
334 25757 pass = ff_sws_graph_add_pass(graph, sws->dst_format, dst_w, dst_h, input, align, sws,
335
2/2
✓ Branch 0 taken 3844 times.
✓ Branch 1 taken 21913 times.
 25757 c->convert_unscaled ? run_legacy_unscaled : run_legacy_swscale);
336
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 25757 times.
 25757 if (!pass) {
337 ✗ sws_free_context(&sws);
338 ✗ return AVERROR(ENOMEM);
339 }
340 25757 pass->setup = setup_legacy_swscale;
341 25757 pass->free = free_legacy_swscale;
342
343 /**
344 * For slice threading, we need to create sub contexts, similar to how
345 * swscale normally handles it internally. The most important difference
346 * is that we handle cascaded contexts before threaded contexts; whereas
347 * context_init_threaded() does it the other way around.
348 */
349
350
2/2
✓ Branch 0 taken 2575 times.
✓ Branch 1 taken 23182 times.
 25757 if (pass->num_slices > 1) {
351 2575 c->slice_ctx = av_calloc(pass->num_slices, sizeof(*c->slice_ctx));
352
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2575 times.
 2575 if (!c->slice_ctx)
353 ✗ return AVERROR(ENOMEM);
354
355
2/2
✓ Branch 0 taken 23082 times.
✓ Branch 1 taken 2575 times.
 25657 for (int i = 0; i < pass->num_slices; i++) {
356 SwsContext *slice;
357 SwsInternal *c2;
358 23082 slice = c->slice_ctx[i] = sws_alloc_context();
359
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 23082 times.
 23082 if (!slice)
360 ✗ return AVERROR(ENOMEM);
361 23082 c->nb_slice_ctx++;
362
363 23082 c2 = sws_internal(slice);
364 23082 c2->parent = sws;
365
366 23082 ret = av_opt_copy(slice, sws);
367
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 23082 times.
 23082 if (ret < 0)
368 ✗ return ret;
369
370 23082 ret = ff_sws_init_single_context(slice, NULL, NULL);
371
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 23082 times.
 23082 if (ret < 0)
372 ✗ return ret;
373
374 23082 sws_setColorspaceDetails(slice, c->srcColorspaceTable,
375 23082 slice->src_range, c->dstColorspaceTable,
376 slice->dst_range, c->brightness, c->contrast,
377 c->saturation);
378
379
2/2
✓ Branch 0 taken 92328 times.
✓ Branch 1 taken 23082 times.
 115410 for (int i = 0; i < FF_ARRAY_ELEMS(c->srcColorspaceTable); i++) {
380 92328 c2->srcColorspaceTable[i] = c->srcColorspaceTable[i];
381 92328 c2->dstColorspaceTable[i] = c->dstColorspaceTable[i];
382 }
383 }
384 }
385
386
6/6
✓ Branch 0 taken 298 times.
✓ Branch 1 taken 25459 times.
✓ Branch 2 taken 4 times.
✓ Branch 3 taken 294 times.
✓ Branch 4 taken 2 times.
✓ Branch 5 taken 2 times.
 25757 if (c->dstXYZ && !(c->srcXYZ && unscaled)) {
387 296 ret = pass_append(graph, AV_PIX_FMT_RGB48, dst_w, dst_h, &pass, 1, c, run_rgb2xyz);
388
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 296 times.
 296 if (ret < 0)
389 ✗ return ret;
390 }
391
392 25757 *output = pass;
393 25757 return 0;
394 }
395
396 25756 static int add_legacy_sws_pass(SwsGraph *graph, SwsFormat src, SwsFormat dst,
397 SwsPass *input, SwsPass **output)
398 {
399 25756 int ret, warned = 0;
400 25756 SwsContext *const ctx = graph->ctx;
401 25756 SwsContext *sws = sws_alloc_context();
402
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 25756 times.
 25756 if (!sws)
403 ✗ return AVERROR(ENOMEM);
404
405 25756 sws->flags = ctx->flags;
406 25756 sws->dither = ctx->dither;
407 25756 sws->alpha_blend = ctx->alpha_blend;
408 25756 sws->gamma_flag = ctx->gamma_flag;
409
410 25756 sws->src_w = src.width;
411 25756 sws->src_h = src.height;
412 25756 sws->src_format = src.format;
413 25756 sws->src_range = src.range == AVCOL_RANGE_JPEG;
414
415 25756 sws->dst_w = dst.width;
416 25756 sws->dst_h = dst.height;
417 25756 sws->dst_format = dst.format;
418 25756 sws->dst_range = dst.range == AVCOL_RANGE_JPEG;
419 25756 get_chroma_pos(graph, &sws->src_h_chr_pos, &sws->src_v_chr_pos, &src);
420 25756 get_chroma_pos(graph, &sws->dst_h_chr_pos, &sws->dst_v_chr_pos, &dst);
421
422 25756 graph->incomplete |= src.range == AVCOL_RANGE_UNSPECIFIED;
423 25756 graph->incomplete |= dst.range == AVCOL_RANGE_UNSPECIFIED;
424
425 /* Allow overriding chroma position with the legacy API */
426 25756 legacy_chr_pos(graph, &sws->src_h_chr_pos, ctx->src_h_chr_pos, &warned);
427 25756 legacy_chr_pos(graph, &sws->src_v_chr_pos, ctx->src_v_chr_pos, &warned);
428 25756 legacy_chr_pos(graph, &sws->dst_h_chr_pos, ctx->dst_h_chr_pos, &warned);
429 25756 legacy_chr_pos(graph, &sws->dst_v_chr_pos, ctx->dst_v_chr_pos, &warned);
430
431 25756 sws->scaler_params[0] = ctx->scaler_params[0];
432 25756 sws->scaler_params[1] = ctx->scaler_params[1];
433
434 25756 ret = sws_init_context(sws, NULL, NULL);
435
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 25756 times.
 25756 if (ret < 0) {
436 ✗ sws_free_context(&sws);
437 ✗ return ret;
438 }
439
440 /* Set correct color matrices */
441 {
442 int in_full, out_full, brightness, contrast, saturation;
443 const int *inv_table, *table;
444 25756 sws_getColorspaceDetails(sws, (int **)&inv_table, &in_full,
445 (int **)&table, &out_full,
446 &brightness, &contrast, &saturation);
447
448 25756 inv_table = sws_getCoefficients(src.csp);
449 25756 table = sws_getCoefficients(dst.csp);
450
451
2/2
✓ Branch 0 taken 11870 times.
✓ Branch 1 taken 13886 times.
 37626 graph->incomplete |= src.csp != dst.csp &&
452
2/2
✓ Branch 0 taken 9610 times.
✓ Branch 1 taken 2260 times.
 11870 (src.csp == AVCOL_SPC_UNSPECIFIED ||
453
2/2
✓ Branch 0 taken 9600 times.
✓ Branch 1 taken 10 times.
 9610 dst.csp == AVCOL_SPC_UNSPECIFIED);
454
455 25756 sws_setColorspaceDetails(sws, inv_table, in_full, table, out_full,
456 brightness, contrast, saturation);
457 }
458
459 25756 return init_legacy_subpass(graph, sws, input, output);
460 }
461
462 /*********************
463 * Format conversion *
464 *********************/
465
466 #if CONFIG_UNSTABLE
467 40036 static int add_convert_pass(SwsGraph *graph, SwsFormat src, SwsFormat dst,
468 SwsPass *input, SwsPass **output)
469 {
470 40036 const SwsPixelType type = SWS_PIXEL_F32;
471
472 40036 SwsContext *ctx = graph->ctx;
473 40036 SwsOpList *ops = NULL;
474 40036 int ret = AVERROR(ENOTSUP);
475
476 /* Mark the entire new ops infrastructure as experimental for now */
477
2/2
✓ Branch 0 taken 23266 times.
✓ Branch 1 taken 16770 times.
 40036 if (!(ctx->flags & SWS_UNSTABLE))
478 23266 goto fail;
479
480 /* The new format conversion layer cannot scale for now */
481
2/4
✓ Branch 0 taken 16770 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 16770 times.
✗ Branch 3 not taken.
 16770 if (src.width != dst.width || src.height != dst.height ||
482
2/4
✓ Branch 0 taken 16770 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 16770 times.
✗ Branch 3 not taken.
 16770 src.desc->log2_chroma_h || src.desc->log2_chroma_w ||
483
2/4
✓ Branch 0 taken 16770 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 16770 times.
 16770 dst.desc->log2_chroma_h || dst.desc->log2_chroma_w)
484 ✗ goto fail;
485
486 /* The new code does not yet support alpha blending */
487
2/2
✓ Branch 0 taken 4644 times.
✓ Branch 1 taken 12126 times.
 16770 if (src.desc->flags & AV_PIX_FMT_FLAG_ALPHA &&
488
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4644 times.
 4644 ctx->alpha_blend != SWS_ALPHA_BLEND_NONE)
489 ✗ goto fail;
490
491 16770 ops = ff_sws_op_list_alloc();
492
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 16770 times.
 16770 if (!ops)
493 ✗ return AVERROR(ENOMEM);
494 16770 ops->src = src;
495 16770 ops->dst = dst;
496
497 16770 ret = ff_sws_decode_pixfmt(ops, src.format);
498
2/2
✓ Branch 0 taken 1290 times.
✓ Branch 1 taken 15480 times.
 16770 if (ret < 0)
499 1290 goto fail;
500 15480 ret = ff_sws_decode_colors(ctx, type, ops, src, &graph->incomplete);
501
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 15480 times.
 15480 if (ret < 0)
502 ✗ goto fail;
503 15480 ret = ff_sws_encode_colors(ctx, type, ops, dst, &graph->incomplete);
504
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 15480 times.
 15480 if (ret < 0)
505 ✗ goto fail;
506 15480 ret = ff_sws_encode_pixfmt(ops, dst.format);
507
2/2
✓ Branch 0 taken 1200 times.
✓ Branch 1 taken 14280 times.
 15480 if (ret < 0)
508 1200 goto fail;
509
510 14280 av_log(ctx, AV_LOG_VERBOSE, "Conversion pass for %s -> %s:\n",
511 av_get_pix_fmt_name(src.format), av_get_pix_fmt_name(dst.format));
512
513 14280 av_log(ctx, AV_LOG_DEBUG, "Unoptimized operation list:\n");
514 14280 ff_sws_op_list_print(ctx, AV_LOG_DEBUG, ops);
515 14280 av_log(ctx, AV_LOG_DEBUG, "Optimized operation list:\n");
516
517 14280 ff_sws_op_list_optimize(ops);
518
2/2
✓ Branch 0 taken 21 times.
✓ Branch 1 taken 14259 times.
 14280 if (ops->num_ops == 0) {
519 21 av_log(ctx, AV_LOG_VERBOSE, " optimized into memcpy\n");
520 21 ff_sws_op_list_free(&ops);
521 21 *output = input;
522 21 return 0;
523 }
524
525 14259 ff_sws_op_list_print(ctx, AV_LOG_VERBOSE, ops);
526
527 14259 ret = ff_sws_compile_pass(graph, ops, 0, dst, input, output);
528
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 14259 times.
 14259 if (ret < 0)
529 ✗ goto fail;
530
531 14259 ret = 0;
532 /* fall through */
533
534 40015 fail:
535 40015 ff_sws_op_list_free(&ops);
536
2/2
✓ Branch 0 taken 25756 times.
✓ Branch 1 taken 14259 times.
 40015 if (ret == AVERROR(ENOTSUP))
537 25756 return add_legacy_sws_pass(graph, src, dst, input, output);
538 14259 return ret;
539 }
540 #else
541 #define add_convert_pass add_legacy_sws_pass
542 #endif
543
544
545 /**************************
546 * Gamut and tone mapping *
547 **************************/
548
549 ✗ static void free_lut3d(void *priv)
550 {
551 ✗ SwsLut3D *lut = priv;
552 ✗ ff_sws_lut3d_free(&lut);
553 ✗ }
554
555 ✗ static void setup_lut3d(const SwsImg *out, const SwsImg *in, const SwsPass *pass)
556 {
557 ✗ SwsLut3D *lut = pass->priv;
558
559 /* Update dynamic frame metadata from the original source frame */
560 ✗ ff_sws_lut3d_update(lut, &pass->graph->src.color);
561 ✗ }
562
563 ✗ static void run_lut3d(const SwsImg *out_base, const SwsImg *in_base,
564 int y, int h, const SwsPass *pass)
565 {
566 ✗ SwsLut3D *lut = pass->priv;
567 ✗ const SwsImg in = ff_sws_img_shift(in_base, y);
568 ✗ const SwsImg out = ff_sws_img_shift(out_base, y);
569
570 ✗ ff_sws_lut3d_apply(lut, in.data[0], in.linesize[0], out.data[0],
571 ✗ out.linesize[0], pass->width, h);
572 ✗ }
573
574 40297 static int adapt_colors(SwsGraph *graph, SwsFormat src, SwsFormat dst,
575 SwsPass *input, SwsPass **output)
576 {
577 enum AVPixelFormat fmt_in, fmt_out;
578 40297 SwsColorMap map = {0};
579 SwsLut3D *lut;
580 SwsPass *pass;
581 int ret;
582
583 /**
584 * Grayspace does not really have primaries, so just force the use of
585 * the equivalent other primary set to avoid a conversion. Technically,
586 * this does affect the weights used for the Grayscale conversion, but
587 * in practise, that should give the expected results more often than not.
588 */
589
2/2
✓ Branch 1 taken 2438 times.
✓ Branch 2 taken 37859 times.
 40297 if (isGray(dst.format)) {
590 2438 dst.color = src.color;
591
2/2
✓ Branch 1 taken 3999 times.
✓ Branch 2 taken 33860 times.
 37859 } else if (isGray(src.format)) {
592 3999 src.color = dst.color;
593 }
594
595 /* Fully infer color spaces before color mapping logic */
596 40297 graph->incomplete |= ff_infer_colors(&src.color, &dst.color);
597
598 40297 map.intent = graph->ctx->intent;
599 40297 map.src = src.color;
600 40297 map.dst = dst.color;
601
602
1/2
✓ Branch 1 taken 40297 times.
✗ Branch 2 not taken.
 40297 if (ff_sws_color_map_noop(&map))
603 40297 return 0;
604
605 ✗ lut = ff_sws_lut3d_alloc();
606 ✗ if (!lut)
607 ✗ return AVERROR(ENOMEM);
608
609 ✗ fmt_in = ff_sws_lut3d_pick_pixfmt(src, 0);
610 ✗ fmt_out = ff_sws_lut3d_pick_pixfmt(dst, 1);
611 ✗ if (fmt_in != src.format) {
612 ✗ SwsFormat tmp = src;
613 ✗ tmp.format = fmt_in;
614 ✗ ret = add_convert_pass(graph, src, tmp, input, &input);
615 ✗ if (ret < 0)
616 ✗ return ret;
617 }
618
619 ✗ ret = ff_sws_lut3d_generate(lut, fmt_in, fmt_out, &map);
620 ✗ if (ret < 0) {
621 ✗ ff_sws_lut3d_free(&lut);
622 ✗ return ret;
623 }
624
625 ✗ pass = ff_sws_graph_add_pass(graph, fmt_out, src.width, src.height,
626 input, 1, lut, run_lut3d);
627 ✗ if (!pass) {
628 ✗ ff_sws_lut3d_free(&lut);
629 ✗ return AVERROR(ENOMEM);
630 }
631 ✗ pass->setup = setup_lut3d;
632 ✗ pass->free = free_lut3d;
633
634 ✗ *output = pass;
635 ✗ return 0;
636 }
637
638 /***************************************
639 * Main filter graph construction code *
640 ***************************************/
641
642 40297 static int init_passes(SwsGraph *graph)
643 {
644 40297 SwsFormat src = graph->src;
645 40297 SwsFormat dst = graph->dst;
646 40297 SwsPass *pass = NULL; /* read from main input image */
647 int ret;
648
649 40297 ret = adapt_colors(graph, src, dst, pass, &pass);
650
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 40297 times.
 40297 if (ret < 0)
651 ✗ return ret;
652
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 40297 times.
 40297 src.format = pass ? pass->format : src.format;
653 40297 src.color = dst.color;
654
655
2/2
✓ Branch 1 taken 40036 times.
✓ Branch 2 taken 261 times.
 40297 if (!ff_fmt_equal(&src, &dst)) {
656 40036 ret = add_convert_pass(graph, src, dst, pass, &pass);
657
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 40036 times.
 40036 if (ret < 0)
658 ✗ return ret;
659 }
660
661
2/2
✓ Branch 0 taken 282 times.
✓ Branch 1 taken 40015 times.
 40297 if (!pass) {
662 /* No passes were added, so no operations were necessary */
663 282 graph->noop = 1;
664
665 /* Add threaded memcpy pass */
666 282 pass = ff_sws_graph_add_pass(graph, dst.format, dst.width, dst.height,
667 pass, 1, NULL, run_copy);
668
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 282 times.
 282 if (!pass)
669 ✗ return AVERROR(ENOMEM);
670 }
671
672 40297 return 0;
673 }
674
675 720178 static void sws_graph_worker(void *priv, int jobnr, int threadnr, int nb_jobs,
676 int nb_threads)
677 {
678 720178 SwsGraph *graph = priv;
679 720178 const SwsPass *pass = graph->exec.pass;
680
2/2
✓ Branch 0 taken 7627 times.
✓ Branch 1 taken 712551 times.
 720178 const SwsImg *input = pass->input ? &pass->input->output : &graph->exec.input;
681
2/2
✓ Branch 0 taken 7627 times.
✓ Branch 1 taken 712551 times.
 720178 const SwsImg *output = pass->output.fmt != AV_PIX_FMT_NONE ? &pass->output : &graph->exec.output;
682 720178 const int slice_y = jobnr * pass->slice_h;
683 720178 const int slice_h = FFMIN(pass->slice_h, pass->height - slice_y);
684
685 720178 pass->run(output, input, slice_y, slice_h, pass);
686 720178 }
687
688 40297 int ff_sws_graph_create(SwsContext *ctx, const SwsFormat *dst, const SwsFormat *src,
689 int field, SwsGraph **out_graph)
690 {
691 int ret;
692 40297 SwsGraph *graph = av_mallocz(sizeof(*graph));
693
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 40297 times.
 40297 if (!graph)
694 ✗ return AVERROR(ENOMEM);
695
696 40297 graph->ctx = ctx;
697 40297 graph->src = *src;
698 40297 graph->dst = *dst;
699 40297 graph->field = field;
700 40297 graph->opts_copy = *ctx;
701
702 40297 graph->exec.input.fmt = src->format;
703 40297 graph->exec.output.fmt = dst->format;
704
705 40297 ret = avpriv_slicethread_create(&graph->slicethread, (void *) graph,
706 sws_graph_worker, NULL, ctx->threads);
707
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 40297 times.
 40297 if (ret == AVERROR(ENOSYS))
708 ✗ graph->num_threads = 1;
709
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 40297 times.
 40297 else if (ret < 0)
710 ✗ goto error;
711 else
712 40297 graph->num_threads = ret;
713
714 40297 ret = init_passes(graph);
715
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 40297 times.
 40297 if (ret < 0)
716 ✗ goto error;
717
718 40297 *out_graph = graph;
719 40297 return 0;
720
721 ✗ error:
722 ✗ ff_sws_graph_free(&graph);
723 ✗ return ret;
724 }
725
726 387138 void ff_sws_graph_free(SwsGraph **pgraph)
727 {
728 387138 SwsGraph *graph = *pgraph;
729
2/2
✓ Branch 0 taken 346841 times.
✓ Branch 1 taken 40297 times.
 387138 if (!graph)
730 346841 return;
731
732 40297 avpriv_slicethread_free(&graph->slicethread);
733
734
2/2
✓ Branch 0 taken 41650 times.
✓ Branch 1 taken 40297 times.
 81947 for (int i = 0; i < graph->num_passes; i++) {
735 41650 SwsPass *pass = graph->passes[i];
736
2/2
✓ Branch 0 taken 40016 times.
✓ Branch 1 taken 1634 times.
 41650 if (pass->free)
737 40016 pass->free(pass->priv);
738
2/2
✓ Branch 0 taken 1353 times.
✓ Branch 1 taken 40297 times.
 41650 if (pass->output.fmt != AV_PIX_FMT_NONE)
739 1353 av_free(pass->output.data[0]);
740 41650 av_free(pass);
741 }
742 40297 av_free(graph->passes);
743
744 40297 av_free(graph);
745 40297 *pgraph = NULL;
746 }
747
748 /* Tests only options relevant to SwsGraph */
749 132672 static int opts_equal(const SwsContext *c1, const SwsContext *c2)
750 {
751 265344 return c1->flags == c2->flags &&
752
1/2
✓ Branch 0 taken 132672 times.
✗ Branch 1 not taken.
 132672 c1->threads == c2->threads &&
753
1/2
✓ Branch 0 taken 132672 times.
✗ Branch 1 not taken.
 132672 c1->dither == c2->dither &&
754
1/2
✓ Branch 0 taken 132672 times.
✗ Branch 1 not taken.
 132672 c1->alpha_blend == c2->alpha_blend &&
755
1/2
✓ Branch 0 taken 132672 times.
✗ Branch 1 not taken.
 132672 c1->gamma_flag == c2->gamma_flag &&
756
1/2
✓ Branch 0 taken 132672 times.
✗ Branch 1 not taken.
 132672 c1->src_h_chr_pos == c2->src_h_chr_pos &&
757
1/2
✓ Branch 0 taken 132672 times.
✗ Branch 1 not taken.
 132672 c1->src_v_chr_pos == c2->src_v_chr_pos &&
758
1/2
✓ Branch 0 taken 132672 times.
✗ Branch 1 not taken.
 132672 c1->dst_h_chr_pos == c2->dst_h_chr_pos &&
759
1/2
✓ Branch 0 taken 132672 times.
✗ Branch 1 not taken.
 132672 c1->dst_v_chr_pos == c2->dst_v_chr_pos &&
760
2/4
✓ Branch 0 taken 132672 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 132672 times.
✗ Branch 3 not taken.
 398016 c1->intent == c2->intent &&
761
1/2
✓ Branch 0 taken 132672 times.
✗ Branch 1 not taken.
 132672 !memcmp(c1->scaler_params, c2->scaler_params, sizeof(c1->scaler_params));
762
763 }
764
765 172969 int ff_sws_graph_reinit(SwsContext *ctx, const SwsFormat *dst, const SwsFormat *src,
766 int field, SwsGraph **out_graph)
767 {
768 172969 SwsGraph *graph = *out_graph;
769
6/6
✓ Branch 0 taken 166600 times.
✓ Branch 1 taken 6369 times.
✓ Branch 3 taken 149571 times.
✓ Branch 4 taken 17029 times.
✓ Branch 5 taken 132672 times.
✓ Branch 6 taken 16899 times.
 322540 if (graph && ff_fmt_equal(&graph->src, src) &&
770
1/2
✓ Branch 1 taken 132672 times.
✗ Branch 2 not taken.
 282243 ff_fmt_equal(&graph->dst, dst) &&
771 132672 opts_equal(ctx, &graph->opts_copy))
772 {
773 132672 ff_sws_graph_update_metadata(graph, &src->color);
774 132672 return 0;
775 }
776
777 40297 ff_sws_graph_free(out_graph);
778 40297 return ff_sws_graph_create(ctx, dst, src, field, out_graph);
779 }
780
781 132672 void ff_sws_graph_update_metadata(SwsGraph *graph, const SwsColor *color)
782 {
783
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 132672 times.
 132672 if (!color)
784 ✗ return;
785
786 132672 ff_color_update_dynamic(&graph->src.color, color);
787 }
788
789 172558 void ff_sws_graph_run(SwsGraph *graph, uint8_t *const out_data[4],
790 const int out_linesize[4],
791 const uint8_t *const in_data[4],
792 const int in_linesize[4])
793 {
794 172558 SwsImg *out = &graph->exec.output;
795 172558 SwsImg *in = &graph->exec.input;
796 172558 memcpy(out->data, out_data, sizeof(out->data));
797 172558 memcpy(out->linesize, out_linesize, sizeof(out->linesize));
798 172558 memcpy(in->data, in_data, sizeof(in->data));
799 172558 memcpy(in->linesize, in_linesize, sizeof(in->linesize));
800
801
2/2
✓ Branch 0 taken 175545 times.
✓ Branch 1 taken 172558 times.
 348103 for (int i = 0; i < graph->num_passes; i++) {
802 175545 const SwsPass *pass = graph->passes[i];
803 175545 graph->exec.pass = pass;
804
2/2
✓ Branch 0 taken 172430 times.
✓ Branch 1 taken 3115 times.
 175545 if (pass->setup) {
805
2/2
✓ Branch 0 taken 874 times.
✓ Branch 1 taken 171556 times.
 172430 pass->setup(pass->output.fmt != AV_PIX_FMT_NONE ? &pass->output : out,
806
2/2
✓ Branch 0 taken 2115 times.
✓ Branch 1 taken 170315 times.
 172430 pass->input ? &pass->input->output : in, pass);
807 }
808 175545 avpriv_slicethread_execute(graph->slicethread, pass->num_slices, 0);
809 }
810 172558 }
811