GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavfilter/formats.c Lines: 235 275 85.5 %
Date: 2021-04-15 16:04:23 Branches: 282 400 70.5 %

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/eval.h"
26
#include "libavutil/pixdesc.h"
27
#include "avfilter.h"
28
#include "internal.h"
29
#include "formats.h"
30
31
#define KNOWN(l) (!FF_LAYOUT2COUNT(l)) /* for readability */
32
33
/**
34
 * Add all refs from a to ret and destroy a.
35
 */
36
#define MERGE_REF(ret, a, fmts, type, fail_statement)                      \
37
do {                                                                       \
38
    type ***tmp;                                                           \
39
    int i;                                                                 \
40
                                                                           \
41
    if (!(tmp = av_realloc_array(ret->refs, ret->refcount + a->refcount,   \
42
                                 sizeof(*tmp))))                           \
43
        { fail_statement }                                                 \
44
    ret->refs = tmp;                                                       \
45
                                                                           \
46
    for (i = 0; i < a->refcount; i ++) {                                   \
47
        ret->refs[ret->refcount] = a->refs[i];                             \
48
        *ret->refs[ret->refcount++] = ret;                                 \
49
    }                                                                      \
50
                                                                           \
51
    av_freep(&a->refs);                                                    \
52
    av_freep(&a->fmts);                                                    \
53
    av_freep(&a);                                                          \
54
} while (0)
55
56
/**
57
 * Add all formats common to a and b to a, add b's refs to a and destroy b.
58
 * If check is set, nothing is modified and it is only checked whether
59
 * the formats are compatible.
60
 * If empty_allowed is set and one of a,b->nb is zero, the lists are
61
 * merged; otherwise, it is treated as error.
62
 */
63
#define MERGE_FORMATS(a, b, fmts, nb, type, check, empty_allowed)          \
64
do {                                                                       \
65
    int i, j, k = 0, skip = 0;                                             \
66
                                                                           \
67
    if (empty_allowed) {                                                   \
68
        if (!a->nb || !b->nb) {                                            \
69
            if (check)                                                     \
70
                return 1;                                                  \
71
            if (!a->nb)                                                    \
72
                FFSWAP(type *, a, b);                                      \
73
            skip = 1;                                                      \
74
        }                                                                  \
75
    }                                                                      \
76
    if (!skip) {                                                           \
77
        for (i = 0; i < a->nb; i++)                                        \
78
            for (j = 0; j < b->nb; j++)                                    \
79
                if (a->fmts[i] == b->fmts[j]) {                            \
80
                    if (check)                                             \
81
                        return 1;                                          \
82
                    a->fmts[k++] = a->fmts[i];                             \
83
                    break;                                                 \
84
                }                                                          \
85
        /* Check that there was at least one common format.                \
86
         * Notice that both a and b are unchanged if not. */               \
87
        if (!k)                                                            \
88
            return 0;                                                      \
89
        av_assert2(!check);                                                \
90
        a->nb = k;                                                         \
91
    }                                                                      \
92
                                                                           \
93
    MERGE_REF(a, b, fmts, type, return AVERROR(ENOMEM););                  \
94
} while (0)
95
96
46667
static int merge_formats_internal(AVFilterFormats *a, AVFilterFormats *b,
97
                                  enum AVMediaType type, int check)
98
{
99
    int i, j;
100
46667
    int alpha1=0, alpha2=0;
101
46667
    int chroma1=0, chroma2=0;
102
103
46667
    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
46667
    if (type == AVMEDIA_TYPE_VIDEO)
114
1239866
        for (i = 0; i < a->nb_formats; i++)
115
22149314
            for (j = 0; j < b->nb_formats; j++) {
116
20946668
                const AVPixFmtDescriptor *adesc = av_pix_fmt_desc_get(a->formats[i]);
117
20946668
                const AVPixFmtDescriptor *bdesc = av_pix_fmt_desc_get(b->formats[j]);
118
20946668
                alpha2 |= adesc->flags & bdesc->flags & AV_PIX_FMT_FLAG_ALPHA;
119

20946668
                chroma2|= adesc->nb_components > 1 && bdesc->nb_components > 1;
120
20946668
                if (a->formats[i] == b->formats[j]) {
121
114941
                    alpha1 |= adesc->flags & AV_PIX_FMT_FLAG_ALPHA;
122
114941
                    chroma1|= adesc->nb_components > 1;
123
                }
124
            }
125
126
    // If chroma or alpha can be lost through merging then do not merge
127

46667
    if (alpha2 > alpha1 || chroma2 > chroma1)
128
282
        return 0;
129
130




6302795
    MERGE_FORMATS(a, b, formats, nb_formats, AVFilterFormats, check, 0);
131
132
23678
    return 1;
133
}
134
135
22989
int ff_can_merge_formats(const AVFilterFormats *a, const AVFilterFormats *b,
136
                         enum AVMediaType type)
