GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavfilter/formats.c Lines: 235 275 85.5 %
Date: 2021-01-20 23:14:43 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
46615
static int merge_formats_internal(AVFilterFormats *a, AVFilterFormats *b,
97
                                  enum AVMediaType type, int check)
98
{
99
    int i, j;
100
46615
    int alpha1=0, alpha2=0;
101
46615
    int chroma1=0, chroma2=0;
102
103
46615
    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
46615
    if (type == AVMEDIA_TYPE_VIDEO)
114
1239334
        for (i = 0; i < a->nb_formats; i++)
115
22104542
            for (j = 0; j < b->nb_formats; j++) {
116
20902400
                const AVPixFmtDescriptor *adesc = av_pix_fmt_desc_get(a->formats[i]);
117
20902400
                const AVPixFmtDescriptor *bdesc = av_pix_fmt_desc_get(b->formats[j]);
118
20902400
                alpha2 |= adesc->flags & bdesc->flags & AV_PIX_FMT_FLAG_ALPHA;
119

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

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




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






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

4870
        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

13181
        MERGE_REF(b, a, channel_layouts, AVFilterChannelLayouts, return AVERROR(ENOMEM););
199
4870
        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
7121
AVFilterFormats *ff_make_format_list(const int *fmts)
288
{
289


26919
    MAKE_FORMAT_LIST(AVFilterFormats, formats, nb_formats);
290
26919
    while (count--)
291
19798
        formats->formats[count] = fmts[count];
292
293
7121
    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
6994285
int ff_add_format(AVFilterFormats **avff, int64_t fmt)
334
{
335

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

2598
    ADD_FORMAT(l, channel_layout, ff_channel_layouts_unref, uint64_t, channel_layouts, nb_channel_layouts);
343
2598
    return 0;
344
}
345
346
36672
AVFilterFormats *ff_all_formats(enum AVMediaType type)
347
{
348
36672
    AVFilterFormats *ret = NULL;
349
350
36672
    if (type == AVMEDIA_TYPE_VIDEO) {
351
28198
        const AVPixFmtDescriptor *desc = NULL;
352
5611402
        while ((desc = av_pix_fmt_desc_next(desc))) {
353
5583204
            if (ff_add_format(&ret, av_pix_fmt_desc_get_id(desc)) < 0)
354
                return NULL;
355
        }
356
8474
    } else if (type == AVMEDIA_TYPE_AUDIO) {
357
8474
        enum AVSampleFormat fmt = 0;
358
110162
        while (av_get_sample_fmt_name(fmt)) {
359
101688
            if (ff_add_format(&ret, fmt) < 0)
360
                return NULL;
361
101688
            fmt++;
362
        }
363
    }
364
365
36672
    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
9265
AVFilterFormats *ff_all_samplerates(void)
423
{
424
9265
    AVFilterFormats *ret = av_mallocz(sizeof(*ret));
425
9265
    return ret;
426
}
427
428
5017
AVFilterChannelLayouts *ff_all_channel_layouts(void)
429
{
430
5017
    AVFilterChannelLayouts *ret = av_mallocz(sizeof(*ret));
431
5017
    if (!ret)
432
        return NULL;
433
5017
    ret->all_layouts = 1;
434
5017
    return ret;
435
}
436
437
6018
AVFilterChannelLayouts *ff_all_channel_counts(void)
438
{
439
6018
    AVFilterChannelLayouts *ret = av_mallocz(sizeof(*ret));
440
6018
    if (!ret)
441
        return NULL;
442
6018
    ret->all_layouts = ret->all_counts = 1;
443
6018
    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
9818
int ff_channel_layouts_ref(AVFilterChannelLayouts *f, AVFilterChannelLayouts **ref)
463
{
464

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

57298
    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
221392
void ff_formats_unref(AVFilterFormats **ref)
505
{
506


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


107860
    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
9822
int ff_set_common_channel_layouts(AVFilterContext *ctx,
570
                                  AVFilterChannelLayouts *channel_layouts)
571
{
572





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





22691
    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
48854
int ff_set_common_formats(AVFilterContext *ctx, AVFilterFormats *formats)
589
{
590





124240
    SET_COMMON_FORMATS(ctx, formats,
591
                       ff_formats_ref, ff_formats_unref);
592
}
593
594
8801
int ff_default_query_formats(AVFilterContext *ctx)
595
{
596
    int ret;
597
8801
    enum AVMediaType type = ctx->nb_inputs  ? ctx->inputs [0]->type :
598
                            ctx->nb_outputs ? ctx->outputs[0]->type :
599
                            AVMEDIA_TYPE_VIDEO;
600
601
8801
    ret = ff_set_common_formats(ctx, ff_all_formats(type));
602
8801
    if (ret < 0)
603
        return ret;
604
8801
    if (type == AVMEDIA_TYPE_AUDIO) {
605
1035
        ret = ff_set_common_channel_layouts(ctx, ff_all_channel_counts());
606
1035
        if (ret < 0)
607
            return ret;
608
1035
        ret = ff_set_common_samplerates(ctx, ff_all_samplerates());
609
1035
        if (ret < 0)
610
            return ret;
611
    }
612
613
8801
    return 0;
614
}
615
616
/* internal functions for parsing audio format arguments */
617
618
6737
int ff_parse_pixel_format(enum AVPixelFormat *ret, const char *arg, void *log_ctx)
619
{
620
    char *tail;
621
6737
    int pix_fmt = av_get_pix_fmt(arg);
622
6737
    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
6737
    *ret = pix_fmt;
630
6737
    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
41104
static int check_list(void *log, const char *name, const AVFilterFormats *fmts)
667
{
668
    unsigned i, j;
669
670
41104
    if (!fmts)
671
1128
        return 0;
672
39976
    if (!fmts->nb_formats) {
673
        av_log(log, AV_LOG_ERROR, "Empty %s list\n", name);
674
        return AVERROR(EINVAL);
675
    }
676
2598295
    for (i = 0; i < fmts->nb_formats; i++) {
677
223545612
        for (j = i + 1; j < fmts->nb_formats; j++) {
678
220987293
            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
39976
    return 0;
685
}
686
687
31417
int ff_formats_check_pixel_formats(void *log, const AVFilterFormats *fmts)
688
{
689
31417
    return check_list(log, "pixel format", fmts);
690
}
691
692
7748
int ff_formats_check_sample_formats(void *log, const AVFilterFormats *fmts)
693
{
694
7748
    return check_list(log, "sample format", fmts);
695
}
696
697
7748
int ff_formats_check_sample_rates(void *log, const AVFilterFormats *fmts)
698
{
699

7748
    if (!fmts || !fmts->nb_formats)
700
5809
        return 0;
701
1939
    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
7748
int ff_formats_check_channel_layouts(void *log, const AVFilterChannelLayouts *fmts)
712
{
713
    unsigned i, j;
714
715
7748
    if (!fmts)
716
2
        return 0;
717
7746
    if (fmts->all_layouts < fmts->all_counts) {
718
        av_log(log, AV_LOG_ERROR, "Inconsistent generic list\n");
719
        return AVERROR(EINVAL);
720
    }
721

7746
    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
9502
    for (i = 0; i < fmts->nb_channel_layouts; i++) {
726
4216
        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
7746
    return 0;
734
}