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

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

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




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






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

4857
        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

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

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

111
            if (!fmt || !KNOWN(fmt))
224
80
                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
82
        FFSWAP(AVFilterChannelLayouts *, a, b);
232
    }
233
    /* a[generic] intersect b[generic] */
234
82
    for (i = 0; i < a->nb_channel_layouts; i++) {
235

41
        if (KNOWN(a->channel_layouts[i]))
236
41
            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
41
    if (!ret_nb) {
243
1
        av_free(channel_layouts);
244
1
        return 0;
245
    }
246
247
40
    if (a->refcount > b->refcount)
248
11
        FFSWAP(AVFilterChannelLayouts *, a, b);
249
250

99
    MERGE_REF(b, a, channel_layouts, AVFilterChannelLayouts,
251
              { av_free(channel_layouts); return AVERROR(ENOMEM); });
252
40
    av_freep(&b->channel_layouts);
253
40
    b->channel_layouts    = channel_layouts;
254
40
    b->nb_channel_layouts = ret_nb;
255
40
    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
7107
AVFilterFormats *ff_make_format_list(const int *fmts)
288
{
289


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

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

2593
    ADD_FORMAT(l, channel_layout, ff_channel_layouts_unref, uint64_t, channel_layouts, nb_channel_layouts);
343
2593
    return 0;
344
}
345
346
36614
AVFilterFormats *ff_all_formats(enum AVMediaType type)
347
{
348
36614
    AVFilterFormats *ret = NULL;
349
350
36614
    if (type == AVMEDIA_TYPE_VIDEO) {
351
28161
        const AVPixFmtDescriptor *desc = NULL;
352
5604039
        while ((desc = av_pix_fmt_desc_next(desc))) {
353
5575878
            if (ff_add_format(&ret, av_pix_fmt_desc_get_id(desc)) < 0)
354
                return NULL;
355
        }
356
8453
    } else if (type == AVMEDIA_TYPE_AUDIO) {
357
8453
        enum AVSampleFormat fmt = 0;
358
109889
        while (av_get_sample_fmt_name(fmt)) {
359
101436
            if (ff_add_format(&ret, fmt) < 0)
360
                return NULL;
361
101436
            fmt++;
362
        }
363
    }
364
365
36614
    return ret;
366
}
367
368
165
int ff_formats_pixdesc_filter(AVFilterFormats **rfmts, unsigned want, unsigned rej)
369
{
370
    unsigned nb_formats, fmt, flags;
371
165
    AVFilterFormats *formats = NULL;
372
373
    while (1) {
374
330
        nb_formats = 0;
375
65670
        for (fmt = 0;; fmt++) {
376
65670
            const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(fmt);
377
65670
            if (!desc)
378
330
                break;
379
65340
            flags = desc->flags;
380
65340
            if (!(desc->flags & AV_PIX_FMT_FLAG_HWACCEL) &&
381
60060
                !(desc->flags & AV_PIX_FMT_FLAG_PLANAR) &&
382

26070
                (desc->log2_chroma_w || desc->log2_chroma_h))
383
1980
                flags |= FF_PIX_FMT_FLAG_SW_FLAT_SUB;
384
65340
            if ((flags & (want | rej)) != want)
385
3332
                continue;
386
62008
            if (formats)
387
31004
                formats->formats[nb_formats] = fmt;
388
62008
            nb_formats++;
389
        }
390
330
        if (formats) {
391
165
            av_assert0(formats->nb_formats == nb_formats);
392
165
            *rfmts = formats;
393
165
            return 0;
394
        }
395
165
        formats = av_mallocz(sizeof(*formats));
396
165
        if (!formats)
397
            return AVERROR(ENOMEM);
398
165
        formats->nb_formats = nb_formats;
399
165
        if (nb_formats) {
400
165
            formats->formats = av_malloc_array(nb_formats, sizeof(*formats->formats));
401
165
            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
9241
AVFilterFormats *ff_all_samplerates(void)
423
{
424
9241
    AVFilterFormats *ret = av_mallocz(sizeof(*ret));
425
9241
    return ret;
426
}
427
428
5005
AVFilterChannelLayouts *ff_all_channel_layouts(void)
429
{
430
5005
    AVFilterChannelLayouts *ret = av_mallocz(sizeof(*ret));
431
5005
    if (!ret)
432
        return NULL;
433
5005
    ret->all_layouts = 1;
434
5005
    return ret;
435
}
436
437
6003
AVFilterChannelLayouts *ff_all_channel_counts(void)
438
{
439
6003
    AVFilterChannelLayouts *ret = av_mallocz(sizeof(*ret));
440
6003
    if (!ret)
441
        return NULL;
442
6003
    ret->all_layouts = ret->all_counts = 1;
443
6003
    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
9794
int ff_channel_layouts_ref(AVFilterChannelLayouts *f, AVFilterChannelLayouts **ref)
463
{
464

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

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


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


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





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





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





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

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

7728
    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
9481
    for (i = 0; i < fmts->nb_channel_layouts; i++) {
726
4213
        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
7728
    return 0;
734
}