137
{
138
22989
    return merge_formats_internal((AVFilterFormats *)a,
139
                                  (AVFilterFormats *)b, type, 1);
140
}
141
142
23678
int ff_merge_formats(AVFilterFormats *a, AVFilterFormats *b,
143
                     enum AVMediaType type)
144
{
145
    av_assert2(a->refcount && b->refcount);
146
23678
    return merge_formats_internal(a, b, type, 0);
147
}
148
149
9447
static int merge_samplerates_internal(AVFilterFormats *a,
150
                                      AVFilterFormats *b, int check)
151
{
152
9447
    if (a == b) return 1;
153
154






18308
    MERGE_FORMATS(a, b, formats, nb_formats, AVFilterFormats, check, 1);
155
4921
    return 1;
156
}
157
158
4526
int ff_can_merge_samplerates(const AVFilterFormats *a, const AVFilterFormats *b)
159
{
160
4526
    return merge_samplerates_internal((AVFilterFormats *)a, (AVFilterFormats *)b, 1);
161
}
162
163
4921
int ff_merge_samplerates(AVFilterFormats *a, AVFilterFormats *b)
164
{
165
    av_assert2(a->refcount && b->refcount);
166
4921
    return merge_samplerates_internal(a, b, 0);
167
}
168
169
4922
int ff_merge_channel_layouts(AVFilterChannelLayouts *a,
170
                             AVFilterChannelLayouts *b)
171
{
172
    uint64_t *channel_layouts;
173
4922
    unsigned a_all = a->all_layouts + a->all_counts;
174
4922
    unsigned b_all = b->all_layouts + b->all_counts;
175
4922
    int ret_max, ret_nb = 0, i, j, round;
176
177
    av_assert2(a->refcount && b->refcount);
178
179
4922
    if (a == b) return 1;
180
181
    /* Put the most generic set in a, to avoid doing everything twice */
182
4922
    if (a_all < b_all) {
183
2211
        FFSWAP(AVFilterChannelLayouts *, a, b);
184
2211
        FFSWAP(unsigned, a_all, b_all);
185
    }
186
4922
    if (a_all) {
187

4882
        if (a_all == 1 && !b_all) {
188
            /* keep only known layouts in b; works also for b_all = 1 */
189
8
            for (i = j = 0; i < b->nb_channel_layouts; i++)
190

4
                if (KNOWN(b->channel_layouts[i]))
191
4
                    b->channel_layouts[j++] = b->channel_layouts[i];
192
            /* Not optimal: the unknown layouts of b may become known after
193
               another merge. */
194
4
            if (!j)
195
                return 0;
196
4
            b->nb_channel_layouts = j;
197
        }
198

13182
        MERGE_REF(b, a, channel_layouts, AVFilterChannelLayouts, return AVERROR(ENOMEM););
199
4882
        return 1;
200
    }
201
202
40
    ret_max = a->nb_channel_layouts + b->nb_channel_layouts;
203
40
    if (!(channel_layouts = av_malloc_array(ret_max, sizeof(*channel_layouts))))
204
        return AVERROR(ENOMEM);
205
206
    /* a[known] intersect b[known] */
207
80
    for (i = 0; i < a->nb_channel_layouts; i++) {
208

40
        if (!KNOWN(a->channel_layouts[i]))
209
            continue;
210
56
        for (j = 0; j < b->nb_channel_layouts; j++) {
211
55
            if (a->channel_layouts[i] == b->channel_layouts[j]) {
212
39
                channel_layouts[ret_nb++] = a->channel_layouts[i];
213
39
                a->channel_layouts[i] = b->channel_layouts[j] = 0;
214
39
                break;
215
            }
216
        }
217
    }
218
    /* 1st round: a[known] intersect b[generic]
219
       2nd round: a[generic] intersect b[known] */
220
120
    for (round = 0; round < 2; round++) {
221
189
        for (i = 0; i < a->nb_channel_layouts; i++) {
222
109
            uint64_t fmt = a->channel_layouts[i], bfmt;
223

109
            if (!fmt || !KNOWN(fmt))
224
78
                continue;
225
31
            bfmt = FF_COUNT2LAYOUT(av_get_channel_layout_nb_channels(fmt));
226
62
            for (j = 0; j < b->nb_channel_layouts; j++)
227
31
                if (b->channel_layouts[j] == bfmt)
228
                    channel_layouts[ret_nb++] = a->channel_layouts[i];
229
        }
230
        /* 1st round: swap to prepare 2nd round; 2nd round: put it back */
231
80
        FFSWAP(AVFilterChannelLayouts *, a, b);
232
    }
233
    /* a[generic] intersect b[generic] */
234
80
    for (i = 0; i < a->nb_channel_layouts; i++) {
235

40
        if (KNOWN(a->channel_layouts[i]))
236
40
            continue;
237
        for (j = 0; j < b->nb_channel_layouts; j++)
238
            if (a->channel_layouts[i] == b->channel_layouts[j])
239
                channel_layouts[ret_nb++] = a->channel_layouts[i];
240
    }
241
242
40
    if (!ret_nb) {
243
1
        av_free(channel_layouts);
244
1
        return 0;
245
    }
246
247
39
    if (a->refcount > b->refcount)
248
11
        FFSWAP(AVFilterChannelLayouts *, a, b);
249
250

97
    MERGE_REF(b, a, channel_layouts, AVFilterChannelLayouts,
251
              { av_free(channel_layouts); return AVERROR(ENOMEM); });
252
39
    av_freep(&b->channel_layouts);
253
39
    b->channel_layouts    = channel_layouts;
254
39
    b->nb_channel_layouts = ret_nb;
255
39
    return 1;
256
}
257
258
153
int ff_fmt_is_in(int fmt, const int *fmts)
259
{
260
    const int *p;
261
262
2055
    for (p = fmts; *p != -1; p++) {
263
1989
        if (fmt == *p)
264
87
            return 1;
265
    }
266
66
    return 0;
267
}
268
269
#define MAKE_FORMAT_LIST(type, field, count_field)                      \
270
    type *formats;                                                      \
