FFmpeg coverage

Directory: ../../../ffmpeg/
File: src/libavfilter/formats.c
Date: 2025-10-16 05:50:53
Exec Total Coverage
Lines: 343 422 81.3%
Functions: 67 80 83.8%
Branches: 470 644 73.0%
Line Branch Exec Source
1 /*
2 * Filter layer - format negotiation
3 * Copyright (c) 2007 Bobby Bingham
4 *
5 * This file is part of FFmpeg.
6 *
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20 */
21
22 #include "libavutil/avassert.h"
23 #include "libavutil/channel_layout.h"
24 #include "libavutil/common.h"
25 #include "libavutil/mem.h"
26 #include "libavutil/pixdesc.h"
27 #include "avfilter.h"
28 #include "filters.h"
29 #include "formats.h"
30
31 /**
32 * Add all refs from a to ret and destroy a.
33 */
34 #define MERGE_REF(ret, a, fmts, type, fail_statement) \
35 do { \
36 type ***tmp; \
37 int i; \
38 \
39 if (!(tmp = av_realloc_array(ret->refs, ret->refcount + a->refcount, \
40 sizeof(*tmp)))) \
41 { fail_statement } \
42 ret->refs = tmp; \
43 \
44 for (i = 0; i < a->refcount; i ++) { \
45 ret->refs[ret->refcount] = a->refs[i]; \
46 *ret->refs[ret->refcount++] = ret; \
47 } \
48 \
49 av_freep(&a->refs); \
50 av_freep(&a->fmts); \
51 av_freep(&a); \
52 } while (0)
53
54 /**
55 * Add all formats common to a and b to a, add b's refs to a and destroy b.
56 * If check is set, nothing is modified and it is only checked whether
57 * the formats are compatible.
58 * If empty_allowed is set and one of a,b->nb is zero, the lists are
59 * merged; otherwise, 0 (for nonmergeability) is returned.
60 */
61 #define MERGE_FORMATS(a, b, fmts, nb, type, check, empty_allowed) \
62 do { \
63 int i, j, k = 0, skip = 0; \
64 \
65 if (empty_allowed) { \
66 if (!a->nb || !b->nb) { \
67 if (check) \
68 return 1; \
69 if (!a->nb) \
70 FFSWAP(type *, a, b); \
71 skip = 1; \
72 } \
73 } \
74 if (!skip) { \
75 for (i = 0; i < a->nb; i++) \
76 for (j = 0; j < b->nb; j++) \
77 if (a->fmts[i] == b->fmts[j]) { \
78 if (check) \
79 return 1; \
80 a->fmts[k++] = a->fmts[i]; \
81 break; \
82 } \
83 /* Check that there was at least one common format. \
84 * Notice that both a and b are unchanged if not. */ \
85 if (!k) \
86 return 0; \
87 av_assert2(!check); \
88 a->nb = k; \
89 } \
90 \
91 MERGE_REF(a, b, fmts, type, return AVERROR(ENOMEM);); \
92 } while (0)
93
94 71645 static int merge_formats_internal(AVFilterFormats *a, AVFilterFormats *b,
95 enum AVMediaType type, int check)
96 {
97 int i, j;
98 71645 int alpha1=0, alpha2=0;
99 71645 int chroma1=0, chroma2=0;
100
101 av_assert2(check || (a->refcount && b->refcount));
102
103
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 71645 times.
 71645 if (a == b)
104 ✗ return 1;
105
106 /* Do not lose chroma or alpha in merging.
107 It happens if both lists have formats with chroma (resp. alpha), but
108 the only formats in common do not have it (e.g. YUV+gray vs.
109 RGB+gray): in that case, the merging would select the gray format,
110 possibly causing a lossy conversion elsewhere in the graph.
111 To avoid that, pretend that there are no common formats to force the
112 insertion of a conversion filter. */
113
2/2
✓ Branch 0 taken 60426 times.
✓ Branch 1 taken 11219 times.
 71645 if (type == AVMEDIA_TYPE_VIDEO)
114
2/2
✓ Branch 0 taken 3313946 times.
✓ Branch 1 taken 60426 times.
 3374372 for (i = 0; i < a->nb_formats; i++) {
115 3313946 const AVPixFmtDescriptor *const adesc = av_pix_fmt_desc_get(a->formats[i]);
116
2/2
✓ Branch 0 taken 189698821 times.
✓ Branch 1 taken 3313946 times.
 193012767 for (j = 0; j < b->nb_formats; j++) {
117 189698821 const AVPixFmtDescriptor *bdesc = av_pix_fmt_desc_get(b->formats[j]);
118 189698821 alpha2 |= adesc->flags & bdesc->flags & AV_PIX_FMT_FLAG_ALPHA;
119
4/4
✓ Branch 0 taken 165555484 times.
✓ Branch 1 taken 24143337 times.
✓ Branch 2 taken 143708103 times.
✓ Branch 3 taken 21847381 times.
 189698821 chroma2|= adesc->nb_components > 1 && bdesc->nb_components > 1;
120
2/2
✓ Branch 0 taken 727012 times.
✓ Branch 1 taken 188971809 times.
 189698821 if (a->formats[i] == b->formats[j]) {
121 727012 alpha1 |= adesc->flags & AV_PIX_FMT_FLAG_ALPHA;
122 727012 chroma1|= adesc->nb_components > 1;
123 }
124 }
125 }
126
127 // If chroma or alpha can be lost through merging then do not merge
128
4/4
✓ Branch 0 taken 71624 times.
✓ Branch 1 taken 21 times.
✓ Branch 2 taken 553 times.
✓ Branch 3 taken 71071 times.
 71645 if (alpha2 > alpha1 || chroma2 > chroma1)
129 574 return 0;
130
131
14/16
✓ Branch 0 taken 71071 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 407562 times.
✓ Branch 3 taken 48191714 times.
✓ Branch 4 taken 33944 times.
✓ Branch 5 taken 373618 times.
✓ Branch 6 taken 48599276 times.
✓ Branch 7 taken 1919890 times.
✓ Branch 8 taken 2327452 times.
✓ Branch 9 taken 37127 times.
✓ Branch 10 taken 678 times.
✓ Branch 11 taken 36449 times.
✗ Branch 13 not taken.
✓ Branch 14 taken 36449 times.
✓ Branch 15 taken 81044 times.
✓ Branch 16 taken 36449 times.
 50637337 MERGE_FORMATS(a, b, formats, nb_formats, AVFilterFormats, check, 0);
132
133 36449 return 1;
134 }
135
136
137 /**
138 * Check the formats lists for compatibility for merging without actually
139 * merging.
140 *
141 * @return 1 if they are compatible, 0 if not.
142 */
143 29902 static int can_merge_pix_fmts(const void *a, const void *b)
144 {
145 29902 return merge_formats_internal((AVFilterFormats *)a,
146 (AVFilterFormats *)b, AVMEDIA_TYPE_VIDEO, 1);
147 }
148
149 /**
150 * Merge the formats lists if they are compatible and update all the
151 * references of a and b to point to the combined list and free the old
152 * lists as needed. The combined list usually contains the intersection of
153 * the lists of a and b.
154 *
155 * Both a and b must have owners (i.e. refcount > 0) for these functions.
156 *
157 * @return 1 if merging succeeded, 0 if a and b are incompatible
158 * and negative AVERROR code on failure.
159 * a and b are unmodified if 0 is returned.
160 */
161 30524 static int merge_pix_fmts(void *a, void *b)
162 {
163 30524 return merge_formats_internal(a, b, AVMEDIA_TYPE_VIDEO, 0);
164 }
165
166 /**
167 * See can_merge_pix_fmts().
168 */
169 5294 static int can_merge_sample_fmts(const void *a, const void *b)
170 {
171 5294 return merge_formats_internal((AVFilterFormats *)a,
172 (AVFilterFormats *)b, AVMEDIA_TYPE_AUDIO, 1);
173 }
174
175 /**
176 * See merge_pix_fmts().
177 */
178 5925 static int merge_sample_fmts(void *a, void *b)
179 {
180 5925 return merge_formats_internal(a, b, AVMEDIA_TYPE_AUDIO, 0);
181 }
182
183 11219 static int merge_samplerates_internal(AVFilterFormats *a,
184 AVFilterFormats *b, int check)
185 {
186 av_assert2(check || (a->refcount && b->refcount));
187
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 11219 times.
 11219 if (a == b) return 1;
188
189
23/24
✓ Branch 0 taken 7102 times.
✓ Branch 1 taken 4117 times.
✓ Branch 2 taken 6973 times.
✓ Branch 3 taken 129 times.
✓ Branch 4 taken 5214 times.
✓ Branch 5 taken 5876 times.
✓ Branch 6 taken 2374 times.
✓ Branch 7 taken 3502 times.
✓ Branch 8 taken 129 times.
✓ Branch 9 taken 5876 times.
✓ Branch 10 taken 123 times.
✓ Branch 11 taken 48 times.
✓ Branch 12 taken 74 times.
✓ Branch 13 taken 49 times.
✓ Branch 14 taken 171 times.
✓ Branch 15 taken 6 times.
✓ Branch 16 taken 129 times.
✓ Branch 17 taken 55 times.
✓ Branch 18 taken 6 times.
✓ Branch 19 taken 49 times.
✗ Branch 21 not taken.
✓ Branch 22 taken 5925 times.
✓ Branch 23 taken 26413 times.
✓ Branch 24 taken 5925 times.
 37735 MERGE_FORMATS(a, b, formats, nb_formats, AVFilterFormats, check, 1);
190 5925 return 1;
191 }
192
193 /**
194 * See can_merge_pix_fmts().
195 */
196 5294 static int can_merge_samplerates(const void *a, const void *b)
197 {
198 5294 return merge_samplerates_internal((AVFilterFormats *)a, (AVFilterFormats *)b, 1);
199 }
200
201 /**
202 * See merge_pix_fmts().
203 */
204 5925 static int merge_samplerates(void *a, void *b)
205 {
206 5925 return merge_samplerates_internal(a, b, 0);
207 }
208
209 /**
210 * See merge_pix_fmts().
211 */
212 6621 static int merge_channel_layouts_internal(AVFilterChannelLayouts *a,
213 AVFilterChannelLayouts *b, int check)
214 {
215 6621 AVChannelLayout *channel_layouts = NULL;
216 6621 unsigned a_all = a->all_layouts + a->all_counts;
217 6621 unsigned b_all = b->all_layouts + b->all_counts;
218 6621 int ret_max, ret_nb = 0, i, j, round;
219
220 av_assert2(a->refcount && b->refcount);
221
222
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6621 times.
 6621 if (a == b) return 1;
223
224 /* Put the most generic set in a, to avoid doing everything twice */
225
2/2
✓ Branch 0 taken 3333 times.
✓ Branch 1 taken 3288 times.
 6621 if (a_all < b_all) {
226 3333 FFSWAP(AVFilterChannelLayouts *, a, b);
227 3333 FFSWAP(unsigned, a_all, b_all);
228 }
229
2/2
✓ Branch 0 taken 6440 times.
✓ Branch 1 taken 181 times.
 6621 if (a_all) {
230
3/4
✓ Branch 0 taken 70 times.
✓ Branch 1 taken 6370 times.
✓ Branch 2 taken 70 times.
✗ Branch 3 not taken.
 6440 if (a_all == 1 && !b_all) {
231 /* keep only known layouts in b; works also for b_all = 1 */
232
2/2
✓ Branch 0 taken 70 times.
✓ Branch 1 taken 70 times.
 140 for (i = j = 0; i < b->nb_channel_layouts; i++)
233
2/6
✗ Branch 0 not taken.
✓ Branch 1 taken 70 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 70 times.
 70 if (KNOWN(&b->channel_layouts[i]) && i != j++) {
234 ✗ if (check)
235 ✗ return 1;
236 ✗ av_channel_layout_copy(&b->channel_layouts[j], &b->channel_layouts[i]);
237 }
238 /* Not optimal: the unknown layouts of b may become known after
239 another merge. */
240
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 70 times.
 70 if (!j)
241 ✗ return 0;
242 70 b->nb_channel_layouts = j;
243 }
244
3/4
✗ Branch 1 not taken.
✓ Branch 2 taken 6440 times.
✓ Branch 3 taken 11120 times.
✓ Branch 4 taken 6440 times.
 17560 MERGE_REF(b, a, channel_layouts, AVFilterChannelLayouts, return AVERROR(ENOMEM););
245 6440 return 1;
246 }
247
248 181 ret_max = a->nb_channel_layouts + b->nb_channel_layouts;
249
3/4
✓ Branch 0 taken 65 times.
✓ Branch 1 taken 116 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 65 times.
 181 if (!check && !(channel_layouts = av_calloc(ret_max, sizeof(*channel_layouts))))
250 ✗ return AVERROR(ENOMEM);
251
252 /* a[known] intersect b[known] */
253
2/2
✓ Branch 0 taken 181 times.
✓ Branch 1 taken 73 times.
 254 for (i = 0; i < a->nb_channel_layouts; i++) {
254
3/4
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 180 times.
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
 181 if (!KNOWN(&a->channel_layouts[i]))
255 1 continue;
256
2/2
✓ Branch 0 taken 276 times.
✓ Branch 1 taken 7 times.
 283 for (j = 0; j < b->nb_channel_layouts; j++) {
257
2/2
✓ Branch 1 taken 173 times.
✓ Branch 2 taken 103 times.
 276 if (!av_channel_layout_compare(&a->channel_layouts[i], &b->channel_layouts[j])) {
258
2/2
✓ Branch 0 taken 108 times.
✓ Branch 1 taken 65 times.
 173 if (check)
259 108 return 1;
260 65 av_channel_layout_copy(&channel_layouts[ret_nb++], &a->channel_layouts[i]);
261 65 av_channel_layout_uninit(&a->channel_layouts[i]);
262 65 av_channel_layout_uninit(&b->channel_layouts[j]);
263 65 break;
264 }
265 }
266 }
267 /* 1st round: a[known] intersect b[generic]
268 2nd round: a[generic] intersect b[known] */
269
2/2
✓ Branch 0 taken 146 times.
✓ Branch 1 taken 72 times.
 218 for (round = 0; round < 2; round++) {
270
2/2
✓ Branch 0 taken 232 times.
✓ Branch 1 taken 145 times.
 377 for (i = 0; i < a->nb_channel_layouts; i++) {
271 232 AVChannelLayout *fmt = &a->channel_layouts[i], bfmt = { 0 };
272
5/6
✓ Branch 1 taken 102 times.
✓ Branch 2 taken 130 times.
✓ Branch 3 taken 1 times.
✓ Branch 4 taken 101 times.
✓ Branch 5 taken 1 times.
✗ Branch 6 not taken.
 232 if (!av_channel_layout_check(fmt) || !KNOWN(fmt))
273 131 continue;
274 101 bfmt = FF_COUNT2LAYOUT(fmt->nb_channels);
275
2/2
✓ Branch 0 taken 101 times.
✓ Branch 1 taken 100 times.
 201 for (j = 0; j < b->nb_channel_layouts; j++)
276
2/2
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 100 times.
 101 if (!av_channel_layout_compare(&b->channel_layouts[j], &bfmt)) {
277
1/2
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
 1 if (check)
278 1 return 1;
279 ✗ av_channel_layout_copy(&channel_layouts[ret_nb++], fmt);
280 }
281 }
282 /* 1st round: swap to prepare 2nd round; 2nd round: put it back */
283 145 FFSWAP(AVFilterChannelLayouts *, a, b);
284 }
285 /* a[generic] intersect b[generic] */
286
2/2
✓ Branch 0 taken 72 times.
✓ Branch 1 taken 72 times.
 144 for (i = 0; i < a->nb_channel_layouts; i++) {
287
3/4
✓ Branch 0 taken 65 times.
✓ Branch 1 taken 7 times.
✓ Branch 2 taken 65 times.
✗ Branch 3 not taken.
 72 if (KNOWN(&a->channel_layouts[i]))
288 72 continue;
289 ✗ for (j = 0; j < b->nb_channel_layouts; j++)
290 ✗ if (!av_channel_layout_compare(&a->channel_layouts[i], &b->channel_layouts[j])) {
291 ✗ if (check)
292 ✗ return 1;
293 ✗ av_channel_layout_copy(&channel_layouts[ret_nb++], &a->channel_layouts[i]);
294 }
295 }
296
297
2/2
✓ Branch 0 taken 7 times.
✓ Branch 1 taken 65 times.
 72 if (!ret_nb) {
298 7 av_free(channel_layouts);
299 7 return 0;
300 }
301
302
2/2
✓ Branch 0 taken 12 times.
✓ Branch 1 taken 53 times.
 65 if (a->refcount > b->refcount)
303 12 FFSWAP(AVFilterChannelLayouts *, a, b);
304
305
3/4
✗ Branch 1 not taken.
✓ Branch 2 taken 65 times.
✓ Branch 4 taken 131 times.
✓ Branch 5 taken 65 times.
 196 MERGE_REF(b, a, channel_layouts, AVFilterChannelLayouts,
306 { av_free(channel_layouts); return AVERROR(ENOMEM); });
307 65 av_freep(&b->channel_layouts);
308 65 b->channel_layouts = channel_layouts;
309 65 b->nb_channel_layouts = ret_nb;
310 65 return 1;
311 }
312
313 5294 static int can_merge_channel_layouts(const void *a, const void *b)
314 {
315 5294 return merge_channel_layouts_internal((AVFilterChannelLayouts *)a,
316 (AVFilterChannelLayouts *)b, 1);
317 }
318
319 1327 static int merge_channel_layouts(void *a, void *b)
320 {
321 1327 return merge_channel_layouts_internal(a, b, 0);
322 }
323
324 181269 static int merge_generic_internal(AVFilterFormats *a,
325 AVFilterFormats *b, int check)
326 {
327 av_assert2(check || (a->refcount && b->refcount));
328
329
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 181269 times.
 181269 if (a == b)
330 ✗ return 1;
331
332
14/16
✓ Branch 0 taken 181269 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 510732 times.
✓ Branch 3 taken 1768972 times.
✓ Branch 4 taken 90258 times.
✓ Branch 5 taken 420474 times.
✓ Branch 6 taken 2279704 times.
✓ Branch 7 taken 19156 times.
✓ Branch 8 taken 529888 times.
✓ Branch 9 taken 91011 times.
✓ Branch 10 taken 64 times.
✓ Branch 11 taken 90947 times.
✗ Branch 13 not taken.
✓ Branch 14 taken 90947 times.
✓ Branch 15 taken 167739 times.
✓ Branch 16 taken 90947 times.
 2557610 MERGE_FORMATS(a, b, formats, nb_formats, AVFilterFormats, check, 0);
333
334 90947 return 1;
335 }
336
337 90322 static int can_merge_generic(const void *a, const void *b)
338 {
339 90322 return merge_generic_internal((AVFilterFormats *)a,
340 (AVFilterFormats *)b, 1);
341 }
342
343 90947 static int merge_generic(void *a, void *b)
344 {
345 90947 return merge_generic_internal(a, b, 0);
346 }
347
348 #define CONVERSION_FILTER_SWSCALE \
349 .conversion_filter = "scale", \
350 .conversion_opts_offset = offsetof(AVFilterGraph, scale_sws_opts),
351
352 #define CONVERSION_FILTER_ARESAMPLE \
353 .conversion_filter = "aresample", \
354 .conversion_opts_offset = offsetof(AVFilterGraph, aresample_swr_opts),
355
356 static const AVFilterFormatsMerger mergers_video[] = {
357 {
358 .offset = offsetof(AVFilterFormatsConfig, formats),
359 .merge = merge_pix_fmts,
360 .can_merge = can_merge_pix_fmts,
361 CONVERSION_FILTER_SWSCALE
362 },
363 {
364 .offset = offsetof(AVFilterFormatsConfig, color_spaces),
365 .merge = merge_generic,
366 .can_merge = can_merge_generic,
367 CONVERSION_FILTER_SWSCALE
368 },
369 {
370 .offset = offsetof(AVFilterFormatsConfig, color_ranges),
371 .merge = merge_generic,
372 .can_merge = can_merge_generic,
373 CONVERSION_FILTER_SWSCALE
374 },
375 {
376 .offset = offsetof(AVFilterFormatsConfig, alpha_modes),
377 .merge = merge_generic,
378 .can_merge = can_merge_generic,
379 .conversion_filter = "premultiply_dynamic",
380 },
381 };
382
383 static const AVFilterFormatsMerger mergers_audio[] = {
384 {
385 .offset = offsetof(AVFilterFormatsConfig, channel_layouts),
386 .merge = merge_channel_layouts,
387 .can_merge = can_merge_channel_layouts,
388 CONVERSION_FILTER_ARESAMPLE
389 },
390 {
391 .offset = offsetof(AVFilterFormatsConfig, samplerates),
392 .merge = merge_samplerates,
393 .can_merge = can_merge_samplerates,
394 CONVERSION_FILTER_ARESAMPLE
395 },
396 {
397 .offset = offsetof(AVFilterFormatsConfig, formats),
398 .merge = merge_sample_fmts,
399 .can_merge = can_merge_sample_fmts,
400 CONVERSION_FILTER_ARESAMPLE
401 },
402 };
403
404 static const AVFilterNegotiation negotiate_video = {
405 .nb_mergers = FF_ARRAY_ELEMS(mergers_video),
406 .mergers = mergers_video,
407 };
408
409 static const AVFilterNegotiation negotiate_audio = {
410 .nb_mergers = FF_ARRAY_ELEMS(mergers_audio),
411 .mergers = mergers_audio,
412 };
413
414 36500 const AVFilterNegotiation *ff_filter_get_negotiation(AVFilterLink *link)
415 {
416
2/3
✓ Branch 0 taken 30571 times.
✓ Branch 1 taken 5929 times.
✗ Branch 2 not taken.
 36500 switch (link->type) {
417 30571 case AVMEDIA_TYPE_VIDEO: return &negotiate_video;
418 5929 case AVMEDIA_TYPE_AUDIO: return &negotiate_audio;
419 ✗ default: return NULL;
420 }
421 }
422
423 194 int ff_fmt_is_in(int fmt, const int *fmts)
424 {
425 const int *p;
426
427
2/2
✓ Branch 0 taken 2185 times.
✓ Branch 1 taken 107 times.
 2292 for (p = fmts; *p != -1; p++) {
428
2/2
✓ Branch 0 taken 87 times.
✓ Branch 1 taken 2098 times.
 2185 if (fmt == *p)
429 87 return 1;
430 }
431 107 return 0;
432 }
433
434 #define MAKE_FORMAT_LIST(type, field, count_field) \
435 type *formats; \
436 int count = 0; \
437 if (fmts) \
438 for (count = 0; fmts[count] != -1; count++) \
439 ; \
440 formats = av_mallocz(sizeof(*formats)); \
441 if (!formats) \
442 return NULL; \
443 formats->count_field = count; \
444 if (count) { \
445 formats->field = av_malloc_array(count, sizeof(*formats->field)); \
446 if (!formats->field) { \
447 av_freep(&formats); \
448 return NULL; \
449 } \
450 }
451
452 4367 AVFilterFormats *ff_make_format_list(const int *fmts)
453 {
454
6/10
✓ Branch 0 taken 4367 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 46939 times.
✓ Branch 3 taken 4367 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 4367 times.
✓ Branch 7 taken 4367 times.
✗ Branch 8 not taken.
✗ Branch 10 not taken.
✓ Branch 11 taken 4367 times.
 51306 MAKE_FORMAT_LIST(AVFilterFormats, formats, nb_formats);
455
2/2
✓ Branch 0 taken 46939 times.
✓ Branch 1 taken 4367 times.
 51306 while (count--)
456 46939 formats->formats[count] = fmts[count];
457
458 4367 return formats;
459 }
460
461 214 AVFilterChannelLayouts *ff_make_channel_layout_list(const AVChannelLayout *fmts)
462 {
463 AVFilterChannelLayouts *ch_layouts;
464 214 int count = 0;
465
1/2
✓ Branch 0 taken 214 times.
✗ Branch 1 not taken.
 214 if (fmts)
466
2/2
✓ Branch 0 taken 538 times.
✓ Branch 1 taken 214 times.
 752 for (count = 0; fmts[count].nb_channels; count++)
467 ;
468 214 ch_layouts = av_mallocz(sizeof(*ch_layouts));
469
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 214 times.
 214 if (!ch_layouts)
470 ✗ return NULL;
471 214 ch_layouts->nb_channel_layouts = count;
472
1/2
✓ Branch 0 taken 214 times.
✗ Branch 1 not taken.
 214 if (count) {
473 428 ch_layouts->channel_layouts =
474 214 av_calloc(count, sizeof(*ch_layouts->channel_layouts));
475
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 214 times.
 214 if (!ch_layouts->channel_layouts) {
476 ✗ av_freep(&ch_layouts);
477 ✗ return NULL;
478 }
479
2/2
✓ Branch 0 taken 538 times.
✓ Branch 1 taken 214 times.
 752 for (int i = 0; i < count; i++) {
480 538 int ret = av_channel_layout_copy(&ch_layouts->channel_layouts[i], &fmts[i]);
481
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 538 times.
 538 if (ret < 0)
482 ✗ goto fail;
483 }
484 }
485
486 214 return ch_layouts;
487
488 ✗ fail:
489 ✗ for (int i = 0; i < count; i++)
490 ✗ av_channel_layout_uninit(&ch_layouts->channel_layouts[i]);
491 ✗ av_free(ch_layouts->channel_layouts);
492 ✗ av_freep(&ch_layouts);
493
494 ✗ return NULL;
495 }
496
497 #define ADD_FORMAT(f, fmt, unref_fn, type, list, nb) \
498 do { \
499 type *fmts; \
500 \
501 if (!(*f) && !(*f = av_mallocz(sizeof(**f)))) { \
502 return AVERROR(ENOMEM); \
503 } \
504 \
505 fmts = av_realloc_array((*f)->list, (*f)->nb + 1, \
506 sizeof(*(*f)->list)); \
507 if (!fmts) { \
508 unref_fn(f); \
509 return AVERROR(ENOMEM); \
510 } \
511 \
512 (*f)->list = fmts; \
513 ASSIGN_FMT(f, fmt, list, nb); \
514 } while (0)
515
516 #define ASSIGN_FMT(f, fmt, list, nb) \
517 do { \
518 (*f)->list[(*f)->nb++] = fmt; \
519 } while (0)
520
521 4453731 int ff_add_format(AVFilterFormats **avff, int64_t fmt)
522 {
523
4/6
✓ Branch 0 taken 220503 times.
✓ Branch 1 taken 4233228 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 220503 times.
✗ Branch 6 not taken.
✓ Branch 7 taken 4453731 times.
 4453731 ADD_FORMAT(avff, fmt, ff_formats_unref, int, formats, nb_formats);
524 4453731 return 0;
525 }
526
527 #undef ASSIGN_FMT
528 #define ASSIGN_FMT(f, fmt, list, nb) \
529 do { \
530 int ret; \
531 memset((*f)->list + (*f)->nb, 0, sizeof(*(*f)->list)); \
532 ret = av_channel_layout_copy(&(*f)->list[(*f)->nb], fmt); \
533 if (ret < 0) \
534 return ret; \
535 (*f)->nb++; \
536 } while (0)
537
538 2271 int ff_add_channel_layout(AVFilterChannelLayouts **l,
539 const AVChannelLayout *channel_layout)
540 {
541 av_assert1(!(*l && (*l)->all_layouts));
542
5/8
✓ Branch 0 taken 1427 times.
✓ Branch 1 taken 844 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 1427 times.
✗ Branch 6 not taken.
✓ Branch 7 taken 2271 times.
✗ Branch 10 not taken.
✓ Branch 11 taken 2271 times.
 2271 ADD_FORMAT(l, channel_layout, ff_channel_layouts_unref, AVChannelLayout, channel_layouts, nb_channel_layouts);
543 2271 return 0;
544 }
545
546 70 AVFilterFormats *ff_make_formats_list_singleton(int fmt)
547 {
548 70 int fmts[2] = { fmt, -1 };
549 70 return ff_make_format_list(fmts);
550 }
551
552 46105 AVFilterFormats *ff_all_formats(enum AVMediaType type)
553 {
554 46105 AVFilterFormats *ret = NULL;
555
556
2/2
✓ Branch 0 taken 35943 times.
✓ Branch 1 taken 10162 times.
 46105 if (type == AVMEDIA_TYPE_VIDEO) {
557 35943 return ff_formats_pixdesc_filter(0, 0);
558
1/2
✓ Branch 0 taken 10162 times.
✗ Branch 1 not taken.
 10162 } else if (type == AVMEDIA_TYPE_AUDIO) {
559 10162 enum AVSampleFormat fmt = 0;
560
2/2
✓ Branch 1 taken 121944 times.
✓ Branch 2 taken 10162 times.
 132106 while (av_get_sample_fmt_name(fmt)) {
561
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 121944 times.
 121944 if (ff_add_format(&ret, fmt) < 0)
562 ✗ return NULL;
563 121944 fmt++;
564 }
565 }
566
567 10162 return ret;
568 }
569
570 36588 AVFilterFormats *ff_formats_pixdesc_filter(unsigned want, unsigned rej)
571 {
572 unsigned nb_formats, fmt, flags;
573 36588 AVFilterFormats *formats = NULL;
574
575 while (1) {
576 73176 nb_formats = 0;
577 19611168 for (fmt = 0;; fmt++) {
578 19611168 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(fmt);
579
2/2
✓ Branch 0 taken 73176 times.
✓ Branch 1 taken 19537992 times.
 19611168 if (!desc)
580 73176 break;
581 19537992 flags = desc->flags;
582
2/2
✓ Branch 0 taken 18367176 times.
✓ Branch 1 taken 1170816 times.
 19537992 if (!(desc->flags & AV_PIX_FMT_FLAG_HWACCEL) &&
583
2/2
✓ Branch 0 taken 8634768 times.
✓ Branch 1 taken 9732408 times.
 18367176 !(desc->flags & AV_PIX_FMT_FLAG_PLANAR) &&
584
3/4
✓ Branch 0 taken 7903008 times.
✓ Branch 1 taken 731760 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 7903008 times.
 8634768 (desc->log2_chroma_w || desc->log2_chroma_h))
585 731760 flags |= FF_PIX_FMT_FLAG_SW_FLAT_SUB;
586
2/2
✓ Branch 0 taken 21420 times.
✓ Branch 1 taken 19516572 times.
 19537992 if ((flags & (want | rej)) != want)
587 21420 continue;
588
2/2
✓ Branch 0 taken 9758286 times.
✓ Branch 1 taken 9758286 times.
 19516572 if (formats)
589 9758286 formats->formats[nb_formats] = fmt;
590 19516572 nb_formats++;
591 }
592
2/2
✓ Branch 0 taken 36588 times.
✓ Branch 1 taken 36588 times.
 73176 if (formats) {
593
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 36588 times.
 36588 av_assert0(formats->nb_formats == nb_formats);
594 36588 return formats;
595 }
596 36588 formats = av_mallocz(sizeof(*formats));
597
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 36588 times.
 36588 if (!formats)
598 ✗ return NULL;
599 36588 formats->nb_formats = nb_formats;
600
1/2
✓ Branch 0 taken 36588 times.
✗ Branch 1 not taken.
 36588 if (nb_formats) {
601 36588 formats->formats = av_malloc_array(nb_formats, sizeof(*formats->formats));
602
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 36588 times.
 36588 if (!formats->formats) {
603 ✗ av_freep(&formats);
604 ✗ return NULL;
605 }
606 }
607 }
608 }
609
610 61 AVFilterFormats *ff_planar_sample_fmts(void)
611 {
612 61 AVFilterFormats *ret = NULL;
613 int fmt;
614
615
2/2
✓ Branch 1 taken 732 times.
✓ Branch 2 taken 61 times.
 793 for (fmt = 0; av_get_bytes_per_sample(fmt)>0; fmt++)
616
2/2
✓ Branch 1 taken 366 times.
✓ Branch 2 taken 366 times.
 732 if (av_sample_fmt_is_planar(fmt))
617
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 366 times.
 366 if (ff_add_format(&ret, fmt) < 0)
618 ✗ return NULL;
619
620 61 return ret;
621 }
622
623 45496 AVFilterFormats *ff_all_samplerates(void)
624 {
625 45496 AVFilterFormats *ret = av_mallocz(sizeof(*ret));
626 45496 return ret;
627 }
628
629 70 AVFilterChannelLayouts *ff_all_channel_layouts(void)
630 {
631 70 AVFilterChannelLayouts *ret = av_mallocz(sizeof(*ret));
632
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 70 times.
 70 if (!ret)
633 ✗ return NULL;
634 70 ret->all_layouts = 1;
635 70 return ret;
636 }
637
638 46157 AVFilterChannelLayouts *ff_all_channel_counts(void)
639 {
640 46157 AVFilterChannelLayouts *ret = av_mallocz(sizeof(*ret));
641
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 46157 times.
 46157 if (!ret)
642 ✗ return NULL;
643 46157 ret->all_layouts = ret->all_counts = 1;
644 46157 return ret;
645 }
646
647 57688 AVFilterFormats *ff_all_color_spaces(void)
648 {
649 57688 AVFilterFormats *ret = NULL;
650
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 57688 times.
 57688 if (ff_add_format(&ret, AVCOL_SPC_UNSPECIFIED) < 0)
651 ✗ return NULL;
652
2/2
✓ Branch 0 taken 1038384 times.
✓ Branch 1 taken 57688 times.
 1096072 for (int csp = 0; csp < AVCOL_SPC_NB; csp++) {
653
4/4
✓ Branch 0 taken 980696 times.
✓ Branch 1 taken 57688 times.
✓ Branch 2 taken 57688 times.
✓ Branch 3 taken 923008 times.
 1038384 if (csp == AVCOL_SPC_RESERVED ||
654 csp == AVCOL_SPC_UNSPECIFIED)
655 115376 continue;
656
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 923008 times.
 923008 if (ff_add_format(&ret, csp) < 0)
657 ✗ return NULL;
658 }
659
660 57688 return ret;
661 }
662
663 57688 AVFilterFormats *ff_all_color_ranges(void)
664 {
665 57688 AVFilterFormats *ret = NULL;
666
2/2
✓ Branch 0 taken 173064 times.
✓ Branch 1 taken 57688 times.
 230752 for (int range = 0; range < AVCOL_RANGE_NB; range++) {
667
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 173064 times.
 173064 if (ff_add_format(&ret, range) < 0)
668 ✗ return NULL;
669 }
670
671 57688 return ret;
672 }
673
674 44562 AVFilterFormats *ff_all_alpha_modes(void)
675 {
676 44562 AVFilterFormats *ret = NULL;
677
2/2
✓ Branch 0 taken 133686 times.
✓ Branch 1 taken 44562 times.
 178248 for (int range = 0; range < AVALPHA_MODE_NB; range++) {
678
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 133686 times.
 133686 if (ff_add_format(&ret, range) < 0)
679 ✗ return NULL;
680 }
681
682 44562 return ret;
683 }
684
685 #define FORMATS_REF(f, ref, unref_fn) \
686 void *tmp; \
687 \
688 if (!f) \
689 return AVERROR(ENOMEM); \
690 \
691 tmp = av_realloc_array(f->refs, f->refcount + 1, sizeof(*f->refs)); \
692 if (!tmp) { \
693 unref_fn(&f); \
694 return AVERROR(ENOMEM); \
695 } \
696 f->refs = tmp; \
697 f->refs[f->refcount++] = ref; \
698 *ref = f; \
699 return 0
700
701 11850 int ff_channel_layouts_ref(AVFilterChannelLayouts *f, AVFilterChannelLayouts **ref)
702 {
703
2/4
✗ Branch 0 not taken.
✓ Branch 1 taken 11850 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 11850 times.
 11850 FORMATS_REF(f, ref, ff_channel_layouts_unref);
704 }
705
706 286102 int ff_formats_ref(AVFilterFormats *f, AVFilterFormats **ref)
707 {
708
2/4
✗ Branch 0 not taken.
✓ Branch 1 taken 286102 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 286102 times.
 286102 FORMATS_REF(f, ref, ff_formats_unref);
709 }
710
711 #define FIND_REF_INDEX(ref, idx) \
712 do { \
713 int i; \
714 for (i = 0; i < (*ref)->refcount; i ++) \
715 if((*ref)->refs[i] == ref) { \
716 idx = i; \
717 break; \
718 } \
719 } while (0)
720
721 #define FORMATS_UNREF(ref, list) \
722 do { \
723 int idx = -1; \
724 \
725 if (!*ref) \
726 return; \
727 \
728 FIND_REF_INDEX(ref, idx); \
729 \
730 if (idx >= 0) { \
731 memmove((*ref)->refs + idx, (*ref)->refs + idx + 1, \
732 sizeof(*(*ref)->refs) * ((*ref)->refcount - idx - 1)); \
733 --(*ref)->refcount; \
734 } \
735 if (!(*ref)->refcount) { \
736 FREE_LIST(ref, list); \
737 av_free((*ref)->list); \
738 av_free((*ref)->refs); \
739 av_free(*ref); \
740 } \
741 *ref = NULL; \
742 } while (0)
743
744 #define FREE_LIST(ref, list) do { } while(0)
745 1009932 void ff_formats_unref(AVFilterFormats **ref)
746 {
747
10/10
✓ Branch 0 taken 608680 times.
✓ Branch 1 taken 401252 times.
✓ Branch 2 taken 286102 times.
✓ Branch 3 taken 144215 times.
✓ Branch 4 taken 430317 times.
✓ Branch 5 taken 115150 times.
✓ Branch 6 taken 286102 times.
✓ Branch 7 taken 115150 times.
✓ Branch 8 taken 173633 times.
✓ Branch 9 taken 227619 times.
 1154147 FORMATS_UNREF(ref, formats);
748 }
749
750 #undef FREE_LIST
751 #define FREE_LIST(ref, list) \
752 do { \
753 for (int i = 0; i < (*ref)->nb_channel_layouts; i++) \
754 av_channel_layout_uninit(&(*ref)->list[i]); \
755 } while(0)
756
757 205409 void ff_channel_layouts_unref(AVFilterChannelLayouts **ref)
758 {
759
12/12
✓ Branch 0 taken 154616 times.
✓ Branch 1 taken 50793 times.
✓ Branch 2 taken 11850 times.
✓ Branch 3 taken 8911 times.
✓ Branch 4 taken 20761 times.
✓ Branch 5 taken 38943 times.
✓ Branch 6 taken 11850 times.
✓ Branch 7 taken 38943 times.
✓ Branch 8 taken 41363 times.
✓ Branch 9 taken 9430 times.
✓ Branch 11 taken 2420 times.
✓ Branch 12 taken 41363 times.
 216740 FORMATS_UNREF(ref, channel_layouts);
760 }
761
762 #define FORMATS_CHANGEREF(oldref, newref) \
763 do { \
764 int idx = -1; \
765 \
766 FIND_REF_INDEX(oldref, idx); \
767 \
768 if (idx >= 0) { \
769 (*oldref)->refs[idx] = newref; \
770 *newref = *oldref; \
771 *oldref = NULL; \
772 } \
773 } while (0)
774
775 631 void ff_channel_layouts_changeref(AVFilterChannelLayouts **oldref,
776 AVFilterChannelLayouts **newref)
777 {
778
4/6
✓ Branch 0 taken 631 times.
✓ Branch 1 taken 1641 times.
✓ Branch 2 taken 2272 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 631 times.
✗ Branch 5 not taken.
 2272 FORMATS_CHANGEREF(oldref, newref);
779 631 }
780
781 3750 void ff_formats_changeref(AVFilterFormats **oldref, AVFilterFormats **newref)
782 {
783
4/6
✓ Branch 0 taken 3750 times.
✓ Branch 1 taken 8054 times.
✓ Branch 2 taken 11804 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 3750 times.
✗ Branch 5 not taken.
 11804 FORMATS_CHANGEREF(oldref, newref);
784 3750 }
785
786 #define SET_COMMON_FORMATS(ctx, fmts, media_type, ref_fn, unref_fn) \
787 int i; \
788 \
789 if (!fmts) \
790 return AVERROR(ENOMEM); \
791 \
792 for (i = 0; i < ctx->nb_inputs; i++) { \
793 AVFilterLink *const link = ctx->inputs[i]; \
794 if (link && !link->outcfg.fmts && \
795 (media_type == AVMEDIA_TYPE_UNKNOWN || link->type == media_type)) { \
796 int ret = ref_fn(fmts, &ctx->inputs[i]->outcfg.fmts); \
797 if (ret < 0) { \
798 return ret; \
799 } \
800 } \
801 } \
802 for (i = 0; i < ctx->nb_outputs; i++) { \
803 AVFilterLink *const link = ctx->outputs[i]; \
804 if (link && !link->incfg.fmts && \
805 (media_type == AVMEDIA_TYPE_UNKNOWN || link->type == media_type)) { \
806 int ret = ref_fn(fmts, &ctx->outputs[i]->incfg.fmts); \
807 if (ret < 0) { \
808 return ret; \
809 } \
810 } \
811 } \
812 \
813 if (!fmts->refcount) \
814 unref_fn(&fmts); \
815 \
816 return 0;
817
818 43152 int ff_set_common_channel_layouts(AVFilterContext *ctx,
819 AVFilterChannelLayouts *channel_layouts)
820 {
821
19/24
✗ Branch 0 not taken.
✓ Branch 1 taken 43152 times.
✓ Branch 2 taken 36105 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 34398 times.
✓ Branch 5 taken 1707 times.
✓ Branch 6 taken 4218 times.
✓ Branch 7 taken 30180 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 4218 times.
✓ Branch 11 taken 36105 times.
✓ Branch 12 taken 43152 times.
✓ Branch 13 taken 35020 times.
✗ Branch 14 not taken.
✓ Branch 15 taken 31891 times.
✓ Branch 16 taken 3129 times.
✓ Branch 17 taken 2796 times.
✓ Branch 18 taken 29095 times.
✗ Branch 20 not taken.
✓ Branch 21 taken 2796 times.
✓ Branch 22 taken 35020 times.
✓ Branch 23 taken 43152 times.
✓ Branch 24 taken 38943 times.
✓ Branch 25 taken 4209 times.
 114277 SET_COMMON_FORMATS(ctx, channel_layouts, AVMEDIA_TYPE_AUDIO,
822 ff_channel_layouts_ref, ff_channel_layouts_unref);
823 }
824
825 ✗ int ff_set_common_channel_layouts_from_list(AVFilterContext *ctx,
826 const AVChannelLayout *fmts)
827 {
828 ✗ return ff_set_common_channel_layouts(ctx, ff_make_channel_layout_list(fmts));
829 }
830
831 43152 int ff_set_common_all_channel_counts(AVFilterContext *ctx)
832 {
833 43152 return ff_set_common_channel_layouts(ctx, ff_all_channel_counts());
834 }
835
836 43153 int ff_set_common_samplerates(AVFilterContext *ctx,
837 AVFilterFormats *samplerates)
838 {
839
19/24
✗ Branch 0 not taken.
✓ Branch 1 taken 43153 times.
✓ Branch 2 taken 36107 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 34522 times.
✓ Branch 5 taken 1585 times.
✓ Branch 6 taken 4342 times.
✓ Branch 7 taken 30180 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 4342 times.
✓ Branch 11 taken 36107 times.
✓ Branch 12 taken 43153 times.
✓ Branch 13 taken 35021 times.
✗ Branch 14 not taken.
✓ Branch 15 taken 32071 times.
✓ Branch 16 taken 2950 times.
✓ Branch 17 taken 2976 times.
✓ Branch 18 taken 29095 times.
✗ Branch 20 not taken.
✓ Branch 21 taken 2976 times.
✓ Branch 22 taken 35021 times.
✓ Branch 23 taken 43153 times.
✓ Branch 24 taken 38887 times.
✓ Branch 25 taken 4266 times.
 114281 SET_COMMON_FORMATS(ctx, samplerates, AVMEDIA_TYPE_AUDIO,
840 ff_formats_ref, ff_formats_unref);
841 }
842
843 ✗ int ff_set_common_samplerates_from_list(AVFilterContext *ctx,
844 const int *samplerates)
845 {
846 ✗ return ff_set_common_samplerates(ctx, ff_make_format_list(samplerates));
847 }
848
849 43153 int ff_set_common_all_samplerates(AVFilterContext *ctx)
850 {
851 43153 return ff_set_common_samplerates(ctx, ff_all_samplerates());
852 }
853
854 44562 int ff_set_common_color_spaces(AVFilterContext *ctx,
855 AVFilterFormats *color_spaces)
856 {
857
19/24
✗ Branch 0 not taken.
✓ Branch 1 taken 44562 times.
✓ Branch 2 taken 36421 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 29882 times.
✓ Branch 5 taken 6539 times.
✓ Branch 6 taken 23999 times.
✓ Branch 7 taken 5883 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 23999 times.
✓ Branch 11 taken 36421 times.
✓ Branch 12 taken 44562 times.
✓ Branch 13 taken 36430 times.
✗ Branch 14 not taken.
✓ Branch 15 taken 24854 times.
✓ Branch 16 taken 11576 times.
✓ Branch 17 taken 18962 times.
✓ Branch 18 taken 5892 times.
✗ Branch 20 not taken.
✓ Branch 21 taken 18962 times.
✓ Branch 22 taken 36430 times.
✓ Branch 23 taken 44562 times.
✓ Branch 24 taken 18755 times.
✓ Branch 25 taken 25807 times.
 117413 SET_COMMON_FORMATS(ctx, color_spaces, AVMEDIA_TYPE_VIDEO,
858 ff_formats_ref, ff_formats_unref);
859 }
860
861 ✗ int ff_set_common_color_spaces_from_list(AVFilterContext *ctx,
862 const int *color_spaces)
863 {
864 ✗ return ff_set_common_color_spaces(ctx, ff_make_format_list(color_spaces));
865 }
866
867 44562 int ff_set_common_all_color_spaces(AVFilterContext *ctx)
868 {
869 44562 return ff_set_common_color_spaces(ctx, ff_all_color_spaces());
870 }
871
872 44562 int ff_set_common_color_ranges(AVFilterContext *ctx,
873 AVFilterFormats *color_ranges)
874 {
875
19/24
✗ Branch 0 not taken.
✓ Branch 1 taken 44562 times.
✓ Branch 2 taken 36421 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 27764 times.
✓ Branch 5 taken 8657 times.
✓ Branch 6 taken 21881 times.
✓ Branch 7 taken 5883 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 21881 times.
✓ Branch 11 taken 36421 times.
✓ Branch 12 taken 44562 times.
✓ Branch 13 taken 36430 times.
✗ Branch 14 not taken.
✓ Branch 15 taken 22736 times.
✓ Branch 16 taken 13694 times.
✓ Branch 17 taken 16844 times.
✓ Branch 18 taken 5892 times.
✗ Branch 20 not taken.
✓ Branch 21 taken 16844 times.
✓ Branch 22 taken 36430 times.
✓ Branch 23 taken 44562 times.
✓ Branch 24 taken 20873 times.
✓ Branch 25 taken 23689 times.
 117413 SET_COMMON_FORMATS(ctx, color_ranges, AVMEDIA_TYPE_VIDEO,
876 ff_formats_ref, ff_formats_unref);
877 }
878
879 ✗ int ff_set_common_color_ranges_from_list(AVFilterContext *ctx,
880 const int *color_ranges)
881 {
882 ✗ return ff_set_common_color_ranges(ctx, ff_make_format_list(color_ranges));
883 }
884
885 44562 int ff_set_common_all_color_ranges(AVFilterContext *ctx)
886 {
887 44562 return ff_set_common_color_ranges(ctx, ff_all_color_ranges());
888 }
889
890 44562 int ff_set_common_alpha_modes(AVFilterContext *ctx,
891 AVFilterFormats *alpha_modes)
892 {
893
19/24
✗ Branch 0 not taken.
✓ Branch 1 taken 44562 times.
✓ Branch 2 taken 36421 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 36382 times.
✓ Branch 5 taken 39 times.
✓ Branch 6 taken 30499 times.
✓ Branch 7 taken 5883 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 30499 times.
✓ Branch 11 taken 36421 times.
✓ Branch 12 taken 44562 times.
✓ Branch 13 taken 36430 times.
✗ Branch 14 not taken.
✓ Branch 15 taken 36076 times.
✓ Branch 16 taken 354 times.
✓ Branch 17 taken 30184 times.
✓ Branch 18 taken 5892 times.
✗ Branch 20 not taken.
✓ Branch 21 taken 30184 times.
✓ Branch 22 taken 36430 times.
✓ Branch 23 taken 44562 times.
✓ Branch 24 taken 7530 times.
✓ Branch 25 taken 37032 times.
 117413 SET_COMMON_FORMATS(ctx, alpha_modes, AVMEDIA_TYPE_VIDEO,
894 ff_formats_ref, ff_formats_unref);
895 }
896
897 ✗ int ff_set_common_alpha_modes_from_list(AVFilterContext *ctx,
898 const int *alpha_modes)
899 {
900 ✗ return ff_set_common_alpha_modes(ctx, ff_make_format_list(alpha_modes));
901 }
902
903 44562 int ff_set_common_all_alpha_modes(AVFilterContext *ctx)
904 {
905 44562 return ff_set_common_alpha_modes(ctx, ff_all_alpha_modes());
906 }
907
908 /**
909 * A helper for query_formats() which sets all links to the same list of
910 * formats. If there are no links hooked to this filter, the list of formats is
911 * freed.
912 */
913 44596 int ff_set_common_formats(AVFilterContext *ctx, AVFilterFormats *formats)
914 {
915
15/20
✗ Branch 0 not taken.
✓ Branch 1 taken 44596 times.
✓ Branch 2 taken 36465 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 14415 times.
✓ Branch 5 taken 22050 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 14415 times.
✓ Branch 9 taken 36465 times.
✓ Branch 10 taken 44596 times.
✓ Branch 11 taken 36464 times.
✗ Branch 12 not taken.
✓ Branch 13 taken 7316 times.
✓ Branch 14 taken 29148 times.
✗ Branch 16 not taken.
✓ Branch 17 taken 7316 times.
✓ Branch 18 taken 36464 times.
✓ Branch 19 taken 44596 times.
✓ Branch 20 taken 29105 times.
✓ Branch 21 taken 15491 times.
 117525 SET_COMMON_FORMATS(ctx, formats, AVMEDIA_TYPE_UNKNOWN,
916 ff_formats_ref, ff_formats_unref);
917 }
918
919 1 int ff_set_common_formats_from_list(AVFilterContext *ctx, const int *fmts)
920 {
921 1 return ff_set_common_formats(ctx, ff_make_format_list(fmts));
922 }
923
924 #define SET_COMMON_FORMATS2(ctx, cfg_in, cfg_out, fmts, media_type, \
925 ref_fn, unref_fn) \
926 if (!fmts) \
927 return AVERROR(ENOMEM); \
928 \
929 for (unsigned i = 0; i < ctx->nb_inputs; i++) { \
930 const AVFilterLink *const link = ctx->inputs[i]; \
931 if (!cfg_in[i]->fmts && \
932 (media_type == AVMEDIA_TYPE_UNKNOWN || \
933 link->type == media_type)) { \
934 int ret = ref_fn(fmts, &cfg_in[i]->fmts); \
935 if (ret < 0) { \
936 return ret; \
937 } \
938 } \
939 } \
940 for (unsigned i = 0; i < ctx->nb_outputs; i++) { \
941 const AVFilterLink *const link = ctx->outputs[i]; \
942 if (!cfg_out[i]->fmts && \
943 (media_type == AVMEDIA_TYPE_UNKNOWN || \
944 link->type == media_type)) { \
945 int ret = ref_fn(fmts, &cfg_out[i]->fmts); \
946 if (ret < 0) { \
947 return ret; \
948 } \
949 } \
950 } \
951 \
952 if (!fmts->refcount) \
953 unref_fn(&fmts); \
954 \
955 return 0;
956
957 1481 int ff_set_common_channel_layouts2(const AVFilterContext *ctx,
958 AVFilterFormatsConfig **cfg_in,
959 AVFilterFormatsConfig **cfg_out,
960 AVFilterChannelLayouts *channel_layouts)
961 {
962
12/20
✗ Branch 0 not taken.
✓ Branch 1 taken 1481 times.
✓ Branch 2 taken 114 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 114 times.
✗ Branch 5 not taken.
✗ Branch 7 not taken.
✓ Branch 8 taken 114 times.
✓ Branch 9 taken 114 times.
✓ Branch 10 taken 1481 times.
✓ Branch 11 taken 1481 times.
✗ Branch 12 not taken.
✓ Branch 13 taken 1481 times.
✗ Branch 14 not taken.
✗ Branch 16 not taken.
✓ Branch 17 taken 1481 times.
✓ Branch 18 taken 1481 times.
✓ Branch 19 taken 1481 times.
✗ Branch 20 not taken.
✓ Branch 21 taken 1481 times.
 3076 SET_COMMON_FORMATS2(ctx, cfg_in, cfg_out, channel_layouts, AVMEDIA_TYPE_AUDIO,
963 ff_channel_layouts_ref, ff_channel_layouts_unref);
964 }
965
966 211 int ff_set_common_channel_layouts_from_list2(const AVFilterContext *ctx,
967 AVFilterFormatsConfig **cfg_in,
968 AVFilterFormatsConfig **cfg_out,
969 const AVChannelLayout *fmts)
970 {
971 211 return ff_set_common_channel_layouts2(ctx, cfg_in, cfg_out, ff_make_channel_layout_list(fmts));
972 }
973
974 ✗ int ff_set_common_all_channel_counts2(const AVFilterContext *ctx,
975 AVFilterFormatsConfig **cfg_in,
976 AVFilterFormatsConfig **cfg_out)
977 {
978 ✗ return ff_set_common_channel_layouts2(ctx, cfg_in, cfg_out, ff_all_channel_counts());
979 }
980
981 1453 int ff_set_common_samplerates2(const AVFilterContext *ctx,
982 AVFilterFormatsConfig **cfg_in,
983 AVFilterFormatsConfig **cfg_out,
984 AVFilterFormats *samplerates)
985 {
986
12/20
✗ Branch 0 not taken.
✓ Branch 1 taken 1453 times.
✓ Branch 2 taken 86 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 86 times.
✗ Branch 5 not taken.
✗ Branch 7 not taken.
✓ Branch 8 taken 86 times.
✓ Branch 9 taken 86 times.
✓ Branch 10 taken 1453 times.
✓ Branch 11 taken 1453 times.
✗ Branch 12 not taken.
✓ Branch 13 taken 1453 times.
✗ Branch 14 not taken.
✗ Branch 16 not taken.
✓ Branch 17 taken 1453 times.
✓ Branch 18 taken 1453 times.
✓ Branch 19 taken 1453 times.
✗ Branch 20 not taken.
✓ Branch 21 taken 1453 times.
 2992 SET_COMMON_FORMATS2(ctx, cfg_in, cfg_out, samplerates, AVMEDIA_TYPE_AUDIO,
987 ff_formats_ref, ff_formats_unref);
988 }
989
990 183 int ff_set_common_samplerates_from_list2(const AVFilterContext *ctx,
991 AVFilterFormatsConfig **cfg_in,
992 AVFilterFormatsConfig **cfg_out,
993 const int *samplerates)
994 {
995 183 return ff_set_common_samplerates2(ctx, cfg_in, cfg_out, ff_make_format_list(samplerates));
996 }
997
998 ✗ int ff_set_common_all_samplerates2(const AVFilterContext *ctx,
999 AVFilterFormatsConfig **cfg_in,
1000 AVFilterFormatsConfig **cfg_out)
1001 {
1002 ✗ return ff_set_common_samplerates2(ctx, cfg_in, cfg_out, ff_all_samplerates());
1003 }
1004
1005 5044 int ff_set_common_color_spaces2(const AVFilterContext *ctx,
1006 AVFilterFormatsConfig **cfg_in,
1007 AVFilterFormatsConfig **cfg_out,
1008 AVFilterFormats *color_spaces)
1009 {
1010
12/20
✗ Branch 0 not taken.
✓ Branch 1 taken 5044 times.
✓ Branch 2 taken 20 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 20 times.
✗ Branch 5 not taken.
✗ Branch 7 not taken.
✓ Branch 8 taken 20 times.
✓ Branch 9 taken 20 times.
✓ Branch 10 taken 5044 times.
✓ Branch 11 taken 5044 times.
✗ Branch 12 not taken.
✓ Branch 13 taken 5044 times.
✗ Branch 14 not taken.
✗ Branch 16 not taken.
✓ Branch 17 taken 5044 times.
✓ Branch 18 taken 5044 times.
✓ Branch 19 taken 5044 times.
✗ Branch 20 not taken.
✓ Branch 21 taken 5044 times.
 10108 SET_COMMON_FORMATS2(ctx, cfg_in, cfg_out, color_spaces, AVMEDIA_TYPE_VIDEO,
1011 ff_formats_ref, ff_formats_unref);
1012 }
1013
1014 ✗ int ff_set_common_color_spaces_from_list2(const AVFilterContext *ctx,
1015 AVFilterFormatsConfig **cfg_in,
1016 AVFilterFormatsConfig **cfg_out,
1017 const int *color_spaces)
1018 {
1019 ✗ return ff_set_common_color_spaces2(ctx, cfg_in, cfg_out, ff_make_format_list(color_spaces));
1020 }
1021
1022 ✗ int ff_set_common_all_color_spaces2(const AVFilterContext *ctx,
1023 AVFilterFormatsConfig **cfg_in,
1024 AVFilterFormatsConfig **cfg_out)
1025 {
1026 ✗ return ff_set_common_color_spaces2(ctx, cfg_in, cfg_out, ff_all_color_spaces());
1027 }
1028
1029 7162 int ff_set_common_color_ranges2(const AVFilterContext *ctx,
1030 AVFilterFormatsConfig **cfg_in,
1031 AVFilterFormatsConfig **cfg_out,
1032 AVFilterFormats *color_ranges)
1033 {
1034
12/20
✗ Branch 0 not taken.
✓ Branch 1 taken 7162 times.
✓ Branch 2 taken 2138 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 2138 times.
✗ Branch 5 not taken.
✗ Branch 7 not taken.
✓ Branch 8 taken 2138 times.
✓ Branch 9 taken 2138 times.
✓ Branch 10 taken 7162 times.
✓ Branch 11 taken 7162 times.
✗ Branch 12 not taken.
✓ Branch 13 taken 7162 times.
✗ Branch 14 not taken.
✗ Branch 16 not taken.
✓ Branch 17 taken 7162 times.
✓ Branch 18 taken 7162 times.
✓ Branch 19 taken 7162 times.
✗ Branch 20 not taken.
✓ Branch 21 taken 7162 times.
 16462 SET_COMMON_FORMATS2(ctx, cfg_in, cfg_out, color_ranges, AVMEDIA_TYPE_VIDEO,
1035 ff_formats_ref, ff_formats_unref);
1036 }
1037
1038 ✗ int ff_set_common_color_ranges_from_list2(const AVFilterContext *ctx,
1039 AVFilterFormatsConfig **cfg_in,
1040 AVFilterFormatsConfig **cfg_out,
1041 const int *color_ranges)
1042 {
1043 ✗ return ff_set_common_color_ranges2(ctx, cfg_in, cfg_out, ff_make_format_list(color_ranges));
1044 }
1045
1046 ✗ int ff_set_common_all_color_ranges2(const AVFilterContext *ctx,
1047 AVFilterFormatsConfig **cfg_in,
1048 AVFilterFormatsConfig **cfg_out)
1049 {
1050 ✗ return ff_set_common_color_ranges2(ctx, cfg_in, cfg_out, ff_all_color_ranges());
1051 }
1052
1053 350 int ff_set_common_alpha_modes2(const AVFilterContext *ctx,
1054 AVFilterFormatsConfig **cfg_in,
1055 AVFilterFormatsConfig **cfg_out,
1056 AVFilterFormats *alpha_modes)
1057 {
1058
12/20
✗ Branch 0 not taken.
✓ Branch 1 taken 350 times.
✓ Branch 2 taken 37 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 37 times.
✗ Branch 5 not taken.
✗ Branch 7 not taken.
✓ Branch 8 taken 37 times.
✓ Branch 9 taken 37 times.
✓ Branch 10 taken 350 times.
✓ Branch 11 taken 350 times.
✗ Branch 12 not taken.
✓ Branch 13 taken 350 times.
✗ Branch 14 not taken.
✗ Branch 16 not taken.
✓ Branch 17 taken 350 times.
✓ Branch 18 taken 350 times.
✓ Branch 19 taken 350 times.
✗ Branch 20 not taken.
✓ Branch 21 taken 350 times.
 737 SET_COMMON_FORMATS2(ctx, cfg_in, cfg_out, alpha_modes, AVMEDIA_TYPE_VIDEO,
1059 ff_formats_ref, ff_formats_unref);
1060 }
1061
1062 ✗ int ff_set_common_alpha_modes_from_list2(const AVFilterContext *ctx,
1063 AVFilterFormatsConfig **cfg_in,
1064 AVFilterFormatsConfig **cfg_out,
1065 const int *alpha_modes)
1066 {
1067 ✗ return ff_set_common_alpha_modes2(ctx, cfg_in, cfg_out, ff_make_format_list(alpha_modes));
1068 }
1069
1070 ✗ int ff_set_common_all_alpha_modes2(const AVFilterContext *ctx,
1071 AVFilterFormatsConfig **cfg_in,
1072 AVFilterFormatsConfig **cfg_out)
1073 {
1074 ✗ return ff_set_common_alpha_modes2(ctx, cfg_in, cfg_out, ff_all_alpha_modes());
1075 }
1076
1077 21022 int ff_set_common_formats2(const AVFilterContext *ctx,
1078 AVFilterFormatsConfig **cfg_in,
1079 AVFilterFormatsConfig **cfg_out,
1080 AVFilterFormats *formats)
1081 {
1082
11/16
✗ Branch 0 not taken.
✓ Branch 1 taken 21022 times.
✓ Branch 2 taken 13938 times.
✓ Branch 3 taken 4 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 13938 times.
✓ Branch 7 taken 13942 times.
✓ Branch 8 taken 21022 times.
✓ Branch 9 taken 21062 times.
✗ Branch 10 not taken.
✗ Branch 12 not taken.
✓ Branch 13 taken 21062 times.
✓ Branch 14 taken 21062 times.
✓ Branch 15 taken 21022 times.
✗ Branch 16 not taken.
✓ Branch 17 taken 21022 times.
 56026 SET_COMMON_FORMATS2(ctx, cfg_in, cfg_out, formats, AVMEDIA_TYPE_UNKNOWN,
1083 ff_formats_ref, ff_formats_unref);
1084 }
1085
1086 1857 int ff_set_common_formats_from_list2(const AVFilterContext *ctx,
1087 AVFilterFormatsConfig **cfg_in,
1088 AVFilterFormatsConfig **cfg_out,
1089 const int *fmts)
1090 {
1091 1857 return ff_set_common_formats2(ctx, cfg_in, cfg_out, ff_make_format_list(fmts));
1092 }
1093
1094
1095 44595 int ff_default_query_formats(AVFilterContext *ctx)
1096 {
1097 44595 const FFFilter *const f = fffilter(ctx->filter);
1098 AVFilterFormats *formats;
1099 enum AVMediaType type;
1100 int ret;
1101
1102
5/5
✓ Branch 0 taken 1412 times.
✓ Branch 1 taken 20 times.
✓ Branch 2 taken 31 times.
✓ Branch 3 taken 13 times.
✓ Branch 4 taken 43119 times.
 44595 switch (f->formats_state) {
1103 1412 case FF_FILTER_FORMATS_PIXFMT_LIST:
1104 1412 type = AVMEDIA_TYPE_VIDEO;
1105 1412 formats = ff_make_format_list(f->formats.pixels_list);
1106 1412 break;
1107 20 case FF_FILTER_FORMATS_SAMPLEFMTS_LIST:
1108 20 type = AVMEDIA_TYPE_AUDIO;
1109 20 formats = ff_make_format_list(f->formats.samples_list);
1110 20 break;
1111 31 case FF_FILTER_FORMATS_SINGLE_PIXFMT:
1112 31 type = AVMEDIA_TYPE_VIDEO;
1113 31 formats = ff_make_formats_list_singleton(f->formats.pix_fmt);
1114 31 break;
1115 13 case FF_FILTER_FORMATS_SINGLE_SAMPLEFMT:
1116 13 type = AVMEDIA_TYPE_AUDIO;
1117 13 formats = ff_make_formats_list_singleton(f->formats.sample_fmt);
1118 13 break;
1119 43119 default:
1120 av_assert2(!"Unreachable");
1121 /* Intended fallthrough */
1122 case FF_FILTER_FORMATS_PASSTHROUGH:
1123 case FF_FILTER_FORMATS_QUERY_FUNC:
1124 case FF_FILTER_FORMATS_QUERY_FUNC2:
1125 43119 type = AVMEDIA_TYPE_UNKNOWN;
1126
2/2
✓ Branch 0 taken 35949 times.
✓ Branch 1 taken 7170 times.
 50289 formats = ff_all_formats(ctx->nb_inputs ? ctx->inputs [0]->type :
1127
1/2
✓ Branch 0 taken 7170 times.
✗ Branch 1 not taken.
 7170 ctx->nb_outputs ? ctx->outputs[0]->type :
1128 AVMEDIA_TYPE_VIDEO);
1129 43119 break;
1130 }
1131
1132 44595 ret = ff_set_common_formats(ctx, formats);
1133
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 44595 times.
 44595 if (ret < 0)
1134 ✗ return ret;
1135
2/2
✓ Branch 0 taken 44562 times.
✓ Branch 1 taken 33 times.
 44595 if (type != AVMEDIA_TYPE_AUDIO) {
1136 44562 ret = ff_set_common_all_color_spaces(ctx);
1137
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 44562 times.
 44562 if (ret < 0)
1138 ✗ return ret;
1139 44562 ret = ff_set_common_all_color_ranges(ctx);
1140
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 44562 times.
 44562 if (ret < 0)
1141 ✗ return ret;
1142 44562 ret = ff_set_common_all_alpha_modes(ctx);
1143
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 44562 times.
 44562 if (ret < 0)
1144 ✗ return ret;
1145 }
1146
2/2
✓ Branch 0 taken 43152 times.
✓ Branch 1 taken 1443 times.
 44595 if (type != AVMEDIA_TYPE_VIDEO) {
1147 43152 ret = ff_set_common_all_channel_counts(ctx);
1148
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 43152 times.
 43152 if (ret < 0)
1149 ✗ return ret;
1150 43152 ret = ff_set_common_all_samplerates(ctx);
1151
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 43152 times.
 43152 if (ret < 0)
1152 ✗ return ret;
1153 }
1154
1155 44595 return 0;
1156 }
1157
1158 211860 static int check_list(void *log, const char *name, const AVFilterFormats *fmts)
1159 {
1160 unsigned i, j;
1161
1162
2/2
✓ Branch 0 taken 117620 times.
✓ Branch 1 taken 94240 times.
 211860 if (!fmts)
1163 117620 return 0;
1164
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 94240 times.
 94240 if (!fmts->nb_formats) {
1165 ✗ av_log(log, AV_LOG_ERROR, "Empty %s list\n", name);
1166 ✗ return AVERROR(EINVAL);
1167 }
1168
2/2
✓ Branch 0 taken 3682884 times.
✓ Branch 1 taken 94240 times.
 3777124 for (i = 0; i < fmts->nb_formats; i++) {
1169
2/2
✓ Branch 0 taken 378591265 times.
✓ Branch 1 taken 3682884 times.
 382274149 for (j = i + 1; j < fmts->nb_formats; j++) {
1170
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 378591265 times.
 378591265 if (fmts->formats[i] == fmts->formats[j]) {
1171 ✗ av_log(log, AV_LOG_ERROR, "Duplicated %s\n", name);
1172 ✗ return AVERROR(EINVAL);
1173 }
1174 }
1175 }
1176 94240 return 0;
1177 }
1178
1179 50070 int ff_formats_check_pixel_formats(void *log, const AVFilterFormats *fmts)
1180 {
1181 50070 return check_list(log, "pixel format", fmts);
1182 }
1183
1184 9397 int ff_formats_check_sample_formats(void *log, const AVFilterFormats *fmts)
1185 {
1186 9397 return check_list(log, "sample format", fmts);
1187 }
1188
1189 9397 int ff_formats_check_sample_rates(void *log, const AVFilterFormats *fmts)
1190 {
1191
4/4
✓ Branch 0 taken 4535 times.
✓ Branch 1 taken 4862 times.
✓ Branch 2 taken 2352 times.
✓ Branch 3 taken 2183 times.
 9397 if (!fmts || !fmts->nb_formats)
1192 7214 return 0;
1193 2183 return check_list(log, "sample rate", fmts);
1194 }
1195
1196 50070 int ff_formats_check_color_spaces(void *log, const AVFilterFormats *fmts)
1197 {
1198
4/4
✓ Branch 0 taken 127482 times.
✓ Branch 1 taken 31955 times.
✓ Branch 2 taken 109367 times.
✓ Branch 3 taken 18115 times.
 159437 for (int i = 0; fmts && i < fmts->nb_formats; i++) {
1199
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 109367 times.
 109367 if (fmts->formats[i] == AVCOL_SPC_RESERVED) {
1200 ✗ av_log(log, AV_LOG_ERROR, "Invalid color space\n");
1201 ✗ return AVERROR(EINVAL);
1202 }
1203 }
1204 50070 return check_list(log, "color space", fmts);
1205 }
1206
1207 50070 int ff_formats_check_color_ranges(void *log, const AVFilterFormats *fmts)
1208 {
1209 50070 return check_list(log, "color range", fmts);
1210 }
1211
1212 50070 int ff_formats_check_alpha_modes(void *log, const AVFilterFormats *fmts)
1213 {
1214 50070 return check_list(log, "alpha mode", fmts);
1215 }
1216
1217 3420 static int layouts_compatible(const AVChannelLayout *a, const AVChannelLayout *b)
1218 {
1219 3420 return !av_channel_layout_compare(a, b) ||
1220
3/12
✓ Branch 0 taken 3420 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 3420 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✓ Branch 7 taken 3420 times.
✗ Branch 8 not taken.
✗ Branch 9 not taken.
✗ Branch 10 not taken.
✗ Branch 11 not taken.
 6840 (KNOWN(a) && !KNOWN(b) && a->nb_channels == b->nb_channels) ||
1221
2/10
✗ Branch 0 not taken.
✓ Branch 1 taken 3420 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 3420 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
✗ Branch 9 not taken.
 3420 (KNOWN(b) && !KNOWN(a) && b->nb_channels == a->nb_channels);
1222 }
1223
1224 9397 int ff_formats_check_channel_layouts(void *log, const AVFilterChannelLayouts *fmts)
1225 {
1226 unsigned i, j;
1227
1228
2/2
✓ Branch 0 taken 4561 times.
✓ Branch 1 taken 4836 times.
 9397 if (!fmts)
1229 4561 return 0;
1230
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4836 times.
 4836 if (fmts->all_layouts < fmts->all_counts) {
1231 ✗ av_log(log, AV_LOG_ERROR, "Inconsistent generic list\n");
1232 ✗ return AVERROR(EINVAL);
1233 }
1234
3/4
✓ Branch 0 taken 1755 times.
✓ Branch 1 taken 3081 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 1755 times.
 4836 if (!fmts->all_layouts && !fmts->nb_channel_layouts) {
1235 ✗ av_log(log, AV_LOG_ERROR, "Empty channel layout list\n");
1236 ✗ return AVERROR(EINVAL);
1237 }
1238
2/2
✓ Branch 0 taken 2403 times.
✓ Branch 1 taken 4836 times.
 7239 for (i = 0; i < fmts->nb_channel_layouts; i++) {
1239
2/2
✓ Branch 0 taken 3420 times.
✓ Branch 1 taken 2403 times.
 5823 for (j = i + 1; j < fmts->nb_channel_layouts; j++) {
1240
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 3420 times.
 3420 if (layouts_compatible(&fmts->channel_layouts[i], &fmts->channel_layouts[j])) {
1241 ✗ av_log(log, AV_LOG_ERROR, "Duplicated or redundant channel layout\n");
1242 ✗ return AVERROR(EINVAL);
1243 }
1244 }
1245 }
1246 4836 return 0;
1247 }
1248