FFmpeg coverage

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