271
    int count = 0;                                                      \
272
    if (fmts)                                                           \
273
        for (count = 0; fmts[count] != -1; count++)                     \
274
            ;                                                           \
275
    formats = av_mallocz(sizeof(*formats));                             \
276
    if (!formats)                                                       \
277
        return NULL;                                                    \
278
    formats->count_field = count;                                       \
279
    if (count) {                                                        \
280
        formats->field = av_malloc_array(count, sizeof(*formats->field));      \
281
        if (!formats->field) {                                          \
282
            av_freep(&formats);                                         \
283
            return NULL;                                                \
284
        }                                                               \
285
    }
286
287
7123
AVFilterFormats *ff_make_format_list(const int *fmts)
288
{
289


27251
    MAKE_FORMAT_LIST(AVFilterFormats, formats, nb_formats);
290
27251
    while (count--)
291
20128
        formats->formats[count] = fmts[count];
292
293
7123
    return formats;
294
}
295
296
23
AVFilterChannelLayouts *ff_make_format64_list(const int64_t *fmts)
297
{
298


46
    MAKE_FORMAT_LIST(AVFilterChannelLayouts,
299
                     channel_layouts, nb_channel_layouts);
300
23
    if (count)
301
23
        memcpy(formats->channel_layouts, fmts,
302
               sizeof(*formats->channel_layouts) * count);
303
304
23
    return formats;
305
}
306
307
#if LIBAVFILTER_VERSION_MAJOR < 8
308
AVFilterChannelLayouts *avfilter_make_format64_list(const int64_t *fmts)
309
{
310
    return ff_make_format64_list(fmts);
311
}
312
#endif
313
314
#define ADD_FORMAT(f, fmt, unref_fn, type, list, nb)        \
315
do {                                                        \
316
    type *fmts;                                             \
317
                                                            \
318
    if (!(*f) && !(*f = av_mallocz(sizeof(**f)))) {         \
319
        return AVERROR(ENOMEM);                             \
320
    }                                                       \
321
                                                            \
322
    fmts = av_realloc_array((*f)->list, (*f)->nb + 1,       \
323
                            sizeof(*(*f)->list));           \
324
    if (!fmts) {                                            \
325
        unref_fn(f);                                        \
326
        return AVERROR(ENOMEM);                             \
327
    }                                                       \
328
                                                            \
329
    (*f)->list = fmts;                                      \
330
    (*f)->list[(*f)->nb++] = fmt;                           \
331
} while (0)
332
333
7000303
int ff_add_format(AVFilterFormats **avff, int64_t fmt)
334
{
335

7000303
    ADD_FORMAT(avff, fmt, ff_formats_unref, int, formats, nb_formats);
336
7000303
    return 0;
337
}
338
339
2615
int ff_add_channel_layout(AVFilterChannelLayouts **l, uint64_t channel_layout)
340
{
341
    av_assert1(!(*l && (*l)->all_layouts));
342

2615
    ADD_FORMAT(l, channel_layout, ff_channel_layouts_unref, uint64_t, channel_layouts, nb_channel_layouts);
343
2615
    return 0;
344
}
345
346
36740
AVFilterFormats *ff_all_formats(enum AVMediaType type)
347
{
348
36740
    AVFilterFormats *ret = NULL;
349
350
36740
    if (type == AVMEDIA_TYPE_VIDEO) {
351
28224
        const AVPixFmtDescriptor *desc = NULL;
352
5616576
        while ((desc = av_pix_fmt_desc_next(desc))) {
353
5588352
            if (ff_add_format(&ret, av_pix_fmt_desc_get_id(desc)) < 0)
354
                return NULL;
355
        }
356
8516
    } else if (type == AVMEDIA_TYPE_AUDIO) {
357
8516
        enum AVSampleFormat fmt = 0;
358
110708
        while (av_get_sample_fmt_name(fmt)) {
359
102192
            if (ff_add_format(&ret, fmt) < 0)
360
                return NULL;
361
102192
            fmt++;
362
        }
363
    }
364
365
36740
    return ret;
366
}
367
368
507
int ff_formats_pixdesc_filter(AVFilterFormats **rfmts, unsigned want, unsigned rej)
369
{
370
    unsigned nb_formats, fmt, flags;
371
507
    AVFilterFormats *formats = NULL;
372
373
    while (1) {
374
1014
        nb_formats = 0;
375
201786
        for (fmt = 0;; fmt++) {
376
201786
            const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(fmt);
377
201786
            if (!desc)
378
1014
                break;
379
200772
            flags = desc->flags;
380
200772
            if (!(desc->flags & AV_PIX_FMT_FLAG_HWACCEL) &&
381
184548
                !(desc->flags & AV_PIX_FMT_FLAG_PLANAR) &&
382

80106
                (desc->log2_chroma_w || desc->log2_chroma_h))
383
6084
                flags |= FF_PIX_FMT_FLAG_SW_FLAT_SUB;
384
200772
            if ((flags & (want | rej)) != want)
385
14798
                continue;
386
185974
            if (formats)
387
92987
                formats->formats[nb_formats] = fmt;
388
185974
            nb_formats++;
389
        }
390
1014
        if (formats) {
391
507
            av_assert0(formats->nb_formats == nb_formats);
392
507
            *rfmts = formats;
393
507
            return 0;
394
        }
395
507
        formats = av_mallocz(sizeof(*formats));
396
507
        if (!formats)
397
            return AVERROR(ENOMEM);
398
507
        formats->nb_formats = nb_formats;
399
507
        if (nb_formats) {
400
507
            formats->formats = av_malloc_array(nb_formats, sizeof(*formats->formats));
401
507
            if (!formats->formats) {
402
                av_freep(&formats);
403
                return AVERROR(ENOMEM);
404
            }
405
        }
406
    }
407
}
408
409
4
AVFilterFormats *ff_planar_sample_fmts(void)
410
{
411
4
    AVFilterFormats *ret = NULL;
412
    int fmt;
413
414
52
    for (fmt = 0; av_get_bytes_per_sample(fmt)>0; fmt++)
415
48
        if (av_sample_fmt_is_planar(fmt))
416
24
            if (ff_add_format(&ret, fmt) < 0)
417
                return NULL;
418
419
4
    return ret;
420
}
421
422
9311
AVFilterFormats *ff_all_samplerates(void)
423
{
424
9311
    AVFilterFormats *ret = av_mallocz(sizeof(*ret));
425
9311
    return ret;
426
}
427
428
5042
AVFilterChannelLayouts *ff_all_channel_layouts(void)
429
{
430
5042
    AVFilterChannelLayouts *ret = av_mallocz(sizeof(*ret));
431
5042
    if (!ret)
432
        return NULL;
433
5042
    ret->all_layouts = 1;
434
5042
    return ret;
435
}
436
437
6043
AVFilterChannelLayouts *ff_all_channel_counts(void)
438
{
439
6043
    AVFilterChannelLayouts *ret = av_mallocz(sizeof(*ret));
440
6043
    if (!ret)
441
        return NULL;
442
6043
    ret->all_layouts = ret->all_counts = 1;
443
6043
    return ret;
444
}
445
446
#define FORMATS_REF(f, ref, unref_fn)                                           \
447
    void *tmp;                                                                  \
