avcodec/cbs_av1_syntax_template: Remove unused variable
[ffmpeg.git] / libavfilter / formats.c
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 "libavutil/parseutils.h"
28 #include "avfilter.h"
29 #include "internal.h"
30 #include "formats.h"
31
32 #define KNOWN(l) (!FF_LAYOUT2COUNT(l)) /* for readability */
33
34 /**
35  * Add all refs from a to ret and destroy a.
36  */
37 #define MERGE_REF(ret, a, fmts, type, fail)                                \
38 do {                                                                       \
39     type ***tmp;                                                           \
40     int i;                                                                 \
41                                                                            \
42     if (!(tmp = av_realloc_array(ret->refs, ret->refcount + a->refcount,   \
43                                  sizeof(*tmp))))                           \
44         goto fail;                                                         \
45     ret->refs = tmp;                                                       \
46                                                                            \
47     for (i = 0; i < a->refcount; i ++) {                                   \
48         ret->refs[ret->refcount] = a->refs[i];                             \
49         *ret->refs[ret->refcount++] = ret;                                 \
50     }                                                                      \
51                                                                            \
52     av_freep(&a->refs);                                                    \
53     av_freep(&a->fmts);                                                    \
54     av_freep(&a);                                                          \
55 } while (0)
56
57 /**
58  * Add all formats common for a and b to ret, copy the refs and destroy
59  * a and b.
60  */
61 #define MERGE_FORMATS(ret, a, b, fmts, nb, type, fail)                          \
62 do {                                                                            \
63     int i, j, k = 0, count = FFMIN(a->nb, b->nb);                               \
64                                                                                 \
65     if (!(ret = av_mallocz(sizeof(*ret))))                                      \
66         goto fail;                                                              \
67                                                                                 \
68     if (count) {                                                                \
69         if (!(ret->fmts = av_malloc_array(count, sizeof(*ret->fmts))))          \
70             goto fail;                                                          \
71         for (i = 0; i < a->nb; i++)                                             \
72             for (j = 0; j < b->nb; j++)                                         \
73                 if (a->fmts[i] == b->fmts[j]) {                                 \
74                     if(k >= FFMIN(a->nb, b->nb)){                               \
75                         av_log(NULL, AV_LOG_ERROR, "Duplicate formats in %s detected\n", __FUNCTION__); \
76                         av_free(ret->fmts);                                     \
77                         av_free(ret);                                           \
78                         return NULL;                                            \
79                     }                                                           \
80                     ret->fmts[k++] = a->fmts[i];                                \
81                 }                                                               \
82     }                                                                           \
83     ret->nb = k;                                                                \
84     /* check that there was at least one common format */                       \
85     if (!ret->nb)                                                               \
86         goto fail;                                                              \
87                                                                                 \
88     MERGE_REF(ret, a, fmts, type, fail);                                        \
89     MERGE_REF(ret, b, fmts, type, fail);                                        \
90 } while (0)
91
92 AVFilterFormats *ff_merge_formats(AVFilterFormats *a, AVFilterFormats *b,
93                                   enum AVMediaType type)
94 {
95     AVFilterFormats *ret = NULL;
96     int i, j;
97     int alpha1=0, alpha2=0;
98     int chroma1=0, chroma2=0;
99
100     if (a == b)
101         return a;
102
103     /* Do not lose chroma or alpha in merging.
104        It happens if both lists have formats with chroma (resp. alpha), but
105        the only formats in common do not have it (e.g. YUV+gray vs.
106        RGB+gray): in that case, the merging would select the gray format,
107        possibly causing a lossy conversion elsewhere in the graph.
108        To avoid that, pretend that there are no common formats to force the
109        insertion of a conversion filter. */
110     if (type == AVMEDIA_TYPE_VIDEO)
111         for (i = 0; i < a->nb_formats; i++)
112             for (j = 0; j < b->nb_formats; j++) {
113                 const AVPixFmtDescriptor *adesc = av_pix_fmt_desc_get(a->formats[i]);
114                 const AVPixFmtDescriptor *bdesc = av_pix_fmt_desc_get(b->formats[j]);
115                 alpha2 |= adesc->flags & bdesc->flags & AV_PIX_FMT_FLAG_ALPHA;
116                 chroma2|= adesc->nb_components > 1 && bdesc->nb_components > 1;
117                 if (a->formats[i] == b->formats[j]) {
118                     alpha1 |= adesc->flags & AV_PIX_FMT_FLAG_ALPHA;
119                     chroma1|= adesc->nb_components > 1;
120                 }
121             }
122
123     // If chroma or alpha can be lost through merging then do not merge
124     if (alpha2 > alpha1 || chroma2 > chroma1)
125         return NULL;
126
127     MERGE_FORMATS(ret, a, b, formats, nb_formats, AVFilterFormats, fail);
128
129     return ret;
130 fail:
131     if (ret) {
132         av_freep(&ret->refs);
133         av_freep(&ret->formats);
134     }
135     av_freep(&ret);
136     return NULL;
137 }
138
139 AVFilterFormats *ff_merge_samplerates(AVFilterFormats *a,
140                                       AVFilterFormats *b)
141 {
142     AVFilterFormats *ret = NULL;
143
144     if (a == b) return a;
145
146     if (a->nb_formats && b->nb_formats) {
147         MERGE_FORMATS(ret, a, b, formats, nb_formats, AVFilterFormats, fail);
148     } else if (a->nb_formats) {
149         MERGE_REF(a, b, formats, AVFilterFormats, fail);
150         ret = a;
151     } else {
152         MERGE_REF(b, a, formats, AVFilterFormats, fail);
153         ret = b;
154     }
155
156     return ret;
157 fail:
158     if (ret) {
159         av_freep(&ret->refs);
160         av_freep(&ret->formats);
161     }
162     av_freep(&ret);
163     return NULL;
164 }
165
166 AVFilterChannelLayouts *ff_merge_channel_layouts(AVFilterChannelLayouts *a,
167                                                  AVFilterChannelLayouts *b)
168 {
169     AVFilterChannelLayouts *ret = NULL;
170     unsigned a_all = a->all_layouts + a->all_counts;
171     unsigned b_all = b->all_layouts + b->all_counts;
172     int ret_max, ret_nb = 0, i, j, round;
173
174     if (a == b) return a;
175
176     /* Put the most generic set in a, to avoid doing everything twice */
177     if (a_all < b_all) {
178         FFSWAP(AVFilterChannelLayouts *, a, b);
179         FFSWAP(unsigned, a_all, b_all);
180     }
181     if (a_all) {
182         if (a_all == 1 && !b_all) {
183             /* keep only known layouts in b; works also for b_all = 1 */
184             for (i = j = 0; i < b->nb_channel_layouts; i++)
185                 if (KNOWN(b->channel_layouts[i]))
186                     b->channel_layouts[j++] = b->channel_layouts[i];
187             /* Not optimal: the unknown layouts of b may become known after
188                another merge. */
189             if (!j)
190                 return NULL;
191             b->nb_channel_layouts = j;
192         }
193         MERGE_REF(b, a, channel_layouts, AVFilterChannelLayouts, fail);
194         return b;
195     }
196
197     ret_max = a->nb_channel_layouts + b->nb_channel_layouts;
198     if (!(ret = av_mallocz(sizeof(*ret))) ||
199         !(ret->channel_layouts = av_malloc_array(ret_max,
200                                                  sizeof(*ret->channel_layouts))))
201         goto fail;
202
203     /* a[known] intersect b[known] */
204     for (i = 0; i < a->nb_channel_layouts; i++) {
205         if (!KNOWN(a->channel_layouts[i]))
206             continue;
207         for (j = 0; j < b->nb_channel_layouts; j++) {
208             if (a->channel_layouts[i] == b->channel_layouts[j]) {
209                 ret->channel_layouts[ret_nb++] = a->channel_layouts[i];
210                 a->channel_layouts[i] = b->channel_layouts[j] = 0;
211             }
212         }
213     }
214     /* 1st round: a[known] intersect b[generic]
215        2nd round: a[generic] intersect b[known] */
216     for (round = 0; round < 2; round++) {
217         for (i = 0; i < a->nb_channel_layouts; i++) {
218             uint64_t fmt = a->channel_layouts[i], bfmt;
219             if (!fmt || !KNOWN(fmt))
220                 continue;
221             bfmt = FF_COUNT2LAYOUT(av_get_channel_layout_nb_channels(fmt));
222             for (j = 0; j < b->nb_channel_layouts; j++)
223                 if (b->channel_layouts[j] == bfmt)
224                     ret->channel_layouts[ret_nb++] = a->channel_layouts[i];
225         }
226         /* 1st round: swap to prepare 2nd round; 2nd round: put it back */
227         FFSWAP(AVFilterChannelLayouts *, a, b);
228     }
229     /* a[generic] intersect b[generic] */
230     for (i = 0; i < a->nb_channel_layouts; i++) {
231         if (KNOWN(a->channel_layouts[i]))
232             continue;
233         for (j = 0; j < b->nb_channel_layouts; j++)
234             if (a->channel_layouts[i] == b->channel_layouts[j])
235                 ret->channel_layouts[ret_nb++] = a->channel_layouts[i];
236     }
237
238     ret->nb_channel_layouts = ret_nb;
239     if (!ret->nb_channel_layouts)
240         goto fail;
241     MERGE_REF(ret, a, channel_layouts, AVFilterChannelLayouts, fail);
242     MERGE_REF(ret, b, channel_layouts, AVFilterChannelLayouts, fail);
243     return ret;
244
245 fail:
246     if (ret) {
247         av_freep(&ret->refs);
248         av_freep(&ret->channel_layouts);
249     }
250     av_freep(&ret);
251     return NULL;
252 }
253
254 int ff_fmt_is_in(int fmt, const int *fmts)
255 {
256     const int *p;
257
258     for (p = fmts; *p != -1; p++) {
259         if (fmt == *p)
260             return 1;
261     }
262     return 0;
263 }
264
265 #define MAKE_FORMAT_LIST(type, field, count_field)                      \
266     type *formats;                                                      \
267     int count = 0;                                                      \
268     if (fmts)                                                           \
269         for (count = 0; fmts[count] != -1; count++)                     \
270             ;                                                           \
271     formats = av_mallocz(sizeof(*formats));                             \
272     if (!formats)                                                       \
273         return NULL;                                                    \
274     formats->count_field = count;                                       \
275     if (count) {                                                        \
276         formats->field = av_malloc_array(count, sizeof(*formats->field));      \
277         if (!formats->field) {                                          \
278             av_freep(&formats);                                         \
279             return NULL;                                                \
280         }                                                               \
281     }
282
283 AVFilterFormats *ff_make_format_list(const int *fmts)
284 {
285     MAKE_FORMAT_LIST(AVFilterFormats, formats, nb_formats);
286     while (count--)
287         formats->formats[count] = fmts[count];
288
289     return formats;
290 }
291
292 AVFilterChannelLayouts *ff_make_formatu64_list(const uint64_t *fmts)
293 {
294     MAKE_FORMAT_LIST(AVFilterChannelLayouts,
295                      channel_layouts, nb_channel_layouts);
296     if (count)
297         memcpy(formats->channel_layouts, fmts,
298                sizeof(*formats->channel_layouts) * count);
299
300     return formats;
301 }
302
303 AVFilterChannelLayouts *avfilter_make_format64_list(const int64_t *fmts)
304 {
305     MAKE_FORMAT_LIST(AVFilterChannelLayouts,
306                      channel_layouts, nb_channel_layouts);
307     if (count)
308         memcpy(formats->channel_layouts, fmts,
309                sizeof(*formats->channel_layouts) * count);
310
311     return formats;
312 }
313
314 #define ADD_FORMAT(f, fmt, unref_fn, type, list, nb)        \
315 do {                                                        \
316     type *fmts;                                             \
317     void *oldf = *f;                                        \
318                                                             \
319     if (!(*f) && !(*f = av_mallocz(sizeof(**f)))) {         \
320         return AVERROR(ENOMEM);                             \
321     }                                                       \
322                                                             \
323     fmts = av_realloc_array((*f)->list, (*f)->nb + 1,       \
324                             sizeof(*(*f)->list));           \
325     if (!fmts) {                                            \
326         unref_fn(f);                                        \
327         if (!oldf)                                          \
328             av_freep(f);                                    \
329         return AVERROR(ENOMEM);                             \
330     }                                                       \
331                                                             \
332     (*f)->list = fmts;                                      \
333     (*f)->list[(*f)->nb++] = fmt;                           \
334 } while (0)
335
336 int ff_add_format(AVFilterFormats **avff, int64_t fmt)
337 {
338     ADD_FORMAT(avff, fmt, ff_formats_unref, int, formats, nb_formats);
339     return 0;
340 }
341
342 int ff_add_channel_layout(AVFilterChannelLayouts **l, uint64_t channel_layout)
343 {
344     av_assert1(!(*l && (*l)->all_layouts));
345     ADD_FORMAT(l, channel_layout, ff_channel_layouts_unref, uint64_t, channel_layouts, nb_channel_layouts);
346     return 0;
347 }
348
349 AVFilterFormats *ff_all_formats(enum AVMediaType type)
350 {
351     AVFilterFormats *ret = NULL;
352
353     if (type == AVMEDIA_TYPE_VIDEO) {
354         const AVPixFmtDescriptor *desc = NULL;
355         while ((desc = av_pix_fmt_desc_next(desc))) {
356             if (ff_add_format(&ret, av_pix_fmt_desc_get_id(desc)) < 0)
357                 return NULL;
358         }
359     } else if (type == AVMEDIA_TYPE_AUDIO) {
360         enum AVSampleFormat fmt = 0;
361         while (av_get_sample_fmt_name(fmt)) {
362             if (ff_add_format(&ret, fmt) < 0)
363                 return NULL;
364             fmt++;
365         }
366     }
367
368     return ret;
369 }
370
371 const int64_t avfilter_all_channel_layouts[] = {
372 #include "all_channel_layouts.inc"
373     -1
374 };
375
376 // AVFilterFormats *avfilter_make_all_channel_layouts(void)
377 // {
378 //     return avfilter_make_format64_list(avfilter_all_channel_layouts);
379 // }
380
381 AVFilterFormats *ff_planar_sample_fmts(void)
382 {
383     AVFilterFormats *ret = NULL;
384     int fmt;
385
386     for (fmt = 0; av_get_bytes_per_sample(fmt)>0; fmt++)
387         if (av_sample_fmt_is_planar(fmt))
388             if (ff_add_format(&ret, fmt) < 0)
389                 return NULL;
390
391     return ret;
392 }
393
394 AVFilterFormats *ff_all_samplerates(void)
395 {
396     AVFilterFormats *ret = av_mallocz(sizeof(*ret));
397     return ret;
398 }
399
400 AVFilterChannelLayouts *ff_all_channel_layouts(void)
401 {
402     AVFilterChannelLayouts *ret = av_mallocz(sizeof(*ret));
403     if (!ret)
404         return NULL;
405     ret->all_layouts = 1;
406     return ret;
407 }
408
409 AVFilterChannelLayouts *ff_all_channel_counts(void)
410 {
411     AVFilterChannelLayouts *ret = av_mallocz(sizeof(*ret));
412     if (!ret)
413         return NULL;
414     ret->all_layouts = ret->all_counts = 1;
415     return ret;
416 }
417
418 #define FORMATS_REF(f, ref, unref_fn)                                           \
419     void *tmp;                                                                  \
420                                                                                 \
421     if (!f || !ref)                                                             \
422         return AVERROR(ENOMEM);                                                 \
423                                                                                 \
424     tmp = av_realloc_array(f->refs, sizeof(*f->refs), f->refcount + 1);         \
425     if (!tmp) {                                                                 \
426         unref_fn(&f);                                                           \
427         return AVERROR(ENOMEM);                                                 \
428     }                                                                           \
429     f->refs = tmp;                                                              \
430     f->refs[f->refcount++] = ref;                                               \
431     *ref = f;                                                                   \
432     return 0
433
434 int ff_channel_layouts_ref(AVFilterChannelLayouts *f, AVFilterChannelLayouts **ref)
435 {
436     FORMATS_REF(f, ref, ff_channel_layouts_unref);
437 }
438
439 int ff_formats_ref(AVFilterFormats *f, AVFilterFormats **ref)
440 {
441     FORMATS_REF(f, ref, ff_formats_unref);
442 }
443
444 #define FIND_REF_INDEX(ref, idx)            \
445 do {                                        \
446     int i;                                  \
447     for (i = 0; i < (*ref)->refcount; i ++) \
448         if((*ref)->refs[i] == ref) {        \
449             idx = i;                        \
450             break;                          \
451         }                                   \
452 } while (0)
453
454 #define FORMATS_UNREF(ref, list)                                   \
455 do {                                                               \
456     int idx = -1;                                                  \
457                                                                    \
458     if (!ref || !*ref || !(*ref)->refs)                            \
459         return;                                                    \
460                                                                    \
461     FIND_REF_INDEX(ref, idx);                                      \
462                                                                    \
463     if (idx >= 0)                                                  \
464         memmove((*ref)->refs + idx, (*ref)->refs + idx + 1,        \
465             sizeof(*(*ref)->refs) * ((*ref)->refcount - idx - 1)); \
466                                                                    \
467     if(!--(*ref)->refcount) {                                      \
468         av_free((*ref)->list);                                     \
469         av_free((*ref)->refs);                                     \
470         av_free(*ref);                                             \
471     }                                                              \
472     *ref = NULL;                                                   \
473 } while (0)
474
475 void ff_formats_unref(AVFilterFormats **ref)
476 {
477     FORMATS_UNREF(ref, formats);
478 }
479
480 void ff_channel_layouts_unref(AVFilterChannelLayouts **ref)
481 {
482     FORMATS_UNREF(ref, channel_layouts);
483 }
484
485 #define FORMATS_CHANGEREF(oldref, newref)       \
486 do {                                            \
487     int idx = -1;                               \
488                                                 \
489     FIND_REF_INDEX(oldref, idx);                \
490                                                 \
491     if (idx >= 0) {                             \
492         (*oldref)->refs[idx] = newref;          \
493         *newref = *oldref;                      \
494         *oldref = NULL;                         \
495     }                                           \
496 } while (0)
497
498 void ff_channel_layouts_changeref(AVFilterChannelLayouts **oldref,
499                                   AVFilterChannelLayouts **newref)
500 {
501     FORMATS_CHANGEREF(oldref, newref);
502 }
503
504 void ff_formats_changeref(AVFilterFormats **oldref, AVFilterFormats **newref)
505 {
506     FORMATS_CHANGEREF(oldref, newref);
507 }
508
509 #define SET_COMMON_FORMATS(ctx, fmts, in_fmts, out_fmts, ref_fn, unref_fn, list) \
510     int count = 0, i;                                               \
511                                                                     \
512     if (!fmts)                                                      \
513         return AVERROR(ENOMEM);                                     \
514                                                                     \
515     for (i = 0; i < ctx->nb_inputs; i++) {                          \
516         if (ctx->inputs[i] && !ctx->inputs[i]->out_fmts) {          \
517             int ret = ref_fn(fmts, &ctx->inputs[i]->out_fmts);      \
518             if (ret < 0) {                                          \
519                 unref_fn(&fmts);                                    \
520                 if (fmts)                                           \
521                     av_freep(&fmts->list);                          \
522                 av_freep(&fmts);                                    \
523                 return ret;                                         \
524             }                                                       \
525             count++;                                                \
526         }                                                           \
527     }                                                               \
528     for (i = 0; i < ctx->nb_outputs; i++) {                         \
529         if (ctx->outputs[i] && !ctx->outputs[i]->in_fmts) {         \
530             int ret = ref_fn(fmts, &ctx->outputs[i]->in_fmts);      \
531             if (ret < 0) {                                          \
532                 unref_fn(&fmts);                                    \
533                 if (fmts)                                           \
534                     av_freep(&fmts->list);                          \
535                 av_freep(&fmts);                                    \
536                 return ret;                                         \
537             }                                                       \
538             count++;                                                \
539         }                                                           \
540     }                                                               \
541                                                                     \
542     if (!count) {                                                   \
543         av_freep(&fmts->list);                                      \
544         av_freep(&fmts->refs);                                      \
545         av_freep(&fmts);                                            \
546     }                                                               \
547                                                                     \
548     return 0;
549
550 int ff_set_common_channel_layouts(AVFilterContext *ctx,
551                                   AVFilterChannelLayouts *layouts)
552 {
553     SET_COMMON_FORMATS(ctx, layouts, in_channel_layouts, out_channel_layouts,
554                        ff_channel_layouts_ref, ff_channel_layouts_unref, channel_layouts);
555 }
556
557 int ff_set_common_samplerates(AVFilterContext *ctx,
558                               AVFilterFormats *samplerates)
559 {
560     SET_COMMON_FORMATS(ctx, samplerates, in_samplerates, out_samplerates,
561                        ff_formats_ref, ff_formats_unref, formats);
562 }
563
564 /**
565  * A helper for query_formats() which sets all links to the same list of
566  * formats. If there are no links hooked to this filter, the list of formats is
567  * freed.
568  */
569 int ff_set_common_formats(AVFilterContext *ctx, AVFilterFormats *formats)
570 {
571     SET_COMMON_FORMATS(ctx, formats, in_formats, out_formats,
572                        ff_formats_ref, ff_formats_unref, formats);
573 }
574
575 static int default_query_formats_common(AVFilterContext *ctx,
576                                         AVFilterChannelLayouts *(layouts)(void))
577 {
578     int ret;
579     enum AVMediaType type = ctx->inputs  && ctx->inputs [0] ? ctx->inputs [0]->type :
580                             ctx->outputs && ctx->outputs[0] ? ctx->outputs[0]->type :
581                             AVMEDIA_TYPE_VIDEO;
582
583     ret = ff_set_common_formats(ctx, ff_all_formats(type));
584     if (ret < 0)
585         return ret;
586     if (type == AVMEDIA_TYPE_AUDIO) {
587         ret = ff_set_common_channel_layouts(ctx, layouts());
588         if (ret < 0)
589             return ret;
590         ret = ff_set_common_samplerates(ctx, ff_all_samplerates());
591         if (ret < 0)
592             return ret;
593     }
594
595     return 0;
596 }
597
598 int ff_default_query_formats(AVFilterContext *ctx)
599 {
600     return default_query_formats_common(ctx, ff_all_channel_counts);
601 }
602
603 int ff_query_formats_all_layouts(AVFilterContext *ctx)
604 {
605     return default_query_formats_common(ctx, ff_all_channel_layouts);
606 }
607
608 /* internal functions for parsing audio format arguments */
609
610 int ff_parse_pixel_format(enum AVPixelFormat *ret, const char *arg, void *log_ctx)
611 {
612     char *tail;
613     int pix_fmt = av_get_pix_fmt(arg);
614     if (pix_fmt == AV_PIX_FMT_NONE) {
615         pix_fmt = strtol(arg, &tail, 0);
616         if (*tail || !av_pix_fmt_desc_get(pix_fmt)) {
617             av_log(log_ctx, AV_LOG_ERROR, "Invalid pixel format '%s'\n", arg);
618             return AVERROR(EINVAL);
619         }
620     }
621     *ret = pix_fmt;
622     return 0;
623 }
624
625 int ff_parse_sample_format(int *ret, const char *arg, void *log_ctx)
626 {
627     char *tail;
628     int sfmt = av_get_sample_fmt(arg);
629     if (sfmt == AV_SAMPLE_FMT_NONE) {
630         sfmt = strtol(arg, &tail, 0);
631         if (*tail || av_get_bytes_per_sample(sfmt)<=0) {
632             av_log(log_ctx, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg);
633             return AVERROR(EINVAL);
634         }
635     }
636     *ret = sfmt;
637     return 0;
638 }
639
640 int ff_parse_time_base(AVRational *ret, const char *arg, void *log_ctx)
641 {
642     AVRational r;
643     if(av_parse_ratio(&r, arg, INT_MAX, 0, log_ctx) < 0 ||r.num<=0  ||r.den<=0) {
644         av_log(log_ctx, AV_LOG_ERROR, "Invalid time base '%s'\n", arg);
645         return AVERROR(EINVAL);
646     }
647     *ret = r;
648     return 0;
649 }
650
651 int ff_parse_sample_rate(int *ret, const char *arg, void *log_ctx)
652 {
653     char *tail;
654     double srate = av_strtod(arg, &tail);
655     if (*tail || srate < 1 || (int)srate != srate || srate > INT_MAX) {
656         av_log(log_ctx, AV_LOG_ERROR, "Invalid sample rate '%s'\n", arg);
657         return AVERROR(EINVAL);
658     }
659     *ret = srate;
660     return 0;
661 }
662
663 int ff_parse_channel_layout(int64_t *ret, int *nret, const char *arg,
664                             void *log_ctx)
665 {
666     int64_t chlayout;
667     int nb_channels;
668
669     if (av_get_extended_channel_layout(arg, &chlayout, &nb_channels) < 0) {
670         av_log(log_ctx, AV_LOG_ERROR, "Invalid channel layout '%s'\n", arg);
671         return AVERROR(EINVAL);
672     }
673     if (!chlayout && !nret) {
674         av_log(log_ctx, AV_LOG_ERROR, "Unknown channel layout '%s' is not supported.\n", arg);
675         return AVERROR(EINVAL);
676     }
677     *ret = chlayout;
678     if (nret)
679         *nret = nb_channels;
680
681     return 0;
682 }