FFmpeg coverage

Directory: ../../../ffmpeg/
File: src/libswscale/ops_dispatch.c
Date: 2026-08-15 14:54:27
Exec Total Coverage
Lines: 424 469 90.4%
Functions: 20 20 100.0%
Branches: 233 291 80.1%
Line Branch Exec Source
1 /**
2 * Copyright (C) 2025 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/cpu.h"
23 #include "libavutil/mathematics.h"
24 #include "libavutil/mem.h"
25 #include "libavutil/mem_internal.h"
26 #include "libavutil/refstruct.h"
27
28 #include "ops.h"
29 #include "ops_internal.h"
30 #include "ops_dispatch.h"
31 #include "swscale_internal.h"
32
33 #define RET(x) \
34 do { \
35 if ((ret = (x)) < 0) \
36 goto fail; \
37 } while (0)
38
39 typedef struct SwsOpPass {
40 SwsCompiledOp comp;
41 SwsOpExec exec_base;
42 SwsOpExec exec_tail;
43 size_t num_blocks;
44 int tail_off_in;
45 int tail_off_out;
46 int tail_size_in;
47 int tail_size_out;
48 int planes_in;
49 int planes_out;
50 int pixel_bits_in;
51 int pixel_bits_out;
52 int idx_in[4];
53 int idx_out[4];
54 int palette_idx;
55 int *offsets_y;
56 int filter_size_h;
57 bool memcpy_first;
58 bool memcpy_last;
59 bool memcpy_out;
60 size_t tail_blocks;
61 uint8_t *tail_buf; /* extra memory for fixing unpadded tails */
62 unsigned int tail_buf_size;
63 } SwsOpPass;
64
65 1629383 static int compile_backend(SwsContext *ctx, const SwsOpBackend *backend,
66 const SwsOpList *ops, SwsCompiledOp *out)
67 {
68 SwsOpList *copy;
69 1629383 SwsCompiledOp compiled = {0};
70 1629383 int ret = 0;
71
72 1629383 copy = ff_sws_op_list_duplicate(ops);
73
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1629383 times.
 1629383 if (!copy)
74 ✗ return AVERROR(ENOMEM);
75
76 /* Ensure these are always set during compilation */
77 1629383 ff_sws_op_list_update_comps(copy);
78
79 1629383 ret = backend->compile(ctx, copy, &compiled);
80
2/2
✓ Branch 0 taken 587294 times.
✓ Branch 1 taken 1042089 times.
 1629383 if (ret < 0) {
81
1/2
✓ Branch 0 taken 587294 times.
✗ Branch 1 not taken.
 587294 int msg_lev = ret == AVERROR(ENOTSUP) ? AV_LOG_TRACE : AV_LOG_ERROR;
82 1174588 av_log(ctx, msg_lev, "Backend '%s' failed to compile operations: %s\n",
83 587294 backend->name, av_err2str(ret));
84 587294 goto fail;
85 }
86
87 1042089 compiled.backend = backend;
88 1042089 *out = compiled;
89
90 1042089 av_log(ctx, AV_LOG_VERBOSE, "Compiled using backend '%s': "
91 "block size = %d, over-read = {%d %d %d %d}, over-write = {%d %d %d %d}, "
92 1042089 "cpu flags = 0x%x\n", backend->name, out->block_size,
93 out->over_read[0], out->over_read[1],
94 out->over_read[2], out->over_read[3],
95 out->over_write[0], out->over_write[1],
96 out->over_write[2], out->over_write[3],
97 out->cpu_flags);
98
99 1042089 ff_sws_op_list_print(ctx, AV_LOG_VERBOSE, AV_LOG_TRACE, ops);
100
101 1629383 fail:
102 1629383 ff_sws_op_list_free(&copy);
103 1629383 return ret;
104 }
105
106 1476951 int ff_sws_ops_compile(SwsContext *ctx, const SwsOpBackend *backend,
107 const SwsOpList *ops, SwsCompiledOp *out)
108 {
109
2/2
✓ Branch 0 taken 1359063 times.
✓ Branch 1 taken 117888 times.
 1476951 if (backend)
110 1359063 return compile_backend(ctx, backend, ops, out);
111
112 117888 const SwsBackend enabled = ff_sws_enabled_backends(ctx);
113
2/2
✓ Branch 0 taken 270320 times.
✓ Branch 1 taken 31998 times.
 302318 for (int n = 0; ff_sws_op_backends[n]; n++) {
114 270320 const SwsOpBackend *backend = ff_sws_op_backends[n];
115
1/2
✓ Branch 0 taken 270320 times.
✗ Branch 1 not taken.
 270320 if (ops->src.hw_format != backend->hw_format ||
116
1/2
✓ Branch 0 taken 270320 times.
✗ Branch 1 not taken.
 270320 ops->dst.hw_format != backend->hw_format ||
117
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 270320 times.
 270320 !(enabled & backend->flags))
118 ✗ continue;
119
2/2
✓ Branch 1 taken 184430 times.
✓ Branch 2 taken 85890 times.
 270320 if (compile_backend(ctx, backend, ops, out) < 0)
120 184430 continue;
121
122 85890 return 0;
123 }
124
125 31998 return AVERROR(ENOTSUP);
126 }
127
128 1487116 void ff_sws_compiled_op_unref(SwsCompiledOp *comp)
129 {
130
2/2
✓ Branch 0 taken 96055 times.
✓ Branch 1 taken 1391061 times.
 1487116 if (comp->free)
131 96055 comp->free(comp->priv);
132
133 1487116 *comp = (SwsCompiledOp) {0};
134 1487116 }
135
136 1476951 static void op_pass_free(void *ptr)
137 {
138 1476951 SwsOpPass *p = ptr;
139
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1476951 times.
 1476951 if (!p)
140 ✗ return;
141
142 1476951 ff_sws_compiled_op_unref(&p->comp);
143 1476951 av_refstruct_unref(&p->offsets_y);
144 1476951 av_free(p->exec_base.in_bump_y);
145 1476951 av_free(p->exec_base.in_offset_x);
146 1476951 av_free(p->tail_buf);
147 1476951 av_free(p);
148 }
149
150 86470 static inline void get_row_data(const SwsOpPass *p, const int y_dst,
151 const uint8_t *in[4], uint8_t *out[4])
152 {
153 86470 const SwsOpExec *base = &p->exec_base;
154
2/2
✓ Branch 0 taken 18948 times.
✓ Branch 1 taken 67522 times.
 86470 const int y_src = p->offsets_y ? p->offsets_y[y_dst] : y_dst;
155
2/2
✓ Branch 0 taken 168926 times.
✓ Branch 1 taken 86470 times.
 255396 for (int i = 0; i < p->planes_in; i++)
156 168926 in[i] = base->in[i] + (y_src >> base->in_sub_y[i]) * base->in_stride[i];
157
2/2
✓ Branch 0 taken 188397 times.
✓ Branch 1 taken 86470 times.
 274867 for (int i = 0; i < p->planes_out; i++)
158 188397 out[i] = base->out[i] + (y_dst >> base->out_sub_y[i]) * base->out_stride[i];
159 86470 }
160
161 16542 static inline int get_lines_in(const SwsOpPass *p, const int y, const int h,
162 const int plane)
163 {
164 16542 const SwsOpExec *base = &p->exec_base;
165
1/2
✓ Branch 0 taken 16542 times.
✗ Branch 1 not taken.
 16542 if (!p->offsets_y)
166 16542 return h >> base->in_sub_y[plane];
167
168 ✗ const int y0 = p->offsets_y[y] >> base->in_sub_y[plane];
169 ✗ const int y1 = p->offsets_y[y + h - 1] >> base->in_sub_y[plane];
170 ✗ return y1 - y0 + 1;
171 }
172
173 98606 static inline size_t pixel_bytes(size_t pixels, int pixel_bits,
174 enum AVRounding rounding)
175 {
176 98606 const uint64_t bits = (uint64_t) pixels * pixel_bits;
177
2/3
✓ Branch 0 taken 14134 times.
✓ Branch 1 taken 84472 times.
✗ Branch 2 not taken.
 98606 switch (rounding) {
178 14134 case AV_ROUND_ZERO:
179 case AV_ROUND_DOWN:
180 14134 return bits >> 3;
181 84472 case AV_ROUND_INF:
182 case AV_ROUND_UP:
183 84472 return (bits + 7) >> 3;
184 ✗ default:
185 ✗ av_unreachable("Invalid rounding mode");
186 return (size_t) -1;
187 }
188 }
189
190 357323 static size_t safe_bytes_pad(int linesize, int plane_pad)
191 {
192 av_assert1(linesize);
193 357323 int64_t safe_bytes = FFABS((int64_t) linesize) - plane_pad;
194 357323 return FFMAX(safe_bytes, 0);
195 }
196
197 52605 static size_t safe_blocks_offset(size_t num_blocks, unsigned block_size,
198 ptrdiff_t safe_offset,
199 const int32_t *offset_bytes)
200 {
201 52605 size_t safe_blocks = num_blocks;
202
3/4
✓ Branch 0 taken 64298 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 11693 times.
✓ Branch 3 taken 52605 times.
 64298 while (safe_blocks && offset_bytes[safe_blocks * block_size - 1] > safe_offset)
203 11693 safe_blocks--;
204 52605 return safe_blocks;
205 }
206
207 86470 static int op_pass_setup(const SwsFrame *out, const SwsFrame *in,
208 const SwsPass *pass)
209 {
210 86470 const AVPixFmtDescriptor *indesc = av_pix_fmt_desc_get(in->format);
211 86470 const bool float_in = indesc->flags & AV_PIX_FMT_FLAG_FLOAT;
212 86470 const int width = out->width;
213
214 86470 SwsOpPass *p = pass->priv;
215 86470 SwsOpExec *exec = &p->exec_base;
216 86470 const SwsCompiledOp *comp = &p->comp;
217
218 /* Set up main loop parameters */
219 86470 const unsigned block_size = comp->block_size;
220 86470 const size_t num_blocks = (width + block_size - 1) / block_size;
221 86470 const size_t aligned_w = num_blocks * block_size;
222
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 86470 times.
 86470 if (aligned_w < width) /* overflow */
223 ✗ return AVERROR(EINVAL);
224 86470 p->num_blocks = num_blocks;
225 86470 p->memcpy_first = false;
226 86470 p->memcpy_last = false;
227 86470 p->memcpy_out = false;
228
229 86470 size_t safe_blocks = num_blocks;
230
2/2
✓ Branch 0 taken 168926 times.
✓ Branch 1 taken 86470 times.
 255396 for (int i = 0; i < p->planes_in; i++) {
231 168926 const int idx = p->idx_in[i];
232 168926 size_t input_bytes = in->linesize[idx];
233
4/4
✓ Branch 0 taken 52605 times.
✓ Branch 1 taken 116321 times.
✓ Branch 2 taken 8310 times.
✓ Branch 3 taken 44295 times.
 168926 if (p->filter_size_h && float_in) {
234 /* Floating point inputs may contain NaN / Infinity in the padding */
235 8310 const int plane_w = AV_CEIL_RSHIFT(in->width, exec->in_sub_x[i]);
236 8310 input_bytes = pixel_bytes(plane_w, p->pixel_bits_in, AV_ROUND_UP);
237 }
238
239 168926 size_t safe_bytes = safe_bytes_pad(input_bytes, comp->over_read[i]);
240 size_t safe_blocks_in;
241
2/2
✓ Branch 0 taken 52605 times.
✓ Branch 1 taken 116321 times.
 168926 if (exec->in_offset_x) {
242 52605 size_t filter_size = pixel_bytes(p->filter_size_h, p->pixel_bits_in,
243 AV_ROUND_UP);
244 52605 safe_blocks_in = safe_blocks_offset(num_blocks, block_size,
245 52605 safe_bytes - filter_size,
246 52605 exec->in_offset_x);
247 } else {
248 116321 safe_blocks_in = safe_bytes / exec->block_size_in[i];
249 }
250
251
2/2
✓ Branch 0 taken 16542 times.
✓ Branch 1 taken 152384 times.
 168926 if (safe_blocks_in < num_blocks) {
252 16542 p->memcpy_first |= in->linesize[idx] < 0;
253 16542 p->memcpy_last |= in->linesize[idx] > 0;
254 16542 safe_blocks = FFMIN(safe_blocks, safe_blocks_in);
255 }
256
257 168926 size_t loop_size = num_blocks * exec->block_size_in[i];
258 168926 exec->in[i] = in->data[idx];
259 168926 exec->in_stride[i] = in->linesize[idx];
260 168926 exec->in_bump[i] = in->linesize[idx] - loop_size;
261 }
262
263
2/2
✓ Branch 0 taken 188397 times.
✓ Branch 1 taken 86470 times.
 274867 for (int i = 0; i < p->planes_out; i++) {
264 188397 const int idx = p->idx_out[i];
265 188397 size_t safe_bytes = safe_bytes_pad(out->linesize[idx], comp->over_write[i]);
266 188397 size_t safe_blocks_out = safe_bytes / exec->block_size_out[i];
267
2/2
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 188394 times.
 188397 if (safe_blocks_out < num_blocks) {
268 3 p->memcpy_out = true;
269 3 safe_blocks = FFMIN(safe_blocks, safe_blocks_out);
270 }
271
272 188397 size_t loop_size = num_blocks * exec->block_size_out[i];
273 188397 exec->out[i] = out->data[idx];
274 188397 exec->out_stride[i] = out->linesize[idx];
275 188397 exec->out_bump[i] = out->linesize[idx] - loop_size;
276 }
277
278
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 86470 times.
 86470 if (p->palette_idx >= 0) {
279 ✗ exec->in[1] = in->data[p->palette_idx];
280 ✗ exec->in_stride[1] = exec->in_bump[1] = 0;
281 }
282
283
3/4
✓ Branch 0 taken 86470 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 9352 times.
✓ Branch 3 taken 77118 times.
 86470 const bool memcpy_in = p->memcpy_first || p->memcpy_last;
284
3/4
✓ Branch 0 taken 77118 times.
✓ Branch 1 taken 9352 times.
✓ Branch 2 taken 77118 times.
✗ Branch 3 not taken.
 86470 if (!memcpy_in && !p->memcpy_out) {
285
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 77118 times.
 77118 av_assert0(safe_blocks == num_blocks);
286 77118 return 0;
287 }
288
289 /* Set-up tail section parameters and buffers */
290 9352 SwsOpExec *tail = &p->exec_tail;
291 9352 const int align = av_cpu_max_align();
292 9352 size_t alloc_size = 0;
293 9352 *tail = *exec;
294
295 9352 const size_t safe_width = safe_blocks * block_size;
296 9352 const size_t tail_size = width - safe_width;
297 9352 p->tail_off_out = pixel_bytes(safe_width, p->pixel_bits_out, AV_ROUND_DOWN);
298 9352 p->tail_size_out = pixel_bytes(tail_size, p->pixel_bits_out, AV_ROUND_UP);
299 9352 p->tail_blocks = num_blocks - safe_blocks;
300
301
2/2
✓ Branch 0 taken 4570 times.
✓ Branch 1 taken 4782 times.
 9352 if (exec->in_offset_x) {
302 4570 p->tail_off_in = exec->in_offset_x[safe_width];
303 4570 p->tail_size_in = exec->in_offset_x[width - 1] - p->tail_off_in;
304 4570 p->tail_size_in += pixel_bytes(p->filter_size_h, p->pixel_bits_in, AV_ROUND_UP);
305 } else {
306 4782 p->tail_off_in = pixel_bytes(safe_width, p->pixel_bits_in, AV_ROUND_DOWN);
307 4782 p->tail_size_in = pixel_bytes(tail_size, p->pixel_bits_in, AV_ROUND_UP);
308 }
309
310 9352 const size_t alloc_width = aligned_w - safe_width;
311
3/4
✓ Branch 0 taken 25894 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 16542 times.
✓ Branch 3 taken 9352 times.
 25894 for (int i = 0; memcpy_in && i < p->planes_in; i++) {
312 size_t needed_size;
313
2/2
✓ Branch 0 taken 11693 times.
✓ Branch 1 taken 4849 times.
 16542 if (exec->in_offset_x) {
314 /* The input offset map is already padded to multiples of the block
315 * size, and clamps the input offsets to the image boundaries; so
316 * we just need to compensate for the comp->over_read */
317 11693 needed_size = p->tail_size_in;
318 } else {
319 4849 needed_size = pixel_bytes(alloc_width, p->pixel_bits_in, AV_ROUND_UP);
320 }
321 16542 size_t loop_size = p->tail_blocks * exec->block_size_in[i];
322 16542 tail->in_stride[i] = FFALIGN(needed_size + comp->over_read[i], align);
323 16542 tail->in_bump[i] = tail->in_stride[i] - loop_size;
324 16542 alloc_size += tail->in_stride[i] * in->height;
325 }
326
327
4/4
✓ Branch 0 taken 5 times.
✓ Branch 1 taken 9351 times.
✓ Branch 2 taken 4 times.
✓ Branch 3 taken 1 times.
 9356 for (int i = 0; p->memcpy_out && i < p->planes_out; i++) {
328 4 size_t needed_size = pixel_bytes(alloc_width, p->pixel_bits_out, AV_ROUND_UP);
329 4 size_t loop_size = p->tail_blocks * exec->block_size_out[i];
330 4 tail->out_stride[i] = FFALIGN(needed_size + comp->over_write[i], align);
331 4 tail->out_bump[i] = tail->out_stride[i] - loop_size;
332 4 alloc_size += tail->out_stride[i] * out->height;
333 }
334
335
3/4
✓ Branch 0 taken 9352 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 4570 times.
✓ Branch 3 taken 4782 times.
 9352 if (memcpy_in && exec->in_offset_x) {
336 /* `in_offset_x` is indexed relative to the line start, not the start
337 * of the section being processed; so we need to over-allocate this
338 * array to the full width of the image, even though we will only
339 * partially fill in the offsets relevant to the tail region */
340 4570 alloc_size += aligned_w * sizeof(*exec->in_offset_x);
341 }
342
343 9352 av_fast_mallocz(&p->tail_buf, &p->tail_buf_size, alloc_size);
344
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 9352 times.
 9352 if (!p->tail_buf)
345 ✗ return AVERROR(ENOMEM);
346
347 9352 uint8_t *tail_buf = p->tail_buf;
348
3/4
✓ Branch 0 taken 25894 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 16542 times.
✓ Branch 3 taken 9352 times.
 25894 for (int i = 0; memcpy_in && i < p->planes_in; i++) {
349 16542 tail->in[i] = tail_buf;
350 16542 tail_buf += tail->in_stride[i] * in->height;
351 }
352
353
4/4
✓ Branch 0 taken 5 times.
✓ Branch 1 taken 9351 times.
✓ Branch 2 taken 4 times.
✓ Branch 3 taken 1 times.
 9356 for (int i = 0; p->memcpy_out && i < p->planes_out; i++) {
354 4 tail->out[i] = tail_buf;
355 4 tail_buf += tail->out_stride[i] * out->height;
356 }
357
358
3/4
✓ Branch 0 taken 9352 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 4570 times.
✓ Branch 3 taken 4782 times.
 9352 if (memcpy_in && exec->in_offset_x) {
359 4570 tail->in_offset_x = (int32_t *) tail_buf;
360
2/2
✓ Branch 0 taken 73120 times.
✓ Branch 1 taken 4570 times.
 77690 for (int i = safe_width; i < aligned_w; i++)
361 73120 tail->in_offset_x[i] = exec->in_offset_x[i] - p->tail_off_in;
362 }
363
364 9352 return 0;
365 }
366
367 16546 static void copy_lines(uint8_t *dst, const size_t dst_stride,
368 const uint8_t *src, const size_t src_stride,
369 const int h, const size_t bytes)
370 {
371
2/2
✓ Branch 0 taken 1588448 times.
✓ Branch 1 taken 16546 times.
 1604994 for (int y = 0; y < h; y++) {
372 1588448 memcpy(dst, src, bytes);
373 1588448 dst += dst_stride;
374 1588448 src += src_stride;
375 }
376 16546 }
377
378 86470 static void op_pass_run(const SwsFrame *out, const SwsFrame *in, const int y,
379 const int h, const SwsPass *pass)
380 {
381 86470 const SwsOpPass *p = pass->priv;
382 86470 const SwsCompiledOp *comp = &p->comp;
383
384 /* Fill exec metadata for this slice */
385 86470 DECLARE_ALIGNED_32(SwsOpExec, exec) = p->exec_base;
386 86470 exec.slice_y = y;
387 86470 exec.slice_h = h;
388
389 /**
390 * To ensure safety, we need to consider the following:
391 *
392 * 1. We can overread the input, unless this is the last line of an
393 * unpadded buffer. All defined operations can handle arbitrary pixel
394 * input, so overread of arbitrary data is fine. For flipped images,
395 * this condition is actually *inverted* to where the first line is
396 * the one at the end of the buffer.
397 *
398 * 2. We can overwrite the output, as long as we don't write more than the
399 * amount of pixels that fit into one linesize. So we always need to
400 * memcpy the last column on the output side if unpadded.
401 */
402
403
3/4
✓ Branch 0 taken 9352 times.
✓ Branch 1 taken 77118 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 9352 times.
 163588 const bool memcpy_in = p->memcpy_last && y + h == pass->lines ||
404
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 77118 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 77118 p->memcpy_first && y == 0;
405 86470 const bool memcpy_out = p->memcpy_out;
406 86470 const size_t num_blocks = p->num_blocks;
407 86470 const size_t tail_blocks = p->tail_blocks;
408
409 86470 get_row_data(p, y, exec.in, exec.out);
410
3/4
✓ Branch 0 taken 77118 times.
✓ Branch 1 taken 9352 times.
✓ Branch 2 taken 77118 times.
✗ Branch 3 not taken.
 86470 if (!memcpy_in && !memcpy_out) {
411 /* Fast path (fully aligned/padded inputs and outputs) */
412 77118 comp->func(&exec, comp->priv, 0, y, num_blocks, y + h);
413 77118 return;
414 }
415
416 /* Non-aligned case (slow path); process main blocks as normal, and
417 * a separate tail (via memcpy into an appropriately padded buffer) */
418
1/2
✓ Branch 0 taken 9352 times.
✗ Branch 1 not taken.
 9352 if (num_blocks > tail_blocks) {
419
2/2
✓ Branch 0 taken 37408 times.
✓ Branch 1 taken 9352 times.
 46760 for (int i = 0; i < 4; i++) {
420 /* We process fewer blocks, so the in_bump needs to be increased
421 * to reflect that the plane pointers are left on the last block,
422 * not the end of the processed line, after each loop iteration */
423 37408 exec.in_bump[i] += exec.block_size_in[i] * tail_blocks;
424 37408 exec.out_bump[i] += exec.block_size_out[i] * tail_blocks;
425 }
426
427 9352 comp->func(&exec, comp->priv, 0, y, num_blocks - tail_blocks, y + h);
428 }
429
430 9352 DECLARE_ALIGNED_32(SwsOpExec, tail) = p->exec_tail;
431 9352 tail.slice_y = y;
432 9352 tail.slice_h = h;
433
434
2/2
✓ Branch 0 taken 16542 times.
✓ Branch 1 taken 9352 times.
 25894 for (int i = 0; i < p->planes_in; i++) {
435 /* Input offsets are relative to the base pointer */
436
3/4
✓ Branch 0 taken 11693 times.
✓ Branch 1 taken 4849 times.
✓ Branch 2 taken 11693 times.
✗ Branch 3 not taken.
 16542 if (!exec.in_offset_x || memcpy_in)
437 16542 exec.in[i] += p->tail_off_in;
438 16542 tail.in[i] += y * tail.in_stride[i];
439 }
440
2/2
✓ Branch 0 taken 24301 times.
✓ Branch 1 taken 9352 times.
 33653 for (int i = 0; i < p->planes_out; i++) {
441 24301 exec.out[i] += p->tail_off_out;
442 24301 tail.out[i] += y * tail.out_stride[i];
443 }
444
445
2/2
✓ Branch 0 taken 16542 times.
✓ Branch 1 taken 9352 times.
 25894 for (int i = 0; i < p->planes_in; i++) {
446
1/2
✓ Branch 0 taken 16542 times.
✗ Branch 1 not taken.
 16542 if (memcpy_in) {
447 16542 const int lines = get_lines_in(p, y, h, i);
448 16542 copy_lines((uint8_t *) tail.in[i], tail.in_stride[i],
449 16542 exec.in[i], exec.in_stride[i], lines, p->tail_size_in);
450 } else {
451 /* Reuse input pointers directly */
452 ✗ const size_t loop_size = tail_blocks * exec.block_size_in[i];
453 ✗ tail.in[i] = exec.in[i];
454 ✗ tail.in_stride[i] = exec.in_stride[i];
455 ✗ tail.in_bump[i] = exec.in_stride[i] - loop_size;
456 }
457 }
458
459
4/4
✓ Branch 0 taken 33648 times.
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 24297 times.
✓ Branch 3 taken 9351 times.
 33649 for (int i = 0; !memcpy_out && i < p->planes_out; i++) {
460 /* Reuse output pointers directly */
461 24297 const size_t loop_size = tail_blocks * exec.block_size_out[i];
462 24297 tail.out[i] = exec.out[i];
463 24297 tail.out_stride[i] = exec.out_stride[i];
464 24297 tail.out_bump[i] = exec.out_stride[i] - loop_size;
465 }
466
467 /* Dispatch kernel over tail */
468 av_assert1(tail_blocks > 0);
469 9352 comp->func(&tail, comp->priv, num_blocks - tail_blocks, y, num_blocks, y + h);
470
471
4/4
✓ Branch 0 taken 5 times.
✓ Branch 1 taken 9351 times.
✓ Branch 2 taken 4 times.
✓ Branch 3 taken 1 times.
 9356 for (int i = 0; memcpy_out && i < p->planes_out; i++) {
472 4 const int lines = h >> tail.out_sub_y[i];
473 4 copy_lines(exec.out[i], exec.out_stride[i],
474 4 tail.out[i], tail.out_stride[i], lines, p->tail_size_out);
475 }
476 }
477
478 /* Updates the plane copy (no-op) map for this operation list */
479 85890 static void op_list_get_plane_copy(const SwsOpList *ops, SwsPass *pass)
480 {
481 85890 const SwsOp *write = ff_sws_op_list_output(ops);
482 85890 const SwsOp *read = ff_sws_op_list_input(ops);
483
5/6
✓ Branch 0 taken 85890 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 66685 times.
✓ Branch 3 taken 19205 times.
✓ Branch 4 taken 57745 times.
✓ Branch 5 taken 8940 times.
 85890 if (!write || write->rw.mode != SWS_RW_PLANAR ||
484
2/2
✓ Branch 0 taken 39111 times.
✓ Branch 1 taken 18634 times.
 57745 !read || read->rw.mode != SWS_RW_PLANAR ||
485
2/2
✓ Branch 0 taken 15156 times.
✓ Branch 1 taken 23955 times.
 39111 read->type != write->type ||
486
2/2
✓ Branch 0 taken 392 times.
✓ Branch 1 taken 14764 times.
 15156 read->rw.frac != write->rw.frac)
487 71126 return; /* only regular planes can be directly ref'd */
488
489 14764 const SwsOp *prev = &ops->ops[ops->num_ops - 2];
490 14764 int *plane_copy = pass->output->plane_copy;
491
2/2
✓ Branch 0 taken 38644 times.
✓ Branch 1 taken 14764 times.
 53408 for (int i = 0; i < write->rw.elems; i++) {
492 38644 SwsCompFlags flags = prev->comps.flags[i];
493
2/2
✓ Branch 0 taken 38509 times.
✓ Branch 1 taken 135 times.
 38644 if (!(flags & SWS_COMP_COPY))
494 38509 continue;
495
496 135 const int out_idx = ops->plane_dst[i];
497
3/5
✓ Branch 0 taken 97 times.
✓ Branch 1 taken 19 times.
✓ Branch 2 taken 19 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
 135 switch (prev->comps.dep_in[i]) {
498 97 case SWS_COMP(0): plane_copy[out_idx] = ops->plane_src[0]; break;
499 19 case SWS_COMP(1): plane_copy[out_idx] = ops->plane_src[1]; break;
500 19 case SWS_COMP(2): plane_copy[out_idx] = ops->plane_src[2]; break;
501 ✗ case SWS_COMP(3): plane_copy[out_idx] = ops->plane_src[3]; break;
502 }
503 }
504 }
505
506 162840 static int rw_data_planes(const SwsOp *op)
507 {
508 /* Exclude the palette plane from the plane count, since it does not need
509 * to be directly processed/adjusted by the dispatch layer */
510
1/2
✓ Branch 0 taken 162840 times.
✗ Branch 1 not taken.
 162840 return op->rw.mode == SWS_RW_PALETTE ? 1 : ff_sws_rw_op_planes(op);
511 }
512
513 162840 static int rw_pixel_bits(const SwsOp *op)
514 {
515
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 162840 times.
 162840 if (op->rw.mode == SWS_RW_PALETTE)
516 ✗ return 8; /* index size */
517
518 162840 int elems = 0;
519
2/3
✓ Branch 0 taken 120969 times.
✓ Branch 1 taken 41871 times.
✗ Branch 2 not taken.
 162840 switch (op->rw.mode) {
520 120969 case SWS_RW_PLANAR: elems = 1; break;
521 41871 case SWS_RW_PACKED: elems = op->rw.elems; break;
522 }
523
524 162840 const int size = ff_sws_pixel_type_size(op->type);
525 162840 const int bits = 8 >> op->rw.frac;
526 av_assert1(bits >= 1);
527 162840 return elems * size * bits;
528 }
529
530 162840 static void align_pass(SwsPass *pass, int block_size, const int *over_rw,
531 int pixel_bits)
532 {
533
3/4
✓ Branch 0 taken 117880 times.
✓ Branch 1 taken 44960 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 117880 times.
 162840 if (!pass || pixel_bits <= 0)
534 44960 return;
535
536 /* Add at least as many pixels as needed to cover the padding requirement */
537 117880 int pad_max = 0;
538
2/2
✓ Branch 0 taken 471520 times.
✓ Branch 1 taken 117880 times.
 589400 for (int i = 0; i < 4; i++) {
539 471520 const int pad = (over_rw[i] * 8 + pixel_bits - 1) / pixel_bits;
540 471520 pad_max = FFMAX(pad_max, pad);
541 }
542
543 117880 SwsPassBuffer *buf = pass->output;
544 117880 buf->width_align = FFMAX(buf->width_align, block_size);
545 117880 buf->width_pad = FFMAX(buf->width_pad, pad_max);
546 }
547
548 /* Unchanging part of parameter list */
549 typedef struct CompileArgs {
550 const SwsOpBackend *backend;
551 SwsGraph *graph;
552 int flags;
553 } CompileArgs;
554
555 1476951 static int compile_single(const CompileArgs *args, const SwsOpList *ops,
556 SwsPass *link, SwsPass *input, SwsPass **output)
557 {
558 1476951 SwsGraph *graph = args->graph;
559 1476951 SwsContext *ctx = graph->ctx;
560 1476951 SwsOpPass *p = av_mallocz(sizeof(*p));
561
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1476951 times.
 1476951 if (!p)
562 ✗ return AVERROR(ENOMEM);
563
564 1476951 int ret = ff_sws_ops_compile(ctx, args->backend, ops, &p->comp);
565
2/2
✓ Branch 0 taken 434862 times.
✓ Branch 1 taken 1042089 times.
 1476951 if (ret < 0)
566 434862 goto fail;
567
2/2
✓ Branch 0 taken 956199 times.
✓ Branch 1 taken 85890 times.
 1042089 else if (args->flags & SWS_OP_FLAG_DRY_RUN)
568 956199 goto fail; /* nothing to do, just return */
569
570 85890 const SwsCompiledOp *comp = &p->comp;
571 85890 const SwsFormat *src = &ops->src;
572 85890 const SwsFormat *dst = &ops->dst;
573
3/4
✓ Branch 0 taken 8948 times.
✓ Branch 1 taken 76942 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 8948 times.
 85890 av_assert0(!link || link->format == dst->format);
574
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 85890 times.
 85890 if (p->comp.opaque) {
575 ✗ SwsCompiledOp c = *comp;
576 ✗ av_free(p);
577 ✗ ret = ff_sws_graph_add_pass(graph, dst->format, dst->width, dst->height,
578 input, 0, c.slice_align, c.func_opaque,
579 NULL, c.priv, c.free, output);
580 ✗ if (ret >= 0) {
581 ✗ (*output)->backend = c.backend->flags;
582 ✗ op_list_get_plane_copy(ops, *output);
583 ✗ ff_sws_pass_link_output(*output, link);
584 }
585 ✗ return ret;
586 }
587
588 85890 const AVPixFmtDescriptor *indesc = av_pix_fmt_desc_get(src->format);
589 85890 const AVPixFmtDescriptor *outdesc = av_pix_fmt_desc_get(dst->format);
590 85890 const SwsOp *write = ff_sws_op_list_output(ops);
591 85890 p->planes_out = rw_data_planes(write);
592 85890 p->pixel_bits_out = rw_pixel_bits(write);
593 85890 p->palette_idx = -1;
594 85890 p->exec_base = (SwsOpExec) {
595 85890 .width = dst->width,
596 85890 .height = dst->height,
597 };
598
599 85890 const SwsOp *read = ff_sws_op_list_input(ops);
600
2/2
✓ Branch 0 taken 76950 times.
✓ Branch 1 taken 8940 times.
 85890 if (read) {
601 76950 p->planes_in = rw_data_planes(read);
602 76950 p->pixel_bits_in = rw_pixel_bits(read);
603
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 76950 times.
 76950 if (read->rw.mode == SWS_RW_PALETTE)
604 ✗ p->palette_idx = ops->plane_src[1];
605 }
606
607 85890 const int64_t block_bits_in = (int64_t) comp->block_size * p->pixel_bits_in;
608 85890 const int64_t block_bits_out = (int64_t) comp->block_size * p->pixel_bits_out;
609
2/4
✓ Branch 0 taken 85890 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 85890 times.
 85890 if (block_bits_in & 0x7 || block_bits_out & 0x7) {
610 ✗ av_log(ctx, AV_LOG_ERROR, "Block size must be byte-aligned.\n");
611 ✗ ret = AVERROR(EINVAL);
612 ✗ goto fail;
613 }
614
615
2/2
✓ Branch 0 taken 343560 times.
✓ Branch 1 taken 85890 times.
 429450 for (int i = 0; i < 4; i++)
616 343560 p->idx_in[i] = p->idx_out[i] = -1;
617
618
2/2
✓ Branch 0 taken 167907 times.
✓ Branch 1 taken 85890 times.
 253797 for (int i = 0; i < p->planes_in; i++) {
619 167907 const int idx = ops->plane_src[i];
620
4/4
✓ Branch 0 taken 124875 times.
✓ Branch 1 taken 43032 times.
✓ Branch 2 taken 41975 times.
✓ Branch 3 taken 82900 times.
 167907 const int chroma = idx == 1 || idx == 2;
621
2/2
✓ Branch 0 taken 85007 times.
✓ Branch 1 taken 82900 times.
 167907 const int sub_x = chroma ? indesc->log2_chroma_w : 0;
622
2/2
✓ Branch 0 taken 85007 times.
✓ Branch 1 taken 82900 times.
 167907 const int sub_y = chroma ? indesc->log2_chroma_h : 0;
623 167907 p->exec_base.in_sub_x[i] = sub_x;
624 167907 p->exec_base.in_sub_y[i] = sub_y;
625 167907 p->exec_base.block_size_in[i] = block_bits_in >> 3;
626 167907 p->idx_in[i] = idx;
627 }
628
629
2/2
✓ Branch 0 taken 186923 times.
✓ Branch 1 taken 85890 times.
 272813 for (int i = 0; i < p->planes_out; i++) {
630 186923 const int idx = ops->plane_dst[i];
631
4/4
✓ Branch 0 taken 138668 times.
✓ Branch 1 taken 48255 times.
✓ Branch 2 taken 47197 times.
✓ Branch 3 taken 91471 times.
 186923 const int chroma = idx == 1 || idx == 2;
632
2/2
✓ Branch 0 taken 95452 times.
✓ Branch 1 taken 91471 times.
 186923 const int sub_x = chroma ? outdesc->log2_chroma_w : 0;
633
2/2
✓ Branch 0 taken 95452 times.
✓ Branch 1 taken 91471 times.
 186923 const int sub_y = chroma ? outdesc->log2_chroma_h : 0;
634 186923 p->exec_base.out_sub_x[i] = sub_x;
635 186923 p->exec_base.out_sub_y[i] = sub_y;
636 186923 p->exec_base.block_size_out[i] = block_bits_out >> 3;
637 186923 p->idx_out[i] = idx;
638 }
639
640
2/2
✓ Branch 0 taken 76950 times.
✓ Branch 1 taken 8940 times.
 85890 const SwsFilterWeights *filter = read ? read->rw.filter.kernel : NULL;
641
4/4
✓ Branch 0 taken 76950 times.
✓ Branch 1 taken 8940 times.
✓ Branch 2 taken 18808 times.
✓ Branch 3 taken 58142 times.
 85890 if (read && read->rw.filter.op == SWS_OP_FILTER_V) {
642 18808 p->offsets_y = av_refstruct_ref(filter->offsets);
643
644 /* Compute relative pointer bumps for each output line */
645 18808 int32_t *bump = av_malloc_array(filter->dst_size, sizeof(*bump));
646
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 18808 times.
 18808 if (!bump) {
647 ✗ ret = AVERROR(ENOMEM);
648 ✗ goto fail;
649 }
650
651 18808 int line = filter->offsets[0];
652
2/2
✓ Branch 0 taken 1782248 times.
✓ Branch 1 taken 18808 times.
 1801056 for (int y = 0; y < filter->dst_size - 1; y++) {
653 1782248 int next = filter->offsets[y + 1];
654 1782248 bump[y] = next - line - 1;
655 1782248 line = next;
656 }
657 18808 bump[filter->dst_size - 1] = 0;
658 18808 p->exec_base.in_bump_y = bump;
659
4/4
✓ Branch 0 taken 58142 times.
✓ Branch 1 taken 8940 times.
✓ Branch 2 taken 19126 times.
✓ Branch 3 taken 39016 times.
 67082 } else if (read && read->rw.filter.op == SWS_OP_FILTER_H) {
660 /* Compute pixel offset map for each output line */
661 19126 const int pixels = FFALIGN(filter->dst_size, p->comp.block_size);
662 19126 int32_t *offset = av_malloc_array(pixels, sizeof(*offset));
663
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 19126 times.
 19126 if (!offset) {
664 ✗ ret = AVERROR(ENOMEM);
665 ✗ goto fail;
666 }
667 19126 p->exec_base.in_offset_x = offset;
668
669
2/2
✓ Branch 0 taken 1841568 times.
✓ Branch 1 taken 19126 times.
 1860694 for (int x = 0; x < filter->dst_size; x++) {
670 /* Sanity check; if the tap would land on a half-pixel, we cannot
671 * reasonably expect the implementation to know about this. Just
672 * error out in such (theoretical) cases. */
673 1841568 int64_t bits = (int64_t) filter->offsets[x] * p->pixel_bits_in;
674
2/4
✓ Branch 0 taken 1841568 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 1841568 times.
 1841568 if ((bits & 0x7) || (bits >> 3) > INT32_MAX) {
675 ✗ ret = AVERROR(EINVAL);
676 ✗ goto fail;
677 }
678 1841568 offset[x] = bits >> 3;
679 }
680
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 19126 times.
 19126 for (int x = filter->dst_size; x < pixels; x++)
681 ✗ offset[x] = offset[filter->dst_size - 1];
682
2/2
✓ Branch 0 taken 76504 times.
✓ Branch 1 taken 19126 times.
 95630 for (int i = 0; i < 4; i++)
683 76504 p->exec_base.block_size_in[i] = 0; /* ptr does not advance */
684 19126 p->filter_size_h = filter->filter_size;
685 }
686
687 85890 ret = ff_sws_graph_add_pass(graph, dst->format, dst->width, dst->height,
688 85890 input, 0, comp->slice_align, op_pass_run,
689 op_pass_setup, p, op_pass_free, output);
690
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 85890 times.
 85890 if (ret < 0)
691 ✗ return ret;
692
693 85890 (*output)->backend = comp->backend->flags;
694 85890 op_list_get_plane_copy(ops, *output);
695 85890 ff_sws_pass_link_output(*output, link);
696 85890 align_pass(*output, comp->block_size, comp->over_write, p->pixel_bits_out);
697
2/2
✓ Branch 0 taken 76950 times.
✓ Branch 1 taken 8940 times.
 85890 if (read)
698 76950 align_pass(input, comp->block_size, comp->over_read, p->pixel_bits_in);
699 85890 return 0;
700
701 1391061 fail:
702 1391061 op_pass_free(p);
703 1391061 return ret;
704 }
705
706 /* Return a mask of all planes matching any flag in `flags` */
707 1530878 static SwsCompMask plane_mask_flags(const SwsOp *op, SwsCompFlags flags)
708 {
709 1530878 SwsCompMask planes = 0;
710
2/2
✓ Branch 0 taken 6123512 times.
✓ Branch 1 taken 1530878 times.
 7654390 for (int c = 0; c < 4; c++) {
711
2/2
✓ Branch 0 taken 299734 times.
✓ Branch 1 taken 5823778 times.
 6123512 if (op->comps.flags[c] & flags)
712 299734 planes |= SWS_COMP(c);
713 }
714
715 1530878 return planes;
716 }
717
718 /* Takes over ownership of *pops, even on failure */
719 1530878 static int compile_subpass(const CompileArgs *args, SwsOpList **pops,
720 SwsPass *link, SwsPass *input, SwsPass **output)
721 {
722 int ret;
723 1530878 SwsContext *ctx = args->graph->ctx;
724 1530878 SwsOpList *ops = *pops;
725 1530878 SwsOpList *rest = NULL;
726 1530878 SwsPass *tmp = NULL;
727 1530878 *pops = NULL;
728
729
1/2
✓ Branch 0 taken 1530878 times.
✗ Branch 1 not taken.
 1530878 if (args->flags & SWS_OP_FLAG_SPLIT_MEMCPY) {
730 /* Split off copied and constant planes into a separate subpass,
731 * since these are likely to be handled by the memcpy backend */
732
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1530878 times.
 1530878 av_assert0(ops->num_ops >= 2);
733 1530878 const SwsOp *prev = &ops->ops[ops->num_ops - 2];
734 1530878 SwsCompMask planes = plane_mask_flags(prev, SWS_COMP_COPY | SWS_COMP_CONST);
735
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1530878 times.
 1530878 RET(ff_sws_op_list_split_planes(ops, &rest, planes));
736
2/2
✓ Branch 0 taken 53927 times.
✓ Branch 1 taken 1476951 times.
 1530878 if (rest) {
737 /* Parallel split: share input and link all outputs together */
738 53927 av_log(ctx, AV_LOG_DEBUG, "Splitting const/memcpy planes: %s\n",
739 53927 ff_sws_comp_mask_str(planes));
740
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 53927 times.
 53927 RET(compile_subpass(args, &ops, link, input, &tmp));
741
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 53927 times.
 53927 RET(compile_subpass(args, &rest, tmp, input, output));
742 53927 return 0;
743 }
744 }
745
746 1476951 ret = compile_single(args, ops, link, input, output);
747
2/2
✓ Branch 0 taken 1042089 times.
✓ Branch 1 taken 434862 times.
 1476951 if (ret != AVERROR(ENOTSUP))
748 1042089 goto fail; /* either success or a hard error */
749
750 /* Find any unresolved filter */
751
2/2
✓ Branch 0 taken 752665 times.
✓ Branch 1 taken 4 times.
 752669 for (int idx = 1; idx < ops->num_ops - 1; idx++) {
752 752665 const SwsOp *op = &ops->ops[idx];
753
4/4
✓ Branch 0 taken 551390 times.
✓ Branch 1 taken 201275 times.
✓ Branch 2 taken 233583 times.
✓ Branch 3 taken 317807 times.
 752665 if (op->op == SWS_OP_FILTER_H || op->op == SWS_OP_FILTER_V) {
754
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 434858 times.
 434858 RET(ff_sws_op_list_split_at(ops, &rest, idx));
755
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 434858 times.
 434858 if (ff_sws_op_list_is_noop(ops)) {
756 /* Prevent infinite recursion by avoiding splitting in a way
757 * that does not meaningfully reduce the number of operations
758 * performed in the second part. */
759 ✗ FFSWAP(SwsOpList *, ops, rest);
760 ✗ break;
761 }
762 /* Serial split: feed first pass into second */
763
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 434858 times.
 434858 RET(compile_subpass(args, &ops, NULL, input, &tmp));
764
2/2
✓ Branch 1 taken 8 times.
✓ Branch 2 taken 434850 times.
 434858 RET(compile_subpass(args, &rest, link, tmp, output));
765 434850 return 0;
766 }
767 }
768
769 /* If we didn't find any more operations to eliminate, then this ops list
770 * is simply unsupported by any of the available backends */
771 4 av_log(ctx, AV_LOG_WARNING, "No backend found for operations:\n");
772 4 ff_sws_op_list_print(ctx, AV_LOG_WARNING, AV_LOG_TRACE, ops);
773 4 ret = AVERROR(ENOTSUP);
774
775 1042101 fail:
776 1042101 ff_sws_op_list_free(&ops);
777 1042101 ff_sws_op_list_free(&rest);
778 1042101 return ret;
779 }
780
781 553969 int ff_sws_compile_pass(SwsGraph *graph, const SwsOpBackend *backend,
782 SwsOpList **pops, int flags, SwsPass *input,
783 SwsPass **output)
784 {
785 553969 const int passes_orig = graph->num_passes;
786 553969 SwsContext *ctx = graph->ctx;
787 553969 SwsOpList *ops = *pops;
788 553969 int ret = 0;
789
790 553969 const SwsOp *write = ff_sws_op_list_output(ops);
791
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 553969 times.
 553969 if (!write) {
792 ✗ av_log(ctx, AV_LOG_ERROR, "Last operation must be SWS_OP_WRITE.\n");
793 ✗ ret = AVERROR(EINVAL);
794 ✗ goto out;
795 }
796
797
2/2
✓ Branch 0 taken 44973 times.
✓ Branch 1 taken 508996 times.
 553969 if (flags & SWS_OP_FLAG_OPTIMIZE) {
798 44973 ret = ff_sws_op_list_optimize(ops);
799
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 44973 times.
 44973 if (ret < 0)
800 ✗ goto out;
801 44973 av_log(ctx, AV_LOG_DEBUG, "Operation list after optimizing:\n");
802 44973 ff_sws_op_list_print(ctx, AV_LOG_DEBUG, AV_LOG_TRACE, ops);
803 }
804
805 /* Check if the whole operation graph is an end-to-end no-op */
806
2/2
✓ Branch 1 taken 661 times.
✓ Branch 2 taken 553308 times.
 553969 if (ff_sws_op_list_is_noop(ops)) {
807
2/2
✓ Branch 0 taken 21 times.
✓ Branch 1 taken 640 times.
 661 if (output)
808 21 *output = input;
809 661 goto out;
810 }
811
812 553308 const CompileArgs args = {
813 .backend = backend,
814 .graph = graph,
815 .flags = flags,
816 };
817
818 553308 ret = compile_subpass(&args, &ops, NULL, input, output);
819
2/2
✓ Branch 0 taken 4 times.
✓ Branch 1 taken 553304 times.
 553308 if (ret < 0)
820 4 goto out;
821
822 553304 const int num_passes = graph->num_passes - passes_orig;
823
2/2
✓ Branch 0 taken 526515 times.
✓ Branch 1 taken 26789 times.
 553304 if (num_passes > 1)
824 26789 av_log(ctx, AV_LOG_VERBOSE, "Using %d separate passes.\n", num_passes);
825
826 526515 out:
827
2/2
✓ Branch 0 taken 4 times.
✓ Branch 1 taken 553965 times.
 553969 if (ret < 0)
828 4 ff_sws_graph_rollback(graph, passes_orig);
829 553969 ff_sws_op_list_free(&ops);
830 553969 *pops = NULL;
831 553969 return ret;
832 }
833