448
                                                                                \
449
    if (!f)                                                                     \
450
        return AVERROR(ENOMEM);                                                 \
451
                                                                                \
452
    tmp = av_realloc_array(f->refs, sizeof(*f->refs), f->refcount + 1);         \
453
    if (!tmp) {                                                                 \
454
        unref_fn(&f);                                                           \
455
        return AVERROR(ENOMEM);                                                 \
456
    }                                                                           \
457
    f->refs = tmp;                                                              \
458
    f->refs[f->refcount++] = ref;                                               \
459
    *ref = f;                                                                   \
460
    return 0
461
462
9842
int ff_channel_layouts_ref(AVFilterChannelLayouts *f, AVFilterChannelLayouts **ref)
463
{
464

9842
    FORMATS_REF(f, ref, ff_channel_layouts_unref);
465
}
466
467
57374
int ff_formats_ref(AVFilterFormats *f, AVFilterFormats **ref)
468
{
469

57374
    FORMATS_REF(f, ref, ff_formats_unref);
470
}
471
472
#define FIND_REF_INDEX(ref, idx)            \
473
do {                                        \
474
    int i;                                  \
475
    for (i = 0; i < (*ref)->refcount; i ++) \
476
        if((*ref)->refs[i] == ref) {        \
477
            idx = i;                        \
478
            break;                          \
479
        }                                   \
480
} while (0)
481
482
#define FORMATS_UNREF(ref, list)                                   \
483
do {                                                               \
484
    int idx = -1;                                                  \
485
                                                                   \
486
    if (!*ref)                                                     \
487
        return;                                                    \
488
                                                                   \
489
    FIND_REF_INDEX(ref, idx);                                      \
490
                                                                   \
491
    if (idx >= 0) {                                                \
492
        memmove((*ref)->refs + idx, (*ref)->refs + idx + 1,        \
493
            sizeof(*(*ref)->refs) * ((*ref)->refcount - idx - 1)); \
494
        --(*ref)->refcount;                                        \
495
    }                                                              \
496
    if (!(*ref)->refcount) {                                       \
497
        av_free((*ref)->list);                                     \
498
        av_free((*ref)->refs);                                     \
499
        av_free(*ref);                                             \
500
    }                                                              \
501
    *ref = NULL;                                                   \
502
} while (0)
503
504
221665
void ff_formats_unref(AVFilterFormats **ref)
505
{
506


231270
    FORMATS_UNREF(ref, formats);
507
}
508
509
101747
void ff_channel_layouts_unref(AVFilterChannelLayouts **ref)
510
{
511


108040
    FORMATS_UNREF(ref, channel_layouts);
512
}
513
514
#define FORMATS_CHANGEREF(oldref, newref)       \
515
do {                                            \
516
    int idx = -1;                               \
517
                                                \
518
    FIND_REF_INDEX(oldref, idx);                \
519
                                                \
520
    if (idx >= 0) {                             \
521
        (*oldref)->refs[idx] = newref;          \
522
        *newref = *oldref;                      \
523
        *oldref = NULL;                         \
524
    }                                           \
525
} while (0)
526
527
395
void ff_channel_layouts_changeref(AVFilterChannelLayouts **oldref,
528
                                  AVFilterChannelLayouts **newref)
529
{
530

734
    FORMATS_CHANGEREF(oldref, newref);
531
395
}
532
533
1088
void ff_formats_changeref(AVFilterFormats **oldref, AVFilterFormats **newref)
534
{
535

1439
    FORMATS_CHANGEREF(oldref, newref);
536
1088
}
537
538
#define SET_COMMON_FORMATS(ctx, fmts, ref_fn, unref_fn)             \
539
    int count = 0, i;                                               \
540
                                                                    \
541
    if (!fmts)                                                      \
542
        return AVERROR(ENOMEM);                                     \
543
                                                                    \
544
    for (i = 0; i < ctx->nb_inputs; i++) {                          \
545
        if (ctx->inputs[i] && !ctx->inputs[i]->outcfg.fmts) {       \
546
            int ret = ref_fn(fmts, &ctx->inputs[i]->outcfg.fmts);   \
547
            if (ret < 0) {                                          \
548
                return ret;                                         \
549
            }                                                       \
550
            count++;                                                \
551
        }                                                           \
552
    }                                                               \
553
    for (i = 0; i < ctx->nb_outputs; i++) {                         \
554
        if (ctx->outputs[i] && !ctx->outputs[i]->incfg.fmts) {      \
555
            int ret = ref_fn(fmts, &ctx->outputs[i]->incfg.fmts);   \
556
            if (ret < 0) {                                          \
557
                return ret;                                         \
558
            }                                                       \
559
            count++;                                                \
560
        }                                                           \
561
    }                                                               \
562
                                                                    \
563
    if (!count) {                                                   \
564
        unref_fn(&fmts);                                            \
565
    }                                                               \
566
                                                                    \
567
    return 0;
568
569
9850
int ff_set_common_channel_layouts(AVFilterContext *ctx,
570
                                  AVFilterChannelLayouts *channel_layouts)
571
{
572





24970
    SET_COMMON_FORMATS(ctx, channel_layouts,
573
                       ff_channel_layouts_ref, ff_channel_layouts_unref);
574
}
575
576
8728
int ff_set_common_samplerates(AVFilterContext *ctx,
577
                              AVFilterFormats *samplerates)
578
{
579





22751
    SET_COMMON_FORMATS(ctx, samplerates,
580
                       ff_formats_ref, ff_formats_unref);
581
}
582
583
/**
584
 * A helper for query_formats() which sets all links to the same list of
585
 * formats. If there are no links hooked to this filter, the list of formats is
586
 * freed.
587
 */
588
48912
int ff_set_common_formats(AVFilterContext *ctx, AVFilterFormats *formats)
589
{
590





124378
    SET_COMMON_FORMATS(ctx, formats,
591
                       ff_formats_ref, ff_formats_unref);
592
}
593
594
8803
int ff_default_query_formats(AVFilterContext *ctx)
595
{
596
    int ret;
597
8803
    enum AVMediaType type = ctx->nb_inputs  ? ctx->inputs [0]->type :
598
                            ctx->nb_outputs ? ctx->outputs[0]->type :
599
                            AVMEDIA_TYPE_VIDEO;
600
601
8803
    ret = ff_set_common_formats(ctx, ff_all_formats(type));
602
8803
    if (ret < 0)
603
        return ret;
604
8803
    if (type == AVMEDIA_TYPE_AUDIO) {
605
1026
        ret = ff_set_common_channel_layouts(ctx, ff_all_channel_counts());
606
1026
        if (ret < 0)
607
            return ret;
608
1026
        ret = ff_set_common_samplerates(ctx, ff_all_samplerates());
609
1026
        if (ret < 0)
610
            return ret;
611
    }
612
613
8803
    return 0;
614
}
615
616
/* internal functions for parsing audio format arguments */
617
618
6792
int ff_parse_pixel_format(enum AVPixelFormat *ret, const char *arg, void *log_ctx)
619
{
620
    char *tail;
621
6792
    int pix_fmt = av_get_pix_fmt(arg);
622
6792
    if (pix_fmt == AV_PIX_FMT_NONE) {
623
        pix_fmt = strtol(arg, &tail, 0);
624
        if (*tail || !av_pix_fmt_desc_get(pix_fmt)) {
625
            av_log(log_ctx, AV_LOG_ERROR, "Invalid pixel format '%s'\n", arg);
626
            return AVERROR(EINVAL);
627
        }
628
    }
629
6792
    *ret = pix_fmt;
630
6792
    return 0;
631
}
632
633
14
int ff_parse_sample_rate(int *ret, const char *arg, void *log_ctx)
634
{
635
    char *tail;
636
14
    double srate = av_strtod(arg, &tail);
637


14
    if (*tail || srate < 1 || (int)srate != srate || srate > INT_MAX) {
638
        av_log(log_ctx, AV_LOG_ERROR, "Invalid sample rate '%s'\n", arg);
639
        return AVERROR(EINVAL);
640
    }
641
14
    *ret = srate;
642
14
    return 0;
643
}
644
645
36
int ff_parse_channel_layout(int64_t *ret, int *nret, const char *arg,
646
                            void *log_ctx)
647
{
648
    int64_t chlayout;
649
    int nb_channels;
650
651
36
    if (av_get_extended_channel_layout(arg, &chlayout, &nb_channels) < 0) {
652
6
        av_log(log_ctx, AV_LOG_ERROR, "Invalid channel layout '%s'\n", arg);
653
6
        return AVERROR(EINVAL);
654
    }
655

30
    if (!chlayout && !nret) {
656
        av_log(log_ctx, AV_LOG_ERROR, "Unknown channel layout '%s' is not supported.\n", arg);
657
        return AVERROR(EINVAL);
658
    }
659
30
    *ret = chlayout;
660
30
    if (nret)
661
30
        *nret = nb_channels;
662
663
30
    return 0;
664
}
665
666
41168
static int check_list(void *log, const char *name, const AVFilterFormats *fmts)
667
{
668
    unsigned i, j;
669
670
41168
    if (!fmts)
671
1132
        return 0;
672
40036
    if (!fmts->nb_formats) {
673
        av_log(log, AV_LOG_ERROR, "Empty %s list\n", name);
674
        return AVERROR(EINVAL);
675
    }
676
2601105
    for (i = 0; i < fmts->nb_formats; i++) {
677
223722676
        for (j = i + 1; j < fmts->nb_formats; j++) {
678
221161607
            if (fmts->formats[i] == fmts->formats[j]) {
679
                av_log(log, AV_LOG_ERROR, "Duplicated %s\n", name);
680
                return AVERROR(EINVAL);
681
            }
682
        }
683
    }
684
40036
    return 0;
685
}
686
687
31435
int ff_formats_check_pixel_formats(void *log, const AVFilterFormats *fmts)
688
{
689
31435
    return check_list(log, "pixel format", fmts);
690
}
691
692
7790
int ff_formats_check_sample_formats(void *log, const AVFilterFormats *fmts)
693
{
694
7790
    return check_list(log, "sample format", fmts);
695
}
696
697
7790
int ff_formats_check_sample_rates(void *log, const AVFilterFormats *fmts)
698
{
699

7790
    if (!fmts || !fmts->nb_formats)
700
5847
        return 0;
701
1943
    return check_list(log, "sample rate", fmts);
702
}
703
704
2460
static int layouts_compatible(uint64_t a, uint64_t b)
705
{
706
2460
    return a == b ||
707



4920
           (KNOWN(a) && !KNOWN(b) && av_get_channel_layout_nb_channels(a) == FF_LAYOUT2COUNT(b)) ||
708



2460
           (KNOWN(b) && !KNOWN(a) && av_get_channel_layout_nb_channels(b) == FF_LAYOUT2COUNT(a));
709
}
710
711
7790
int ff_formats_check_channel_layouts(void *log, const AVFilterChannelLayouts *fmts)
712
{
713
    unsigned i, j;
714
715
7790
    if (!fmts)
716
2
        return 0;
717
7788
    if (fmts->all_layouts < fmts->all_counts) {
718
        av_log(log, AV_LOG_ERROR, "Inconsistent generic list\n");
719
        return AVERROR(EINVAL);
720
    }
721

7788
    if (!fmts->all_layouts && !fmts->nb_channel_layouts) {
722
        av_log(log, AV_LOG_ERROR, "Empty channel layout list\n");
723
        return AVERROR(EINVAL);
724
    }
725
9548
    for (i = 0; i < fmts->nb_channel_layouts; i++) {
726
4220
        for (j = i + 1; j < fmts->nb_channel_layouts; j++) {
727
2460
            if (layouts_compatible(fmts->channel_layouts[i], fmts->channel_layouts[j])) {
728
                av_log(log, AV_LOG_ERROR, "Duplicated or redundant channel layout\n");
729
                return AVERROR(EINVAL);
730
            }
731
        }
732
    }
733
7788
    return 0;
734
}