avconv: decouple configuring filtergraphs and setting output parameters
[ffmpeg.git] / avconv_opt.c
1 /*
2  * avconv option parsing
3  *
4  * This file is part of Libav.
5  *
6  * Libav is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * Libav is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with Libav; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20
21 #include <stdint.h>
22
23 #include "avconv.h"
24 #include "cmdutils.h"
25
26 #include "libavformat/avformat.h"
27
28 #include "libavcodec/avcodec.h"
29
30 #include "libavfilter/avfilter.h"
31
32 #include "libavutil/avassert.h"
33 #include "libavutil/avstring.h"
34 #include "libavutil/avutil.h"
35 #include "libavutil/channel_layout.h"
36 #include "libavutil/intreadwrite.h"
37 #include "libavutil/fifo.h"
38 #include "libavutil/mathematics.h"
39 #include "libavutil/opt.h"
40 #include "libavutil/parseutils.h"
41 #include "libavutil/pixdesc.h"
42 #include "libavutil/pixfmt.h"
43
44 #define DEFAULT_PASS_LOGFILENAME_PREFIX "av2pass"
45
46 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
47 {\
48     int i, ret;\
49     for (i = 0; i < o->nb_ ## name; i++) {\
50         char *spec = o->name[i].specifier;\
51         if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
52             outvar = o->name[i].u.type;\
53         else if (ret < 0)\
54             exit_program(1);\
55     }\
56 }
57
58 const HWAccel hwaccels[] = {
59 #if HAVE_VDPAU_X11
60     { "vdpau", vdpau_init, HWACCEL_VDPAU, AV_PIX_FMT_VDPAU },
61 #endif
62 #if HAVE_DXVA2_LIB
63     { "dxva2", dxva2_init, HWACCEL_DXVA2, AV_PIX_FMT_DXVA2_VLD },
64 #endif
65 #if CONFIG_VDA
66     { "vda",   vda_init,   HWACCEL_VDA,   AV_PIX_FMT_VDA },
67 #endif
68 #if CONFIG_LIBMFX
69     { "qsv",   qsv_init,   HWACCEL_QSV,   AV_PIX_FMT_QSV },
70 #endif
71 #if CONFIG_VAAPI
72     { "vaapi", vaapi_decode_init, HWACCEL_VAAPI, AV_PIX_FMT_VAAPI },
73 #endif
74     { 0 },
75 };
76 int hwaccel_lax_profile_check = 0;
77 AVBufferRef *hw_device_ctx;
78
79 char *vstats_filename;
80
81 float audio_drift_threshold = 0.1;
82 float dts_delta_threshold   = 10;
83
84 int audio_volume      = 256;
85 int audio_sync_method = 0;
86 int video_sync_method = VSYNC_AUTO;
87 int do_benchmark      = 0;
88 int do_hex_dump       = 0;
89 int do_pkt_dump       = 0;
90 int copy_ts           = 0;
91 int copy_tb           = 1;
92 int exit_on_error     = 0;
93 int print_stats       = 1;
94 int qp_hist           = 0;
95
96 static int file_overwrite     = 0;
97 static int file_skip          = 0;
98 static int video_discard      = 0;
99 static int intra_dc_precision = 8;
100 static int using_stdin        = 0;
101 static int input_sync;
102
103 static void uninit_options(OptionsContext *o)
104 {
105     const OptionDef *po = options;
106     int i;
107
108     /* all OPT_SPEC and OPT_STRING can be freed in generic way */
109     while (po->name) {
110         void *dst = (uint8_t*)o + po->u.off;
111
112         if (po->flags & OPT_SPEC) {
113             SpecifierOpt **so = dst;
114             int i, *count = (int*)(so + 1);
115             for (i = 0; i < *count; i++) {
116                 av_freep(&(*so)[i].specifier);
117                 if (po->flags & OPT_STRING)
118                     av_freep(&(*so)[i].u.str);
119             }
120             av_freep(so);
121             *count = 0;
122         } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
123             av_freep(dst);
124         po++;
125     }
126
127     for (i = 0; i < o->nb_stream_maps; i++)
128         av_freep(&o->stream_maps[i].linklabel);
129     av_freep(&o->stream_maps);
130     av_freep(&o->meta_data_maps);
131     av_freep(&o->streamid_map);
132 }
133
134 static void init_options(OptionsContext *o)
135 {
136     memset(o, 0, sizeof(*o));
137
138     o->mux_max_delay  = 0.7;
139     o->start_time     = AV_NOPTS_VALUE;
140     o->recording_time = INT64_MAX;
141     o->limit_filesize = UINT64_MAX;
142     o->chapters_input_file = INT_MAX;
143     o->accurate_seek  = 1;
144 }
145
146 /* return a copy of the input with the stream specifiers removed from the keys */
147 static AVDictionary *strip_specifiers(AVDictionary *dict)
148 {
149     AVDictionaryEntry *e = NULL;
150     AVDictionary    *ret = NULL;
151
152     while ((e = av_dict_get(dict, "", e, AV_DICT_IGNORE_SUFFIX))) {
153         char *p = strchr(e->key, ':');
154
155         if (p)
156             *p = 0;
157         av_dict_set(&ret, e->key, e->value, 0);
158         if (p)
159             *p = ':';
160     }
161     return ret;
162 }
163
164 static double parse_frame_aspect_ratio(const char *arg)
165 {
166     int x = 0, y = 0;
167     double ar = 0;
168     const char *p;
169     char *end;
170
171     p = strchr(arg, ':');
172     if (p) {
173         x = strtol(arg, &end, 10);
174         if (end == p)
175             y = strtol(end + 1, &end, 10);
176         if (x > 0 && y > 0)
177             ar = (double)x / (double)y;
178     } else
179         ar = strtod(arg, NULL);
180
181     if (!ar) {
182         av_log(NULL, AV_LOG_FATAL, "Incorrect aspect ratio specification.\n");
183         exit_program(1);
184     }
185     return ar;
186 }
187
188 static int show_hwaccels(void *optctx, const char *opt, const char *arg)
189 {
190     int i;
191
192     printf("Supported hardware acceleration:\n");
193     for (i = 0; i < FF_ARRAY_ELEMS(hwaccels) - 1; i++) {
194         printf("%s\n", hwaccels[i].name);
195     }
196     printf("\n");
197     return 0;
198 }
199
200 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
201 {
202     OptionsContext *o = optctx;
203     return parse_option(o, "codec:a", arg, options);
204 }
205
206 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
207 {
208     OptionsContext *o = optctx;
209     return parse_option(o, "codec:v", arg, options);
210 }
211
212 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
213 {
214     OptionsContext *o = optctx;
215     return parse_option(o, "codec:s", arg, options);
216 }
217
218 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
219 {
220     OptionsContext *o = optctx;
221     return parse_option(o, "codec:d", arg, options);
222 }
223
224 static int opt_map(void *optctx, const char *opt, const char *arg)
225 {
226     OptionsContext *o = optctx;
227     StreamMap *m = NULL;
228     int i, negative = 0, file_idx;
229     int sync_file_idx = -1, sync_stream_idx;
230     char *p, *sync;
231     char *map;
232
233     if (*arg == '-') {
234         negative = 1;
235         arg++;
236     }
237     map = av_strdup(arg);
238     if (!map)
239         return AVERROR(ENOMEM);
240
241     /* parse sync stream first, just pick first matching stream */
242     if (sync = strchr(map, ',')) {
243         *sync = 0;
244         sync_file_idx = strtol(sync + 1, &sync, 0);
245         if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
246             av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
247             exit_program(1);
248         }
249         if (*sync)
250             sync++;
251         for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
252             if (check_stream_specifier(input_files[sync_file_idx]->ctx,
253                                        input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
254                 sync_stream_idx = i;
255                 break;
256             }
257         if (i == input_files[sync_file_idx]->nb_streams) {
258             av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
259                                        "match any streams.\n", arg);
260             exit_program(1);
261         }
262     }
263
264
265     if (map[0] == '[') {
266         /* this mapping refers to lavfi output */
267         const char *c = map + 1;
268         GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
269         m = &o->stream_maps[o->nb_stream_maps - 1];
270         m->linklabel = av_get_token(&c, "]");
271         if (!m->linklabel) {
272             av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
273             exit_program(1);
274         }
275     } else {
276         file_idx = strtol(map, &p, 0);
277         if (file_idx >= nb_input_files || file_idx < 0) {
278             av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
279             exit_program(1);
280         }
281         if (negative)
282             /* disable some already defined maps */
283             for (i = 0; i < o->nb_stream_maps; i++) {
284                 m = &o->stream_maps[i];
285                 if (file_idx == m->file_index &&
286                     check_stream_specifier(input_files[m->file_index]->ctx,
287                                            input_files[m->file_index]->ctx->streams[m->stream_index],
288                                            *p == ':' ? p + 1 : p) > 0)
289                     m->disabled = 1;
290             }
291         else
292             for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
293                 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
294                             *p == ':' ? p + 1 : p) <= 0)
295                     continue;
296                 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
297                 m = &o->stream_maps[o->nb_stream_maps - 1];
298
299                 m->file_index   = file_idx;
300                 m->stream_index = i;
301
302                 if (sync_file_idx >= 0) {
303                     m->sync_file_index   = sync_file_idx;
304                     m->sync_stream_index = sync_stream_idx;
305                 } else {
306                     m->sync_file_index   = file_idx;
307                     m->sync_stream_index = i;
308                 }
309             }
310     }
311
312     if (!m) {
313         av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
314         exit_program(1);
315     }
316
317     av_freep(&map);
318     return 0;
319 }
320
321 static int opt_attach(void *optctx, const char *opt, const char *arg)
322 {
323     OptionsContext *o = optctx;
324     GROW_ARRAY(o->attachments, o->nb_attachments);
325     o->attachments[o->nb_attachments - 1] = arg;
326     return 0;
327 }
328
329 #if CONFIG_VAAPI
330 static int opt_vaapi_device(void *optctx, const char *opt, const char *arg)
331 {
332     int err;
333     err = vaapi_device_init(arg);
334     if (err < 0)
335         exit_program(1);
336     return 0;
337 }
338 #endif
339
340 /**
341  * Parse a metadata specifier passed as 'arg' parameter.
342  * @param arg  metadata string to parse
343  * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
344  * @param index for type c/p, chapter/program index is written here
345  * @param stream_spec for type s, the stream specifier is written here
346  */
347 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
348 {
349     if (*arg) {
350         *type = *arg;
351         switch (*arg) {
352         case 'g':
353             break;
354         case 's':
355             if (*(++arg) && *arg != ':') {
356                 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
357                 exit_program(1);
358             }
359             *stream_spec = *arg == ':' ? arg + 1 : "";
360             break;
361         case 'c':
362         case 'p':
363             if (*(++arg) == ':')
364                 *index = strtol(++arg, NULL, 0);
365             break;
366         default:
367             av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
368             exit_program(1);
369         }
370     } else
371         *type = 'g';
372 }
373
374 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
375 {
376     AVDictionary **meta_in = NULL;
377     AVDictionary **meta_out;
378     int i, ret = 0;
379     char type_in, type_out;
380     const char *istream_spec = NULL, *ostream_spec = NULL;
381     int idx_in = 0, idx_out = 0;
382
383     parse_meta_type(inspec,  &type_in,  &idx_in,  &istream_spec);
384     parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
385
386     if (type_in == 'g' || type_out == 'g')
387         o->metadata_global_manual = 1;
388     if (type_in == 's' || type_out == 's')
389         o->metadata_streams_manual = 1;
390     if (type_in == 'c' || type_out == 'c')
391         o->metadata_chapters_manual = 1;
392
393     /* ic is NULL when just disabling automatic mappings */
394     if (!ic)
395         return 0;
396
397 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
398     if ((index) < 0 || (index) >= (nb_elems)) {\
399         av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
400                 (desc), (index));\
401         exit_program(1);\
402     }
403
404 #define SET_DICT(type, meta, context, index)\
405         switch (type) {\
406         case 'g':\
407             meta = &context->metadata;\
408             break;\
409         case 'c':\
410             METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
411             meta = &context->chapters[index]->metadata;\
412             break;\
413         case 'p':\
414             METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
415             meta = &context->programs[index]->metadata;\
416             break;\
417         case 's':\
418             break; /* handled separately below */ \
419         default: av_assert0(0);\
420         }\
421
422     SET_DICT(type_in, meta_in, ic, idx_in);
423     SET_DICT(type_out, meta_out, oc, idx_out);
424
425     /* for input streams choose first matching stream */
426     if (type_in == 's') {
427         for (i = 0; i < ic->nb_streams; i++) {
428             if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
429                 meta_in = &ic->streams[i]->metadata;
430                 break;
431             } else if (ret < 0)
432                 exit_program(1);
433         }
434         if (!meta_in) {
435             av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match  any streams.\n", istream_spec);
436             exit_program(1);
437         }
438     }
439
440     if (type_out == 's') {
441         for (i = 0; i < oc->nb_streams; i++) {
442             if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
443                 meta_out = &oc->streams[i]->metadata;
444                 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
445             } else if (ret < 0)
446                 exit_program(1);
447         }
448     } else
449         av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
450
451     return 0;
452 }
453
454 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
455 {
456     const AVCodecDescriptor *desc;
457     const char *codec_string = encoder ? "encoder" : "decoder";
458     AVCodec *codec;
459
460     codec = encoder ?
461         avcodec_find_encoder_by_name(name) :
462         avcodec_find_decoder_by_name(name);
463
464     if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
465         codec = encoder ? avcodec_find_encoder(desc->id) :
466                           avcodec_find_decoder(desc->id);
467         if (codec)
468             av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
469                    codec_string, codec->name, desc->name);
470     }
471
472     if (!codec) {
473         av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
474         exit_program(1);
475     }
476     if (codec->type != type) {
477         av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
478         exit_program(1);
479     }
480     return codec;
481 }
482
483 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
484 {
485     char *codec_name = NULL;
486
487     MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
488     if (codec_name) {
489         AVCodec *codec = find_codec_or_die(codec_name, st->codecpar->codec_type, 0);
490         st->codecpar->codec_id = codec->id;
491         return codec;
492     } else
493         return avcodec_find_decoder(st->codecpar->codec_id);
494 }
495
496 /* Add all the streams from the given input file to the global
497  * list of input streams. */
498 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
499 {
500     int i, ret;
501
502     for (i = 0; i < ic->nb_streams; i++) {
503         AVStream *st = ic->streams[i];
504         AVCodecParameters *par = st->codecpar;
505         InputStream *ist = av_mallocz(sizeof(*ist));
506         char *framerate = NULL, *hwaccel = NULL, *hwaccel_device = NULL;
507         char *hwaccel_output_format = NULL;
508         char *codec_tag = NULL;
509         char *next;
510
511         if (!ist)
512             exit_program(1);
513
514         GROW_ARRAY(input_streams, nb_input_streams);
515         input_streams[nb_input_streams - 1] = ist;
516
517         ist->st = st;
518         ist->file_index = nb_input_files;
519         ist->discard = 1;
520         st->discard  = AVDISCARD_ALL;
521         ist->nb_samples = 0;
522         ist->min_pts = INT64_MAX;
523         ist->max_pts = INT64_MIN;
524
525         ist->ts_scale = 1.0;
526         MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
527
528         ist->autorotate = 1;
529         MATCH_PER_STREAM_OPT(autorotate, i, ist->autorotate, ic, st);
530
531         MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
532         if (codec_tag) {
533             uint32_t tag = strtol(codec_tag, &next, 0);
534             if (*next)
535                 tag = AV_RL32(codec_tag);
536             st->codecpar->codec_tag = tag;
537         }
538
539         ist->dec = choose_decoder(o, ic, st);
540         ist->decoder_opts = filter_codec_opts(o->g->codec_opts, par->codec_id, ic, st, ist->dec);
541
542         ist->dec_ctx = avcodec_alloc_context3(ist->dec);
543         if (!ist->dec_ctx) {
544             av_log(NULL, AV_LOG_ERROR, "Error allocating the decoder context.\n");
545             exit_program(1);
546         }
547
548         ret = avcodec_parameters_to_context(ist->dec_ctx, par);
549         if (ret < 0) {
550             av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
551             exit_program(1);
552         }
553
554         switch (par->codec_type) {
555         case AVMEDIA_TYPE_VIDEO:
556             ist->resample_height  = ist->dec_ctx->height;
557             ist->resample_width   = ist->dec_ctx->width;
558             ist->resample_pix_fmt = ist->dec_ctx->pix_fmt;
559
560             MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
561             if (framerate && av_parse_video_rate(&ist->framerate,
562                                                  framerate) < 0) {
563                 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
564                        framerate);
565                 exit_program(1);
566             }
567
568             MATCH_PER_STREAM_OPT(hwaccels, str, hwaccel, ic, st);
569             if (hwaccel) {
570                 if (!strcmp(hwaccel, "none"))
571                     ist->hwaccel_id = HWACCEL_NONE;
572                 else if (!strcmp(hwaccel, "auto"))
573                     ist->hwaccel_id = HWACCEL_AUTO;
574                 else {
575                     int i;
576                     for (i = 0; hwaccels[i].name; i++) {
577                         if (!strcmp(hwaccels[i].name, hwaccel)) {
578                             ist->hwaccel_id = hwaccels[i].id;
579                             break;
580                         }
581                     }
582
583                     if (!ist->hwaccel_id) {
584                         av_log(NULL, AV_LOG_FATAL, "Unrecognized hwaccel: %s.\n",
585                                hwaccel);
586                         av_log(NULL, AV_LOG_FATAL, "Supported hwaccels: ");
587                         for (i = 0; hwaccels[i].name; i++)
588                             av_log(NULL, AV_LOG_FATAL, "%s ", hwaccels[i].name);
589                         av_log(NULL, AV_LOG_FATAL, "\n");
590                         exit_program(1);
591                     }
592                 }
593             }
594
595             MATCH_PER_STREAM_OPT(hwaccel_devices, str, hwaccel_device, ic, st);
596             if (hwaccel_device) {
597                 ist->hwaccel_device = av_strdup(hwaccel_device);
598                 if (!ist->hwaccel_device)
599                     exit_program(1);
600             }
601
602             MATCH_PER_STREAM_OPT(hwaccel_output_formats, str,
603                                  hwaccel_output_format, ic, st);
604             if (hwaccel_output_format) {
605                 ist->hwaccel_output_format = av_get_pix_fmt(hwaccel_output_format);
606                 if (ist->hwaccel_output_format == AV_PIX_FMT_NONE) {
607                     av_log(NULL, AV_LOG_FATAL, "Unrecognised hwaccel output "
608                            "format: %s", hwaccel_output_format);
609                 }
610             } else {
611                 ist->hwaccel_output_format = AV_PIX_FMT_NONE;
612             }
613
614             ist->hwaccel_pix_fmt = AV_PIX_FMT_NONE;
615
616             break;
617         case AVMEDIA_TYPE_AUDIO:
618             guess_input_channel_layout(ist);
619
620             ist->resample_sample_fmt     = ist->dec_ctx->sample_fmt;
621             ist->resample_sample_rate    = ist->dec_ctx->sample_rate;
622             ist->resample_channels       = ist->dec_ctx->channels;
623             ist->resample_channel_layout = ist->dec_ctx->channel_layout;
624
625             break;
626         case AVMEDIA_TYPE_DATA:
627         case AVMEDIA_TYPE_SUBTITLE:
628         case AVMEDIA_TYPE_ATTACHMENT:
629         case AVMEDIA_TYPE_UNKNOWN:
630             break;
631         default:
632             abort();
633         }
634     }
635 }
636
637 static void assert_file_overwrite(const char *filename)
638 {
639     if (file_overwrite && file_skip) {
640         fprintf(stderr, "Error, both -y and -n supplied. Exiting.\n");
641         exit_program(1);
642     }
643
644     if (!file_overwrite &&
645         (!strchr(filename, ':') || filename[1] == ':' ||
646          av_strstart(filename, "file:", NULL))) {
647         if (avio_check(filename, 0) == 0) {
648             if (!using_stdin && !file_skip) {
649                 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
650                 fflush(stderr);
651                 if (!read_yesno()) {
652                     fprintf(stderr, "Not overwriting - exiting\n");
653                     exit_program(1);
654                 }
655             }
656             else {
657                 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
658                 exit_program(1);
659             }
660         }
661     }
662 }
663
664 static void dump_attachment(AVStream *st, const char *filename)
665 {
666     int ret;
667     AVIOContext *out = NULL;
668     AVDictionaryEntry *e;
669
670     if (!st->codecpar->extradata_size) {
671         av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
672                nb_input_files - 1, st->index);
673         return;
674     }
675     if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
676         filename = e->value;
677     if (!*filename) {
678         av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
679                "in stream #%d:%d.\n", nb_input_files - 1, st->index);
680         exit_program(1);
681     }
682
683     assert_file_overwrite(filename);
684
685     if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
686         av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
687                filename);
688         exit_program(1);
689     }
690
691     avio_write(out, st->codecpar->extradata, st->codecpar->extradata_size);
692     avio_flush(out);
693     avio_close(out);
694 }
695
696 static int open_input_file(OptionsContext *o, const char *filename)
697 {
698     InputFile *f;
699     AVFormatContext *ic;
700     AVInputFormat *file_iformat = NULL;
701     int err, i, ret;
702     int64_t timestamp;
703     uint8_t buf[128];
704     AVDictionary **opts;
705     AVDictionary *unused_opts = NULL;
706     AVDictionaryEntry *e = NULL;
707     int orig_nb_streams;                     // number of streams before avformat_find_stream_info
708
709     if (o->format) {
710         if (!(file_iformat = av_find_input_format(o->format))) {
711             av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
712             exit_program(1);
713         }
714     }
715
716     if (!strcmp(filename, "-"))
717         filename = "pipe:";
718
719     using_stdin |= !strncmp(filename, "pipe:", 5) ||
720                     !strcmp(filename, "/dev/stdin");
721
722     /* get default parameters from command line */
723     ic = avformat_alloc_context();
724     if (!ic) {
725         print_error(filename, AVERROR(ENOMEM));
726         exit_program(1);
727     }
728     if (o->nb_audio_sample_rate) {
729         snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
730         av_dict_set(&o->g->format_opts, "sample_rate", buf, 0);
731     }
732     if (o->nb_audio_channels) {
733         /* because we set audio_channels based on both the "ac" and
734          * "channel_layout" options, we need to check that the specified
735          * demuxer actually has the "channels" option before setting it */
736         if (file_iformat && file_iformat->priv_class &&
737             av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
738                         AV_OPT_SEARCH_FAKE_OBJ)) {
739             snprintf(buf, sizeof(buf), "%d",
740                      o->audio_channels[o->nb_audio_channels - 1].u.i);
741             av_dict_set(&o->g->format_opts, "channels", buf, 0);
742         }
743     }
744     if (o->nb_frame_rates) {
745         /* set the format-level framerate option;
746          * this is important for video grabbers, e.g. x11 */
747         if (file_iformat && file_iformat->priv_class &&
748             av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
749                         AV_OPT_SEARCH_FAKE_OBJ)) {
750             av_dict_set(&o->g->format_opts, "framerate",
751                         o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
752         }
753     }
754     if (o->nb_frame_sizes) {
755         av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
756     }
757     if (o->nb_frame_pix_fmts)
758         av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
759
760     ic->flags |= AVFMT_FLAG_NONBLOCK;
761     ic->interrupt_callback = int_cb;
762
763     /* open the input file with generic Libav function */
764     err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
765     if (err < 0) {
766         print_error(filename, err);
767         exit_program(1);
768     }
769     assert_avoptions(o->g->format_opts);
770
771     /* apply forced codec ids */
772     for (i = 0; i < ic->nb_streams; i++)
773         choose_decoder(o, ic, ic->streams[i]);
774
775     /* Set AVCodecContext options for avformat_find_stream_info */
776     opts = setup_find_stream_info_opts(ic, o->g->codec_opts);
777     orig_nb_streams = ic->nb_streams;
778
779     /* If not enough info to get the stream parameters, we decode the
780        first frames to get it. (used in mpeg case for example) */
781     ret = avformat_find_stream_info(ic, opts);
782     if (ret < 0) {
783         av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
784         avformat_close_input(&ic);
785         exit_program(1);
786     }
787
788     timestamp = (o->start_time == AV_NOPTS_VALUE) ? 0 : o->start_time;
789     /* add the stream start time */
790     if (ic->start_time != AV_NOPTS_VALUE)
791         timestamp += ic->start_time;
792
793     /* if seeking requested, we execute it */
794     if (o->start_time != AV_NOPTS_VALUE) {
795         ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
796         if (ret < 0) {
797             av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
798                    filename, (double)timestamp / AV_TIME_BASE);
799         }
800     }
801
802     /* update the current parameters so that they match the one of the input stream */
803     add_input_streams(o, ic);
804
805     /* dump the file content */
806     av_dump_format(ic, nb_input_files, filename, 0);
807
808     GROW_ARRAY(input_files, nb_input_files);
809     f = av_mallocz(sizeof(*f));
810     if (!f)
811         exit_program(1);
812     input_files[nb_input_files - 1] = f;
813
814     f->ctx        = ic;
815     f->ist_index  = nb_input_streams - ic->nb_streams;
816     f->start_time = o->start_time;
817     f->recording_time = o->recording_time;
818     f->ts_offset  = o->input_ts_offset - (copy_ts ? 0 : timestamp);
819     f->nb_streams = ic->nb_streams;
820     f->rate_emu   = o->rate_emu;
821     f->accurate_seek = o->accurate_seek;
822     f->loop = o->loop;
823     f->duration = 0;
824     f->time_base = (AVRational){ 1, 1 };
825
826     /* check if all codec options have been used */
827     unused_opts = strip_specifiers(o->g->codec_opts);
828     for (i = f->ist_index; i < nb_input_streams; i++) {
829         e = NULL;
830         while ((e = av_dict_get(input_streams[i]->decoder_opts, "", e,
831                                 AV_DICT_IGNORE_SUFFIX)))
832             av_dict_set(&unused_opts, e->key, NULL, 0);
833     }
834
835     e = NULL;
836     while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
837         const AVClass *class = avcodec_get_class();
838         const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
839                                              AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
840         if (!option)
841             continue;
842         if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) {
843             av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
844                    "input file #%d (%s) is not a decoding option.\n", e->key,
845                    option->help ? option->help : "", nb_input_files - 1,
846                    filename);
847             exit_program(1);
848         }
849
850         av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
851                "input file #%d (%s) has not been used for any stream. The most "
852                "likely reason is either wrong type (e.g. a video option with "
853                "no video streams) or that it is a private option of some decoder "
854                "which was not actually used for any stream.\n", e->key,
855                option->help ? option->help : "", nb_input_files - 1, filename);
856     }
857     av_dict_free(&unused_opts);
858
859     for (i = 0; i < o->nb_dump_attachment; i++) {
860         int j;
861
862         for (j = 0; j < ic->nb_streams; j++) {
863             AVStream *st = ic->streams[j];
864
865             if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
866                 dump_attachment(st, o->dump_attachment[i].u.str);
867         }
868     }
869
870     for (i = 0; i < orig_nb_streams; i++)
871         av_dict_free(&opts[i]);
872     av_freep(&opts);
873
874     return 0;
875 }
876
877 static uint8_t *get_line(AVIOContext *s)
878 {
879     AVIOContext *line;
880     uint8_t *buf;
881     char c;
882
883     if (avio_open_dyn_buf(&line) < 0) {
884         av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
885         exit_program(1);
886     }
887
888     while ((c = avio_r8(s)) && c != '\n')
889         avio_w8(line, c);
890     avio_w8(line, 0);
891     avio_close_dyn_buf(line, &buf);
892
893     return buf;
894 }
895
896 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
897 {
898     int i, ret = -1;
899     char filename[1000];
900     const char *base[3] = { getenv("AVCONV_DATADIR"),
901                             getenv("HOME"),
902                             AVCONV_DATADIR,
903                             };
904
905     for (i = 0; i < FF_ARRAY_ELEMS(base) && ret < 0; i++) {
906         if (!base[i])
907             continue;
908         if (codec_name) {
909             snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
910                      i != 1 ? "" : "/.avconv", codec_name, preset_name);
911             ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
912         }
913         if (ret < 0) {
914             snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
915                      i != 1 ? "" : "/.avconv", preset_name);
916             ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
917         }
918     }
919     return ret;
920 }
921
922 static int choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
923 {
924     enum AVMediaType type = ost->st->codecpar->codec_type;
925     char *codec_name = NULL;
926
927     if (type == AVMEDIA_TYPE_VIDEO || type == AVMEDIA_TYPE_AUDIO || type == AVMEDIA_TYPE_SUBTITLE) {
928         MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
929         if (!codec_name) {
930             ost->st->codecpar->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
931                                                          NULL, ost->st->codecpar->codec_type);
932             ost->enc = avcodec_find_encoder(ost->st->codecpar->codec_id);
933             if (!ost->enc) {
934                 av_log(NULL, AV_LOG_FATAL, "Automatic encoder selection failed for "
935                        "output stream #%d:%d. Default encoder for format %s is "
936                        "probably disabled. Please choose an encoder manually.\n",
937                        ost->file_index, ost->index, s->oformat->name);
938                 return AVERROR_ENCODER_NOT_FOUND;
939             }
940         } else if (!strcmp(codec_name, "copy"))
941             ost->stream_copy = 1;
942         else {
943             ost->enc = find_codec_or_die(codec_name, ost->st->codecpar->codec_type, 1);
944             ost->st->codecpar->codec_id = ost->enc->id;
945         }
946
947         ost->encoding_needed = !ost->stream_copy;
948     } else {
949         /* no encoding supported for other media types */
950         ost->stream_copy     = 1;
951         ost->encoding_needed = 0;
952     }
953
954     return 0;
955 }
956
957 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type)
958 {
959     OutputStream *ost;
960     AVStream *st = avformat_new_stream(oc, NULL);
961     int idx      = oc->nb_streams - 1, ret = 0;
962     const char *bsfs = NULL;
963     char *next, *codec_tag = NULL;
964     double qscale = -1;
965
966     if (!st) {
967         av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
968         exit_program(1);
969     }
970
971     if (oc->nb_streams - 1 < o->nb_streamid_map)
972         st->id = o->streamid_map[oc->nb_streams - 1];
973
974     GROW_ARRAY(output_streams, nb_output_streams);
975     if (!(ost = av_mallocz(sizeof(*ost))))
976         exit_program(1);
977     output_streams[nb_output_streams - 1] = ost;
978
979     ost->file_index = nb_output_files - 1;
980     ost->index      = idx;
981     ost->st         = st;
982     st->codecpar->codec_type = type;
983
984     ret = choose_encoder(o, oc, ost);
985     if (ret < 0) {
986         av_log(NULL, AV_LOG_FATAL, "Error selecting an encoder for stream "
987                "%d:%d\n", ost->file_index, ost->index);
988         exit_program(1);
989     }
990
991     ost->enc_ctx = avcodec_alloc_context3(ost->enc);
992     if (!ost->enc_ctx) {
993         av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding context.\n");
994         exit_program(1);
995     }
996     ost->enc_ctx->codec_type = type;
997
998     if (ost->enc) {
999         AVIOContext *s = NULL;
1000         char *buf = NULL, *arg = NULL, *preset = NULL;
1001
1002         ost->encoder_opts  = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
1003
1004         MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
1005         if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
1006             do  {
1007                 buf = get_line(s);
1008                 if (!buf[0] || buf[0] == '#') {
1009                     av_free(buf);
1010                     continue;
1011                 }
1012                 if (!(arg = strchr(buf, '='))) {
1013                     av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
1014                     exit_program(1);
1015                 }
1016                 *arg++ = 0;
1017                 av_dict_set(&ost->encoder_opts, buf, arg, AV_DICT_DONT_OVERWRITE);
1018                 av_free(buf);
1019             } while (!s->eof_reached);
1020             avio_close(s);
1021         }
1022         if (ret) {
1023             av_log(NULL, AV_LOG_FATAL,
1024                    "Preset %s specified for stream %d:%d, but could not be opened.\n",
1025                    preset, ost->file_index, ost->index);
1026             exit_program(1);
1027         }
1028     } else {
1029         ost->encoder_opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
1030     }
1031
1032     ost->max_frames = INT64_MAX;
1033     MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
1034
1035     MATCH_PER_STREAM_OPT(bitstream_filters, str, bsfs, oc, st);
1036     while (bsfs && *bsfs) {
1037         const AVBitStreamFilter *filter;
1038         char *bsf;
1039
1040         bsf = av_get_token(&bsfs, ",");
1041         if (!bsf)
1042             exit_program(1);
1043
1044         filter = av_bsf_get_by_name(bsf);
1045         if (!filter) {
1046             av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
1047             exit_program(1);
1048         }
1049         av_freep(&bsf);
1050
1051         ost->bitstream_filters = av_realloc_array(ost->bitstream_filters,
1052                                                   ost->nb_bitstream_filters + 1,
1053                                                   sizeof(*ost->bitstream_filters));
1054         if (!ost->bitstream_filters)
1055             exit_program(1);
1056
1057         ost->bitstream_filters[ost->nb_bitstream_filters++] = filter;
1058         if (*bsfs)
1059             bsfs++;
1060     }
1061
1062     MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1063     if (codec_tag) {
1064         uint32_t tag = strtol(codec_tag, &next, 0);
1065         if (*next)
1066             tag = AV_RL32(codec_tag);
1067         ost->enc_ctx->codec_tag = tag;
1068     }
1069
1070     MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1071     if (qscale >= 0) {
1072         ost->enc_ctx->flags |= AV_CODEC_FLAG_QSCALE;
1073         ost->enc_ctx->global_quality = FF_QP2LAMBDA * qscale;
1074     }
1075
1076     ost->max_muxing_queue_size = 128;
1077     MATCH_PER_STREAM_OPT(max_muxing_queue_size, i, ost->max_muxing_queue_size, oc, st);
1078     ost->max_muxing_queue_size *= sizeof(AVPacket);
1079
1080     if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1081         ost->enc_ctx->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
1082
1083     av_opt_get_int(o->g->sws_opts, "sws_flags", 0, &ost->sws_flags);
1084
1085     av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1086
1087     ost->pix_fmts[0] = ost->pix_fmts[1] = AV_PIX_FMT_NONE;
1088     ost->last_mux_dts = AV_NOPTS_VALUE;
1089
1090     ost->muxing_queue = av_fifo_alloc(8 * sizeof(AVPacket));
1091     if (!ost->muxing_queue)
1092         exit_program(1);
1093
1094     return ost;
1095 }
1096
1097 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1098 {
1099     int i;
1100     const char *p = str;
1101     for (i = 0;; i++) {
1102         dest[i] = atoi(p);
1103         if (i == 63)
1104             break;
1105         p = strchr(p, ',');
1106         if (!p) {
1107             av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1108             exit_program(1);
1109         }
1110         p++;
1111     }
1112 }
1113
1114 /* read file contents into a string */
1115 static uint8_t *read_file(const char *filename)
1116 {
1117     AVIOContext *pb      = NULL;
1118     AVIOContext *dyn_buf = NULL;
1119     int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1120     uint8_t buf[1024], *str;
1121
1122     if (ret < 0) {
1123         av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1124         return NULL;
1125     }
1126
1127     ret = avio_open_dyn_buf(&dyn_buf);
1128     if (ret < 0) {
1129         avio_closep(&pb);
1130         return NULL;
1131     }
1132     while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1133         avio_write(dyn_buf, buf, ret);
1134     avio_w8(dyn_buf, 0);
1135     avio_closep(&pb);
1136
1137     ret = avio_close_dyn_buf(dyn_buf, &str);
1138     if (ret < 0)
1139         return NULL;
1140     return str;
1141 }
1142
1143 static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
1144                              OutputStream *ost)
1145 {
1146     AVStream *st = ost->st;
1147     char *filter = NULL, *filter_script = NULL;
1148
1149     MATCH_PER_STREAM_OPT(filter_scripts, str, filter_script, oc, st);
1150     MATCH_PER_STREAM_OPT(filters, str, filter, oc, st);
1151
1152     if (filter_script && filter) {
1153         av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1154                "output stream #%d:%d.\n", nb_output_files, st->index);
1155         exit_program(1);
1156     }
1157
1158     if (filter_script)
1159         return read_file(filter_script);
1160     else if (filter)
1161         return av_strdup(filter);
1162
1163     return av_strdup(st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ?
1164                      "null" : "anull");
1165 }
1166
1167 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc)
1168 {
1169     AVStream *st;
1170     OutputStream *ost;
1171     AVCodecContext *video_enc;
1172     char *frame_aspect_ratio = NULL;
1173
1174     ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO);
1175     st  = ost->st;
1176     video_enc = ost->enc_ctx;
1177
1178     MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1179     if (frame_aspect_ratio)
1180         ost->frame_aspect_ratio = parse_frame_aspect_ratio(frame_aspect_ratio);
1181
1182     if (!ost->stream_copy) {
1183         const char *p = NULL;
1184         char *frame_rate = NULL, *frame_size = NULL;
1185         char *frame_pix_fmt = NULL;
1186         char *intra_matrix = NULL, *inter_matrix = NULL;
1187         int do_pass = 0;
1188         int i;
1189
1190         MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1191         if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1192             av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1193             exit_program(1);
1194         }
1195
1196         MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1197         if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1198             av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1199             exit_program(1);
1200         }
1201
1202         MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1203         if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1204             av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1205             exit_program(1);
1206         }
1207         st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1208
1209         MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1210         if (intra_matrix) {
1211             if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1212                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1213                 exit_program(1);
1214             }
1215             parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1216         }
1217         MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1218         if (inter_matrix) {
1219             if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1220                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1221                 exit_program(1);
1222             }
1223             parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1224         }
1225
1226         MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1227         for (i = 0; p; i++) {
1228             int start, end, q;
1229             int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1230             if (e != 3) {
1231                 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1232                 exit_program(1);
1233             }
1234             video_enc->rc_override =
1235                 av_realloc(video_enc->rc_override,
1236                            sizeof(RcOverride) * (i + 1));
1237             if (!video_enc->rc_override) {
1238                 av_log(NULL, AV_LOG_FATAL, "Could not (re)allocate memory for rc_override.\n");
1239                 exit_program(1);
1240             }
1241             video_enc->rc_override[i].start_frame = start;
1242             video_enc->rc_override[i].end_frame   = end;
1243             if (q > 0) {
1244                 video_enc->rc_override[i].qscale         = q;
1245                 video_enc->rc_override[i].quality_factor = 1.0;
1246             }
1247             else {
1248                 video_enc->rc_override[i].qscale         = 0;
1249                 video_enc->rc_override[i].quality_factor = -q/100.0;
1250             }
1251             p = strchr(p, '/');
1252             if (p) p++;
1253         }
1254         video_enc->rc_override_count = i;
1255         video_enc->intra_dc_precision = intra_dc_precision - 8;
1256
1257         /* two pass mode */
1258         MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1259         if (do_pass) {
1260             if (do_pass == 1) {
1261                 video_enc->flags |= AV_CODEC_FLAG_PASS1;
1262             } else {
1263                 video_enc->flags |= AV_CODEC_FLAG_PASS2;
1264             }
1265         }
1266
1267         MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1268         if (ost->logfile_prefix &&
1269             !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1270             exit_program(1);
1271
1272         if (do_pass) {
1273             char logfilename[1024];
1274             FILE *f;
1275
1276             snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1277                      ost->logfile_prefix ? ost->logfile_prefix :
1278                                            DEFAULT_PASS_LOGFILENAME_PREFIX,
1279                      i);
1280             if (!strcmp(ost->enc->name, "libx264")) {
1281                 av_dict_set(&ost->encoder_opts, "stats", logfilename, AV_DICT_DONT_OVERWRITE);
1282             } else {
1283                 if (video_enc->flags & AV_CODEC_FLAG_PASS1) {
1284                     f = fopen(logfilename, "wb");
1285                     if (!f) {
1286                         av_log(NULL, AV_LOG_FATAL, "Cannot write log file '%s' for pass-1 encoding: %s\n",
1287                                logfilename, strerror(errno));
1288                         exit_program(1);
1289                     }
1290                     ost->logfile = f;
1291                 } else {
1292                     char  *logbuffer = read_file(logfilename);
1293
1294                     if (!logbuffer) {
1295                         av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
1296                                logfilename);
1297                         exit_program(1);
1298                     }
1299                     video_enc->stats_in = logbuffer;
1300                 }
1301             }
1302         }
1303
1304         MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1305         if (ost->forced_keyframes)
1306             ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1307
1308         MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1309
1310         ost->top_field_first = -1;
1311         MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1312
1313
1314         ost->avfilter = get_ost_filters(o, oc, ost);
1315         if (!ost->avfilter)
1316             exit_program(1);
1317     } else {
1318         MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1319     }
1320
1321     return ost;
1322 }
1323
1324 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc)
1325 {
1326     AVStream *st;
1327     OutputStream *ost;
1328     AVCodecContext *audio_enc;
1329
1330     ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO);
1331     st  = ost->st;
1332
1333     audio_enc = ost->enc_ctx;
1334     audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1335
1336     if (!ost->stream_copy) {
1337         char *sample_fmt = NULL;
1338
1339         MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1340
1341         MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1342         if (sample_fmt &&
1343             (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1344             av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1345             exit_program(1);
1346         }
1347
1348         MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1349
1350         ost->avfilter = get_ost_filters(o, oc, ost);
1351         if (!ost->avfilter)
1352             exit_program(1);
1353     }
1354
1355     return ost;
1356 }
1357
1358 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc)
1359 {
1360     OutputStream *ost;
1361
1362     ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA);
1363     if (!ost->stream_copy) {
1364         av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1365         exit_program(1);
1366     }
1367
1368     return ost;
1369 }
1370
1371 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc)
1372 {
1373     OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT);
1374     ost->stream_copy = 1;
1375     ost->finished    = 1;
1376     return ost;
1377 }
1378
1379 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc)
1380 {
1381     OutputStream *ost;
1382     AVCodecContext *subtitle_enc;
1383
1384     ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE);
1385     subtitle_enc = ost->enc_ctx;
1386
1387     subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1388
1389     return ost;
1390 }
1391
1392 /* arg format is "output-stream-index:streamid-value". */
1393 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1394 {
1395     OptionsContext *o = optctx;
1396     int idx;
1397     char *p;
1398     char idx_str[16];
1399
1400     av_strlcpy(idx_str, arg, sizeof(idx_str));
1401     p = strchr(idx_str, ':');
1402     if (!p) {
1403         av_log(NULL, AV_LOG_FATAL,
1404                "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1405                arg, opt);
1406         exit_program(1);
1407     }
1408     *p++ = '\0';
1409     idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, INT_MAX);
1410     o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1411     o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1412     return 0;
1413 }
1414
1415 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1416 {
1417     AVFormatContext *is = ifile->ctx;
1418     AVFormatContext *os = ofile->ctx;
1419     AVChapter **tmp;
1420     int i;
1421
1422     tmp = av_realloc(os->chapters, sizeof(*os->chapters) * (is->nb_chapters + os->nb_chapters));
1423     if (!tmp)
1424         return AVERROR(ENOMEM);
1425     os->chapters = tmp;
1426
1427     for (i = 0; i < is->nb_chapters; i++) {
1428         AVChapter *in_ch = is->chapters[i], *out_ch;
1429         int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
1430         int64_t ts_off   = av_rescale_q(start_time - ifile->ts_offset,
1431                                        AV_TIME_BASE_Q, in_ch->time_base);
1432         int64_t rt       = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1433                            av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1434
1435
1436         if (in_ch->end < ts_off)
1437             continue;
1438         if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1439             break;
1440
1441         out_ch = av_mallocz(sizeof(AVChapter));
1442         if (!out_ch)
1443             return AVERROR(ENOMEM);
1444
1445         out_ch->id        = in_ch->id;
1446         out_ch->time_base = in_ch->time_base;
1447         out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
1448         out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
1449
1450         if (copy_metadata)
1451             av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1452
1453         os->chapters[os->nb_chapters++] = out_ch;
1454     }
1455     return 0;
1456 }
1457
1458 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1459                                AVFormatContext *oc)
1460 {
1461     OutputStream *ost;
1462
1463     switch (ofilter->type) {
1464     case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
1465     case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
1466     default:
1467         av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1468                "currently.\n");
1469         exit_program(1);
1470     }
1471
1472     ost->source_index = -1;
1473     ost->filter       = ofilter;
1474
1475     ofilter->ost      = ost;
1476     ofilter->format   = -1;
1477
1478     if (ost->stream_copy) {
1479         av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1480                "which is fed from a complex filtergraph. Filtering and streamcopy "
1481                "cannot be used together.\n", ost->file_index, ost->index);
1482         exit_program(1);
1483     }
1484
1485     avfilter_inout_free(&ofilter->out_tmp);
1486 }
1487
1488 static int init_complex_filters(void)
1489 {
1490     int i, ret = 0;
1491
1492     for (i = 0; i < nb_filtergraphs; i++) {
1493         ret = init_complex_filtergraph(filtergraphs[i]);
1494         if (ret < 0)
1495             return ret;
1496     }
1497     return 0;
1498 }
1499
1500 static int configure_complex_filters(void)
1501 {
1502     int i, j, ret = 0;
1503
1504     for (i = 0; i < nb_filtergraphs; i++) {
1505         FilterGraph *fg = filtergraphs[i];
1506
1507         if (filtergraph_is_simple(fg))
1508             continue;
1509
1510         for (j = 0; j < fg->nb_inputs; j++) {
1511             ret = ifilter_parameters_from_decoder(fg->inputs[j],
1512                                                   fg->inputs[j]->ist->dec_ctx);
1513             if (ret < 0) {
1514                 av_log(NULL, AV_LOG_ERROR,
1515                        "Error initializing filtergraph %d input %d\n", i, j);
1516                 return ret;
1517             }
1518         }
1519
1520         ret = configure_filtergraph(filtergraphs[i]);
1521         if (ret < 0)
1522             return ret;
1523     }
1524     return 0;
1525 }
1526
1527 static int open_output_file(OptionsContext *o, const char *filename)
1528 {
1529     AVFormatContext *oc;
1530     int i, j, err;
1531     AVOutputFormat *file_oformat;
1532     OutputFile *of;
1533     OutputStream *ost;
1534     InputStream  *ist;
1535     AVDictionary *unused_opts = NULL;
1536     AVDictionaryEntry *e = NULL;
1537
1538     GROW_ARRAY(output_files, nb_output_files);
1539     of = av_mallocz(sizeof(*of));
1540     if (!of)
1541         exit_program(1);
1542     output_files[nb_output_files - 1] = of;
1543
1544     of->ost_index      = nb_output_streams;
1545     of->recording_time = o->recording_time;
1546     of->start_time     = o->start_time;
1547     of->limit_filesize = o->limit_filesize;
1548     of->shortest       = o->shortest;
1549     av_dict_copy(&of->opts, o->g->format_opts, 0);
1550
1551     if (!strcmp(filename, "-"))
1552         filename = "pipe:";
1553
1554     oc = avformat_alloc_context();
1555     if (!oc) {
1556         print_error(filename, AVERROR(ENOMEM));
1557         exit_program(1);
1558     }
1559     of->ctx = oc;
1560     if (o->recording_time != INT64_MAX)
1561         oc->duration = o->recording_time;
1562
1563     if (o->format) {
1564         file_oformat = av_guess_format(o->format, NULL, NULL);
1565         if (!file_oformat) {
1566             av_log(NULL, AV_LOG_FATAL, "Requested output format '%s' is not a suitable output format\n", o->format);
1567             exit_program(1);
1568         }
1569     } else {
1570         file_oformat = av_guess_format(NULL, filename, NULL);
1571         if (!file_oformat) {
1572             av_log(NULL, AV_LOG_FATAL, "Unable to find a suitable output format for '%s'\n",
1573                    filename);
1574             exit_program(1);
1575         }
1576     }
1577
1578     oc->oformat = file_oformat;
1579     oc->interrupt_callback = int_cb;
1580     av_strlcpy(oc->filename, filename, sizeof(oc->filename));
1581
1582     /* create streams for all unlabeled output pads */
1583     for (i = 0; i < nb_filtergraphs; i++) {
1584         FilterGraph *fg = filtergraphs[i];
1585         for (j = 0; j < fg->nb_outputs; j++) {
1586             OutputFilter *ofilter = fg->outputs[j];
1587
1588             if (!ofilter->out_tmp || ofilter->out_tmp->name)
1589                 continue;
1590
1591             switch (ofilter->type) {
1592             case AVMEDIA_TYPE_VIDEO:    o->video_disable    = 1; break;
1593             case AVMEDIA_TYPE_AUDIO:    o->audio_disable    = 1; break;
1594             case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1595             }
1596             init_output_filter(ofilter, o, oc);
1597         }
1598     }
1599
1600     if (!o->nb_stream_maps) {
1601         /* pick the "best" stream of each type */
1602 #define NEW_STREAM(type, index)\
1603         if (index >= 0) {\
1604             ost = new_ ## type ## _stream(o, oc);\
1605             ost->source_index = index;\
1606             ost->sync_ist     = input_streams[index];\
1607             input_streams[index]->discard = 0;\
1608             input_streams[index]->st->discard = AVDISCARD_NONE;\
1609         }
1610
1611         /* video: highest resolution */
1612         if (!o->video_disable && oc->oformat->video_codec != AV_CODEC_ID_NONE) {
1613             int area = 0, idx = -1;
1614             for (i = 0; i < nb_input_streams; i++) {
1615                 ist = input_streams[i];
1616                 if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
1617                     ist->st->codecpar->width * ist->st->codecpar->height > area) {
1618                     area = ist->st->codecpar->width * ist->st->codecpar->height;
1619                     idx = i;
1620                 }
1621             }
1622             NEW_STREAM(video, idx);
1623         }
1624
1625         /* audio: most channels */
1626         if (!o->audio_disable && oc->oformat->audio_codec != AV_CODEC_ID_NONE) {
1627             int channels = 0, idx = -1;
1628             for (i = 0; i < nb_input_streams; i++) {
1629                 ist = input_streams[i];
1630                 if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
1631                     ist->st->codecpar->channels > channels) {
1632                     channels = ist->st->codecpar->channels;
1633                     idx = i;
1634                 }
1635             }
1636             NEW_STREAM(audio, idx);
1637         }
1638
1639         /* subtitles: pick first */
1640         if (!o->subtitle_disable && oc->oformat->subtitle_codec != AV_CODEC_ID_NONE) {
1641             for (i = 0; i < nb_input_streams; i++)
1642                 if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1643                     NEW_STREAM(subtitle, i);
1644                     break;
1645                 }
1646         }
1647         /* do something with data? */
1648     } else {
1649         for (i = 0; i < o->nb_stream_maps; i++) {
1650             StreamMap *map = &o->stream_maps[i];
1651
1652             if (map->disabled)
1653                 continue;
1654
1655             if (map->linklabel) {
1656                 FilterGraph *fg;
1657                 OutputFilter *ofilter = NULL;
1658                 int j, k;
1659
1660                 for (j = 0; j < nb_filtergraphs; j++) {
1661                     fg = filtergraphs[j];
1662                     for (k = 0; k < fg->nb_outputs; k++) {
1663                         AVFilterInOut *out = fg->outputs[k]->out_tmp;
1664                         if (out && !strcmp(out->name, map->linklabel)) {
1665                             ofilter = fg->outputs[k];
1666                             goto loop_end;
1667                         }
1668                     }
1669                 }
1670 loop_end:
1671                 if (!ofilter) {
1672                     av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1673                            "in any defined filter graph.\n", map->linklabel);
1674                     exit_program(1);
1675                 }
1676                 init_output_filter(ofilter, o, oc);
1677             } else {
1678                 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
1679                 switch (ist->st->codecpar->codec_type) {
1680                 case AVMEDIA_TYPE_VIDEO:    ost = new_video_stream(o, oc);    break;
1681                 case AVMEDIA_TYPE_AUDIO:    ost = new_audio_stream(o, oc);    break;
1682                 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(o, oc); break;
1683                 case AVMEDIA_TYPE_DATA:     ost = new_data_stream(o, oc);     break;
1684                 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc); break;
1685                 default:
1686                     av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
1687                            map->file_index, map->stream_index);
1688                     exit_program(1);
1689                 }
1690
1691                 ost->source_index = input_files[map->file_index]->ist_index + map->stream_index;
1692                 ost->sync_ist     = input_streams[input_files[map->sync_file_index]->ist_index +
1693                                                map->sync_stream_index];
1694                 ist->discard = 0;
1695                 ist->st->discard = AVDISCARD_NONE;
1696             }
1697         }
1698     }
1699
1700     /* handle attached files */
1701     for (i = 0; i < o->nb_attachments; i++) {
1702         AVIOContext *pb;
1703         uint8_t *attachment;
1704         const char *p;
1705         int64_t len;
1706
1707         if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
1708             av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
1709                    o->attachments[i]);
1710             exit_program(1);
1711         }
1712         if ((len = avio_size(pb)) <= 0) {
1713             av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
1714                    o->attachments[i]);
1715             exit_program(1);
1716         }
1717         if (!(attachment = av_malloc(len))) {
1718             av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
1719                    o->attachments[i]);
1720             exit_program(1);
1721         }
1722         avio_read(pb, attachment, len);
1723
1724         ost = new_attachment_stream(o, oc);
1725         ost->stream_copy               = 0;
1726         ost->source_index              = -1;
1727         ost->attachment_filename       = o->attachments[i];
1728         ost->st->codecpar->extradata      = attachment;
1729         ost->st->codecpar->extradata_size = len;
1730
1731         p = strrchr(o->attachments[i], '/');
1732         av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
1733         avio_close(pb);
1734     }
1735
1736     if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
1737         av_dump_format(oc, nb_output_files - 1, oc->filename, 1);
1738         av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", nb_output_files - 1);
1739         exit_program(1);
1740     }
1741
1742     /* check if all codec options have been used */
1743     unused_opts = strip_specifiers(o->g->codec_opts);
1744     for (i = of->ost_index; i < nb_output_streams; i++) {
1745         e = NULL;
1746         while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
1747                                 AV_DICT_IGNORE_SUFFIX)))
1748             av_dict_set(&unused_opts, e->key, NULL, 0);
1749     }
1750
1751     e = NULL;
1752     while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
1753         const AVClass *class = avcodec_get_class();
1754         const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
1755                                              AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1756         if (!option)
1757             continue;
1758         if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
1759             av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
1760                    "output file #%d (%s) is not an encoding option.\n", e->key,
1761                    option->help ? option->help : "", nb_output_files - 1,
1762                    filename);
1763             exit_program(1);
1764         }
1765
1766         av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
1767                "output file #%d (%s) has not been used for any stream. The most "
1768                "likely reason is either wrong type (e.g. a video option with "
1769                "no video streams) or that it is a private option of some encoder "
1770                "which was not actually used for any stream.\n", e->key,
1771                option->help ? option->help : "", nb_output_files - 1, filename);
1772     }
1773     av_dict_free(&unused_opts);
1774
1775     /* set the decoding_needed flags and create simple filtergraphs */
1776     for (i = of->ost_index; i < nb_output_streams; i++) {
1777         OutputStream *ost = output_streams[i];
1778
1779         if (ost->encoding_needed && ost->source_index >= 0) {
1780             InputStream *ist = input_streams[ost->source_index];
1781             ist->decoding_needed = 1;
1782
1783             if (ost->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
1784                 ost->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
1785                 err = init_simple_filtergraph(ist, ost);
1786                 if (err < 0) {
1787                     av_log(NULL, AV_LOG_ERROR,
1788                            "Error initializing a simple filtergraph between streams "
1789                            "%d:%d->%d:%d\n", ist->file_index, ost->source_index,
1790                            nb_output_files - 1, ost->st->index);
1791                     exit_program(1);
1792                 }
1793             }
1794         }
1795
1796         /*
1797          * We want CFR output if and only if one of those is true:
1798          * 1) user specified output framerate with -r
1799          * 2) user specified -vsync cfr
1800          * 3) output format is CFR and the user didn't force vsync to
1801          *    something else than CFR
1802          *
1803          * in such a case, set ost->frame_rate
1804          */
1805         if (ost->encoding_needed && ost->enc_ctx->codec_type == AVMEDIA_TYPE_VIDEO) {
1806             int format_cfr = !(oc->oformat->flags & (AVFMT_NOTIMESTAMPS | AVFMT_VARIABLE_FPS));
1807             int need_cfr = !!ost->frame_rate.num;
1808
1809             if (video_sync_method == VSYNC_CFR ||
1810                 (video_sync_method == VSYNC_AUTO && format_cfr))
1811                 need_cfr = 1;
1812
1813             if (need_cfr && !ost->frame_rate.num) {
1814                 InputStream *ist = ost->source_index >= 0 ? input_streams[ost->source_index] : NULL;
1815
1816                 if (ist && ist->framerate.num)
1817                     ost->frame_rate = ist->framerate;
1818                 else if (ist && ist->st->avg_frame_rate.num)
1819                     ost->frame_rate = ist->st->avg_frame_rate;
1820                 else {
1821                     av_log(NULL, AV_LOG_WARNING, "Constant framerate requested "
1822                            "for the output stream #%d:%d, but no information "
1823                            "about the input framerate is available. Falling "
1824                            "back to a default value of 25fps. Use the -r option "
1825                            "if you want a different framerate.\n",
1826                            ost->file_index, ost->index);
1827                     ost->frame_rate = (AVRational){ 25, 1 };
1828                 }
1829             }
1830
1831             if (need_cfr && ost->enc->supported_framerates && !ost->force_fps) {
1832                 int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
1833                 ost->frame_rate = ost->enc->supported_framerates[idx];
1834             }
1835         }
1836
1837         /* set the filter output constraints */
1838         if (ost->filter) {
1839             OutputFilter *f = ost->filter;
1840             int count;
1841             switch (ost->enc_ctx->codec_type) {
1842             case AVMEDIA_TYPE_VIDEO:
1843                 f->frame_rate = ost->frame_rate;
1844                 f->width      = ost->enc_ctx->width;
1845                 f->height     = ost->enc_ctx->height;
1846                 if (ost->enc_ctx->pix_fmt != AV_PIX_FMT_NONE) {
1847                     f->format = ost->enc_ctx->pix_fmt;
1848                 } else if (ost->enc->pix_fmts) {
1849                     count = 0;
1850                     while (ost->enc->pix_fmts[count] != AV_PIX_FMT_NONE)
1851                         count++;
1852                     f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
1853                     if (!f->formats)
1854                         exit_program(1);
1855                     memcpy(f->formats, ost->enc->pix_fmts, (count + 1) * sizeof(*f->formats));
1856                 }
1857                 break;
1858             case AVMEDIA_TYPE_AUDIO:
1859                 if (ost->enc_ctx->sample_fmt != AV_SAMPLE_FMT_NONE) {
1860                     f->format = ost->enc_ctx->sample_fmt;
1861                 } else if (ost->enc->sample_fmts) {
1862                     count = 0;
1863                     while (ost->enc->sample_fmts[count] != AV_SAMPLE_FMT_NONE)
1864                         count++;
1865                     f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
1866                     if (!f->formats)
1867                         exit_program(1);
1868                     memcpy(f->formats, ost->enc->sample_fmts, (count + 1) * sizeof(*f->formats));
1869                 }
1870                 if (ost->enc_ctx->sample_rate) {
1871                     f->sample_rate = ost->enc_ctx->sample_rate;
1872                 } else if (ost->enc->supported_samplerates) {
1873                     count = 0;
1874                     while (ost->enc->supported_samplerates[count])
1875                         count++;
1876                     f->sample_rates = av_mallocz_array(count + 1, sizeof(*f->sample_rates));
1877                     if (!f->sample_rates)
1878                         exit_program(1);
1879                     memcpy(f->sample_rates, ost->enc->supported_samplerates,
1880                            (count + 1) * sizeof(*f->sample_rates));
1881                 }
1882                 if (ost->enc_ctx->channels) {
1883                     f->channel_layout = av_get_default_channel_layout(ost->enc_ctx->channels);
1884                 } else if (ost->enc->channel_layouts) {
1885                     count = 0;
1886                     while (ost->enc->channel_layouts[count])
1887                         count++;
1888                     f->channel_layouts = av_mallocz_array(count + 1, sizeof(*f->channel_layouts));
1889                     if (!f->channel_layouts)
1890                         exit_program(1);
1891                     memcpy(f->channel_layouts, ost->enc->channel_layouts,
1892                            (count + 1) * sizeof(*f->channel_layouts));
1893                 }
1894                 break;
1895             }
1896         }
1897
1898     }
1899
1900     /* check filename in case of an image number is expected */
1901     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
1902         if (!av_filename_number_test(oc->filename)) {
1903             print_error(oc->filename, AVERROR(EINVAL));
1904             exit_program(1);
1905         }
1906     }
1907
1908     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
1909         /* test if it already exists to avoid losing precious files */
1910         assert_file_overwrite(filename);
1911
1912         /* open the file */
1913         if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
1914                               &oc->interrupt_callback,
1915                               &of->opts)) < 0) {
1916             print_error(filename, err);
1917             exit_program(1);
1918         }
1919     }
1920
1921     if (o->mux_preload) {
1922         uint8_t buf[64];
1923         snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
1924         av_dict_set(&of->opts, "preload", buf, 0);
1925     }
1926     oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
1927     oc->flags |= AVFMT_FLAG_NONBLOCK;
1928
1929     /* copy metadata */
1930     for (i = 0; i < o->nb_metadata_map; i++) {
1931         char *p;
1932         int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
1933
1934         if (in_file_index >= nb_input_files) {
1935             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
1936             exit_program(1);
1937         }
1938         copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
1939                       in_file_index >= 0 ?
1940                       input_files[in_file_index]->ctx : NULL, o);
1941     }
1942
1943     /* copy chapters */
1944     if (o->chapters_input_file >= nb_input_files) {
1945         if (o->chapters_input_file == INT_MAX) {
1946             /* copy chapters from the first input file that has them*/
1947             o->chapters_input_file = -1;
1948             for (i = 0; i < nb_input_files; i++)
1949                 if (input_files[i]->ctx->nb_chapters) {
1950                     o->chapters_input_file = i;
1951                     break;
1952                 }
1953         } else {
1954             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
1955                    o->chapters_input_file);
1956             exit_program(1);
1957         }
1958     }
1959     if (o->chapters_input_file >= 0)
1960         copy_chapters(input_files[o->chapters_input_file], of,
1961                       !o->metadata_chapters_manual);
1962
1963     /* copy global metadata by default */
1964     if (!o->metadata_global_manual && nb_input_files)
1965         av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
1966                      AV_DICT_DONT_OVERWRITE);
1967     if (!o->metadata_streams_manual)
1968         for (i = of->ost_index; i < nb_output_streams; i++) {
1969             InputStream *ist;
1970             if (output_streams[i]->source_index < 0)         /* this is true e.g. for attached files */
1971                 continue;
1972             ist = input_streams[output_streams[i]->source_index];
1973             av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
1974         }
1975
1976     /* process manually set metadata */
1977     for (i = 0; i < o->nb_metadata; i++) {
1978         AVDictionary **m;
1979         char type, *val;
1980         const char *stream_spec;
1981         int index = 0, j, ret;
1982
1983         val = strchr(o->metadata[i].u.str, '=');
1984         if (!val) {
1985             av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
1986                    o->metadata[i].u.str);
1987             exit_program(1);
1988         }
1989         *val++ = 0;
1990
1991         parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
1992         if (type == 's') {
1993             for (j = 0; j < oc->nb_streams; j++) {
1994                 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
1995                     av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
1996                 } else if (ret < 0)
1997                     exit_program(1);
1998             }
1999         }
2000         else {
2001             switch (type) {
2002             case 'g':
2003                 m = &oc->metadata;
2004                 break;
2005             case 'c':
2006                 if (index < 0 || index >= oc->nb_chapters) {
2007                     av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2008                     exit_program(1);
2009                 }
2010                 m = &oc->chapters[index]->metadata;
2011                 break;
2012             default:
2013                 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2014                 exit_program(1);
2015             }
2016             av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2017         }
2018     }
2019
2020     return 0;
2021 }
2022
2023 static int opt_target(void *optctx, const char *opt, const char *arg)
2024 {
2025     OptionsContext *o = optctx;
2026     enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2027     static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2028
2029     if (!strncmp(arg, "pal-", 4)) {
2030         norm = PAL;
2031         arg += 4;
2032     } else if (!strncmp(arg, "ntsc-", 5)) {
2033         norm = NTSC;
2034         arg += 5;
2035     } else if (!strncmp(arg, "film-", 5)) {
2036         norm = FILM;
2037         arg += 5;
2038     } else {
2039         /* Try to determine PAL/NTSC by peeking in the input files */
2040         if (nb_input_files) {
2041             int i, j, fr;
2042             for (j = 0; j < nb_input_files; j++) {
2043                 for (i = 0; i < input_files[j]->nb_streams; i++) {
2044                     AVStream *st = input_files[j]->ctx->streams[i];
2045                     if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO)
2046                         continue;
2047                     fr = st->time_base.den * 1000 / st->time_base.num;
2048                     if (fr == 25000) {
2049                         norm = PAL;
2050                         break;
2051                     } else if ((fr == 29970) || (fr == 23976)) {
2052                         norm = NTSC;
2053                         break;
2054                     }
2055                 }
2056                 if (norm != UNKNOWN)
2057                     break;
2058             }
2059         }
2060         if (norm != UNKNOWN)
2061             av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2062     }
2063
2064     if (norm == UNKNOWN) {
2065         av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2066         av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2067         av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2068         exit_program(1);
2069     }
2070
2071     if (!strcmp(arg, "vcd")) {
2072         opt_video_codec(o, "c:v", "mpeg1video");
2073         opt_audio_codec(o, "c:a", "mp2");
2074         parse_option(o, "f", "vcd", options);
2075
2076         parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2077         parse_option(o, "r", frame_rates[norm], options);
2078         opt_default(NULL, "g", norm == PAL ? "15" : "18");
2079
2080         opt_default(NULL, "b", "1150000");
2081         opt_default(NULL, "maxrate", "1150000");
2082         opt_default(NULL, "minrate", "1150000");
2083         opt_default(NULL, "bufsize", "327680"); // 40*1024*8;
2084
2085         opt_default(NULL, "b:a", "224000");
2086         parse_option(o, "ar", "44100", options);
2087         parse_option(o, "ac", "2", options);
2088
2089         opt_default(NULL, "packetsize", "2324");
2090         opt_default(NULL, "muxrate", "3528"); // 2352 * 75 / 50;
2091
2092         /* We have to offset the PTS, so that it is consistent with the SCR.
2093            SCR starts at 36000, but the first two packs contain only padding
2094            and the first pack from the other stream, respectively, may also have
2095            been written before.
2096            So the real data starts at SCR 36000+3*1200. */
2097         o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2098     } else if (!strcmp(arg, "svcd")) {
2099
2100         opt_video_codec(o, "c:v", "mpeg2video");
2101         opt_audio_codec(o, "c:a", "mp2");
2102         parse_option(o, "f", "svcd", options);
2103
2104         parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2105         parse_option(o, "r", frame_rates[norm], options);
2106         opt_default(NULL, "g", norm == PAL ? "15" : "18");
2107
2108         opt_default(NULL, "b", "2040000");
2109         opt_default(NULL, "maxrate", "2516000");
2110         opt_default(NULL, "minrate", "0"); // 1145000;
2111         opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
2112         opt_default(NULL, "scan_offset", "1");
2113
2114
2115         opt_default(NULL, "b:a", "224000");
2116         parse_option(o, "ar", "44100", options);
2117
2118         opt_default(NULL, "packetsize", "2324");
2119
2120     } else if (!strcmp(arg, "dvd")) {
2121
2122         opt_video_codec(o, "c:v", "mpeg2video");
2123         opt_audio_codec(o, "c:a", "ac3");
2124         parse_option(o, "f", "dvd", options);
2125
2126         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2127         parse_option(o, "r", frame_rates[norm], options);
2128         opt_default(NULL, "g", norm == PAL ? "15" : "18");
2129
2130         opt_default(NULL, "b", "6000000");
2131         opt_default(NULL, "maxrate", "9000000");
2132         opt_default(NULL, "minrate", "0"); // 1500000;
2133         opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
2134
2135         opt_default(NULL, "packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
2136         opt_default(NULL, "muxrate", "25200"); // from mplex project: data_rate = 1260000. mux_rate = data_rate / 50
2137
2138         opt_default(NULL, "b:a", "448000");
2139         parse_option(o, "ar", "48000", options);
2140
2141     } else if (!strncmp(arg, "dv", 2)) {
2142
2143         parse_option(o, "f", "dv", options);
2144
2145         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2146         parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2147                           norm == PAL ? "yuv420p" : "yuv411p", options);
2148         parse_option(o, "r", frame_rates[norm], options);
2149
2150         parse_option(o, "ar", "48000", options);
2151         parse_option(o, "ac", "2", options);
2152
2153     } else {
2154         av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2155         return AVERROR(EINVAL);
2156     }
2157
2158     av_dict_copy(&o->g->codec_opts,  codec_opts, 0);
2159     av_dict_copy(&o->g->format_opts, format_opts, 0);
2160
2161     return 0;
2162 }
2163
2164 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2165 {
2166     av_free (vstats_filename);
2167     vstats_filename = av_strdup (arg);
2168     return 0;
2169 }
2170
2171 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2172 {
2173     char filename[40];
2174     time_t today2 = time(NULL);
2175     struct tm *today = localtime(&today2);
2176
2177     if (!today) { // maybe tomorrow
2178         av_log(NULL, AV_LOG_FATAL, "Unable to get current time.\n");
2179         exit_program(1);
2180     }
2181
2182     snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2183              today->tm_sec);
2184     return opt_vstats_file(NULL, opt, filename);
2185 }
2186
2187 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2188 {
2189     OptionsContext *o = optctx;
2190     return parse_option(o, "frames:v", arg, options);
2191 }
2192
2193 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2194 {
2195     OptionsContext *o = optctx;
2196     return parse_option(o, "frames:a", arg, options);
2197 }
2198
2199 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2200 {
2201     OptionsContext *o = optctx;
2202     return parse_option(o, "frames:d", arg, options);
2203 }
2204
2205 static int opt_video_tag(void *optctx, const char *opt, const char *arg)
2206 {
2207     OptionsContext *o = optctx;
2208     return parse_option(o, "tag:v", arg, options);
2209 }
2210
2211 static int opt_audio_tag(void *optctx, const char *opt, const char *arg)
2212 {
2213     OptionsContext *o = optctx;
2214     return parse_option(o, "tag:a", arg, options);
2215 }
2216
2217 static int opt_subtitle_tag(void *optctx, const char *opt, const char *arg)
2218 {
2219     OptionsContext *o = optctx;
2220     return parse_option(o, "tag:s", arg, options);
2221 }
2222
2223 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2224 {
2225     OptionsContext *o = optctx;
2226     return parse_option(o, "filter:v", arg, options);
2227 }
2228
2229 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2230 {
2231     OptionsContext *o = optctx;
2232     return parse_option(o, "filter:a", arg, options);
2233 }
2234
2235 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2236 {
2237     if      (!av_strcasecmp(arg, "cfr"))         video_sync_method = VSYNC_CFR;
2238     else if (!av_strcasecmp(arg, "vfr"))         video_sync_method = VSYNC_VFR;
2239     else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2240
2241     if (video_sync_method == VSYNC_AUTO)
2242         video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
2243     return 0;
2244 }
2245
2246 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2247 {
2248     OptionsContext *o = optctx;
2249     char layout_str[32];
2250     char *stream_str;
2251     char *ac_str;
2252     int ret, channels, ac_str_size;
2253     uint64_t layout;
2254
2255     layout = av_get_channel_layout(arg);
2256     if (!layout) {
2257         av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2258         return AVERROR(EINVAL);
2259     }
2260     snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2261     ret = opt_default(NULL, opt, layout_str);
2262     if (ret < 0)
2263         return ret;
2264
2265     /* set 'ac' option based on channel layout */
2266     channels = av_get_channel_layout_nb_channels(layout);
2267     snprintf(layout_str, sizeof(layout_str), "%d", channels);
2268     stream_str = strchr(opt, ':');
2269     ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2270     ac_str = av_mallocz(ac_str_size);
2271     if (!ac_str)
2272         return AVERROR(ENOMEM);
2273     av_strlcpy(ac_str, "ac", 3);
2274     if (stream_str)
2275         av_strlcat(ac_str, stream_str, ac_str_size);
2276     ret = parse_option(o, ac_str, layout_str, options);
2277     av_free(ac_str);
2278
2279     return ret;
2280 }
2281
2282 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2283 {
2284     OptionsContext *o = optctx;
2285     return parse_option(o, "q:a", arg, options);
2286 }
2287
2288 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2289 {
2290     GROW_ARRAY(filtergraphs, nb_filtergraphs);
2291     if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2292         return AVERROR(ENOMEM);
2293     filtergraphs[nb_filtergraphs - 1]->index      = nb_filtergraphs - 1;
2294     filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
2295     if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
2296         return AVERROR(ENOMEM);
2297     return 0;
2298 }
2299
2300 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
2301 {
2302     uint8_t *graph_desc = read_file(arg);
2303     if (!graph_desc)
2304         return AVERROR(EINVAL);
2305
2306     GROW_ARRAY(filtergraphs, nb_filtergraphs);
2307     if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2308         return AVERROR(ENOMEM);
2309     filtergraphs[nb_filtergraphs - 1]->index      = nb_filtergraphs - 1;
2310     filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
2311     return 0;
2312 }
2313
2314 void show_help_default(const char *opt, const char *arg)
2315 {
2316     /* per-file options have at least one of those set */
2317     const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2318     int show_advanced = 0, show_avoptions = 0;
2319
2320     if (opt && *opt) {
2321         if (!strcmp(opt, "long"))
2322             show_advanced = 1;
2323         else if (!strcmp(opt, "full"))
2324             show_advanced = show_avoptions = 1;
2325         else
2326             av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2327     }
2328
2329     show_usage();
2330
2331     printf("Getting help:\n"
2332            "    -h      -- print basic options\n"
2333            "    -h long -- print more options\n"
2334            "    -h full -- print all options (including all format and codec specific options, very long)\n"
2335            "    -h type=name -- print all options for the named decoder/encoder/demuxer/muxer/filter\n"
2336            "    See man %s for detailed description of the options.\n"
2337            "\n", program_name);
2338
2339     show_help_options(options, "Print help / information / capabilities:",
2340                       OPT_EXIT, 0, 0);
2341
2342     show_help_options(options, "Global options (affect whole program "
2343                       "instead of just one file:",
2344                       0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2345     if (show_advanced)
2346         show_help_options(options, "Advanced global options:", OPT_EXPERT,
2347                           per_file | OPT_EXIT, 0);
2348
2349     show_help_options(options, "Per-file main options:", 0,
2350                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
2351                       OPT_EXIT, per_file);
2352     if (show_advanced)
2353         show_help_options(options, "Advanced per-file options:",
2354                           OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2355
2356     show_help_options(options, "Video options:",
2357                       OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
2358     if (show_advanced)
2359         show_help_options(options, "Advanced Video options:",
2360                           OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2361
2362     show_help_options(options, "Audio options:",
2363                       OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2364     if (show_advanced)
2365         show_help_options(options, "Advanced Audio options:",
2366                           OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2367     show_help_options(options, "Subtitle options:",
2368                       OPT_SUBTITLE, 0, 0);
2369     printf("\n");
2370
2371     if (show_avoptions) {
2372         int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2373         show_help_children(avcodec_get_class(), flags);
2374         show_help_children(avformat_get_class(), flags);
2375         show_help_children(sws_get_class(), flags);
2376         show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM);
2377     }
2378 }
2379
2380 void show_usage(void)
2381 {
2382     printf("Hyper fast Audio and Video encoder\n");
2383     printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2384     printf("\n");
2385 }
2386
2387 enum OptGroup {
2388     GROUP_OUTFILE,
2389     GROUP_INFILE,
2390 };
2391
2392 static const OptionGroupDef groups[] = {
2393     [GROUP_OUTFILE] = { "output file",  NULL, OPT_OUTPUT },
2394     [GROUP_INFILE]  = { "input file",   "i",  OPT_INPUT },
2395 };
2396
2397 static int open_files(OptionGroupList *l, const char *inout,
2398                       int (*open_file)(OptionsContext*, const char*))
2399 {
2400     int i, ret;
2401
2402     for (i = 0; i < l->nb_groups; i++) {
2403         OptionGroup *g = &l->groups[i];
2404         OptionsContext o;
2405
2406         init_options(&o);
2407         o.g = g;
2408
2409         ret = parse_optgroup(&o, g);
2410         if (ret < 0) {
2411             av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
2412                    "%s.\n", inout, g->arg);
2413             return ret;
2414         }
2415
2416         av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
2417         ret = open_file(&o, g->arg);
2418         uninit_options(&o);
2419         if (ret < 0) {
2420             av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
2421                    inout, g->arg);
2422             return ret;
2423         }
2424         av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
2425     }
2426
2427     return 0;
2428 }
2429
2430 int avconv_parse_options(int argc, char **argv)
2431 {
2432     OptionParseContext octx;
2433     uint8_t error[128];
2434     int ret;
2435
2436     memset(&octx, 0, sizeof(octx));
2437
2438     /* split the commandline into an internal representation */
2439     ret = split_commandline(&octx, argc, argv, options, groups,
2440                             FF_ARRAY_ELEMS(groups));
2441     if (ret < 0) {
2442         av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
2443         goto fail;
2444     }
2445
2446     /* apply global options */
2447     ret = parse_optgroup(NULL, &octx.global_opts);
2448     if (ret < 0) {
2449         av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
2450         goto fail;
2451     }
2452
2453     /* open input files */
2454     ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
2455     if (ret < 0) {
2456         av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
2457         goto fail;
2458     }
2459
2460     /* create the complex filtergraphs */
2461     ret = init_complex_filters();
2462     if (ret < 0) {
2463         av_log(NULL, AV_LOG_FATAL, "Error initializing complex filters.\n");
2464         goto fail;
2465     }
2466
2467     /* open output files */
2468     ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
2469     if (ret < 0) {
2470         av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
2471         goto fail;
2472     }
2473
2474     /* configure the complex filtergraphs */
2475     ret = configure_complex_filters();
2476     if (ret < 0) {
2477         av_log(NULL, AV_LOG_FATAL, "Error configuring complex filters.\n");
2478         goto fail;
2479     }
2480
2481 fail:
2482     uninit_parse_context(&octx);
2483     if (ret < 0) {
2484         av_strerror(ret, error, sizeof(error));
2485         av_log(NULL, AV_LOG_FATAL, "%s\n", error);
2486     }
2487     return ret;
2488 }
2489
2490 #define OFFSET(x) offsetof(OptionsContext, x)
2491 const OptionDef options[] = {
2492     /* main options */
2493 #include "cmdutils_common_opts.h"
2494     { "f",              HAS_ARG | OPT_STRING | OPT_OFFSET |
2495                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(format) },
2496         "force format", "fmt" },
2497     { "y",              OPT_BOOL,                                    {              &file_overwrite },
2498         "overwrite output files" },
2499     { "n",              OPT_BOOL,                                    {              &file_skip },
2500         "never overwrite output files" },
2501     { "c",              HAS_ARG | OPT_STRING | OPT_SPEC |
2502                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(codec_names) },
2503         "codec name", "codec" },
2504     { "codec",          HAS_ARG | OPT_STRING | OPT_SPEC |
2505                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(codec_names) },
2506         "codec name", "codec" },
2507     { "pre",            HAS_ARG | OPT_STRING | OPT_SPEC |
2508                         OPT_OUTPUT,                                  { .off       = OFFSET(presets) },
2509         "preset name", "preset" },
2510     { "map",            HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2511                         OPT_OUTPUT,                                  { .func_arg = opt_map },
2512         "set input stream mapping",
2513         "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
2514     { "map_metadata",   HAS_ARG | OPT_STRING | OPT_SPEC |
2515                         OPT_OUTPUT,                                  { .off       = OFFSET(metadata_map) },
2516         "set metadata information of outfile from infile",
2517         "outfile[,metadata]:infile[,metadata]" },
2518     { "map_chapters",   HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
2519                         OPT_OUTPUT,                                  { .off = OFFSET(chapters_input_file) },
2520         "set chapters mapping", "input_file_index" },
2521     { "t",              HAS_ARG | OPT_TIME | OPT_OFFSET |
2522                         OPT_INPUT | OPT_OUTPUT,                      { .off = OFFSET(recording_time) },
2523         "record or transcode \"duration\" seconds of audio/video",
2524         "duration" },
2525     { "fs",             HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
2526         "set the limit file size in bytes", "limit_size" },
2527     { "ss",             HAS_ARG | OPT_TIME | OPT_OFFSET |
2528                         OPT_INPUT | OPT_OUTPUT,                      { .off = OFFSET(start_time) },
2529         "set the start time offset", "time_off" },
2530     { "accurate_seek",  OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
2531                         OPT_INPUT,                                   { .off = OFFSET(accurate_seek) },
2532         "enable/disable accurate seeking with -ss" },
2533     { "itsoffset",      HAS_ARG | OPT_TIME | OPT_OFFSET |
2534                         OPT_EXPERT | OPT_INPUT,                      { .off = OFFSET(input_ts_offset) },
2535         "set the input ts offset", "time_off" },
2536     { "itsscale",       HAS_ARG | OPT_DOUBLE | OPT_SPEC |
2537                         OPT_EXPERT | OPT_INPUT,                      { .off = OFFSET(ts_scale) },
2538         "set the input ts scale", "scale" },
2539     { "metadata",       HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
2540         "add metadata", "string=string" },
2541     { "dframes",        HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2542                         OPT_OUTPUT,                                  { .func_arg = opt_data_frames },
2543         "set the number of data frames to record", "number" },
2544     { "benchmark",      OPT_BOOL | OPT_EXPERT,                       { &do_benchmark },
2545         "add timings for benchmarking" },
2546     { "timelimit",      HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_timelimit },
2547         "set max runtime in seconds", "limit" },
2548     { "dump",           OPT_BOOL | OPT_EXPERT,                       { &do_pkt_dump },
2549         "dump each input packet" },
2550     { "hex",            OPT_BOOL | OPT_EXPERT,                       { &do_hex_dump },
2551         "when dumping packets, also dump the payload" },
2552     { "re",             OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2553                         OPT_INPUT,                                   { .off = OFFSET(rate_emu) },
2554         "read input at native frame rate", "" },
2555     { "target",         HAS_ARG | OPT_PERFILE | OPT_OUTPUT,          { .func_arg = opt_target },
2556         "specify target file type (\"vcd\", \"svcd\", \"dvd\","
2557         " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2558     { "vsync",          HAS_ARG | OPT_EXPERT,                        { opt_vsync },
2559         "video sync method", "" },
2560     { "async",          HAS_ARG | OPT_INT | OPT_EXPERT,              { &audio_sync_method },
2561         "audio sync method", "" },
2562     { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,          { &audio_drift_threshold },
2563         "audio drift threshold", "threshold" },
2564     { "copyts",         OPT_BOOL | OPT_EXPERT,                       { &copy_ts },
2565         "copy timestamps" },
2566     { "copytb",         OPT_BOOL | OPT_EXPERT,                       { &copy_tb },
2567         "copy input stream time base when stream copying" },
2568     { "shortest",       OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2569                         OPT_OUTPUT,                                  { .off = OFFSET(shortest) },
2570         "finish encoding within shortest input" },
2571     { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,       { &dts_delta_threshold },
2572         "timestamp discontinuity delta threshold", "threshold" },
2573     { "xerror",         OPT_BOOL | OPT_EXPERT,                       { &exit_on_error },
2574         "exit on error", "error" },
2575     { "copyinkf",       OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2576                         OPT_OUTPUT,                                  { .off = OFFSET(copy_initial_nonkeyframes) },
2577         "copy initial non-keyframes" },
2578     { "frames",         OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
2579         "set the number of frames to record", "number" },
2580     { "tag",            OPT_STRING | HAS_ARG | OPT_SPEC |
2581                         OPT_EXPERT | OPT_OUTPUT | OPT_INPUT,         { .off = OFFSET(codec_tags) },
2582         "force codec tag/fourcc", "fourcc/tag" },
2583     { "q",              HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
2584                         OPT_SPEC | OPT_OUTPUT,                       { .off = OFFSET(qscale) },
2585         "use fixed quality scale (VBR)", "q" },
2586     { "qscale",         HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
2587                         OPT_SPEC | OPT_OUTPUT,                       { .off = OFFSET(qscale) },
2588         "use fixed quality scale (VBR)", "q" },
2589     { "filter",         HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
2590         "set stream filterchain", "filter_list" },
2591     { "filter_script",  HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
2592         "read stream filtergraph description from a file", "filename" },
2593     { "filter_complex", HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_filter_complex },
2594         "create a complex filtergraph", "graph_description" },
2595     { "filter_complex_script", HAS_ARG | OPT_EXPERT,                 { .func_arg = opt_filter_complex_script },
2596         "read complex filtergraph description from a file", "filename" },
2597     { "stats",          OPT_BOOL,                                    { &print_stats },
2598         "print progress report during encoding", },
2599     { "attach",         HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2600                         OPT_OUTPUT,                                  { .func_arg = opt_attach },
2601         "add an attachment to the output file", "filename" },
2602     { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
2603                          OPT_EXPERT | OPT_INPUT,                     { .off = OFFSET(dump_attachment) },
2604         "extract an attachment into a file", "filename" },
2605     { "loop", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_INPUT |
2606                         OPT_OFFSET,                                  { .off = OFFSET(loop) }, "set number of times input stream shall be looped", "loop count" },
2607
2608     /* video options */
2609     { "vframes",      OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_video_frames },
2610         "set the number of video frames to record", "number" },
2611     { "r",            OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC |
2612                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_rates) },
2613         "set frame rate (Hz value, fraction or abbreviation)", "rate" },
2614     { "s",            OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC |
2615                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_sizes) },
2616         "set frame size (WxH or abbreviation)", "size" },
2617     { "aspect",       OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC |
2618                       OPT_OUTPUT,                                                { .off = OFFSET(frame_aspect_ratios) },
2619         "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
2620     { "pix_fmt",      OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
2621                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_pix_fmts) },
2622         "set pixel format", "format" },
2623     { "vn",           OPT_VIDEO | OPT_BOOL  | OPT_OFFSET | OPT_OUTPUT,           { .off = OFFSET(video_disable) },
2624         "disable video" },
2625     { "vdt",          OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT ,               { &video_discard },
2626         "discard threshold", "n" },
2627     { "rc_override",  OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
2628                       OPT_OUTPUT,                                                { .off = OFFSET(rc_overrides) },
2629         "rate control override for specific intervals", "override" },
2630     { "vcodec",       OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_INPUT |
2631                       OPT_OUTPUT,                                                { .func_arg = opt_video_codec },
2632         "force video codec ('copy' to copy stream)", "codec" },
2633     { "pass",         OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT,     { .off = OFFSET(pass) },
2634         "select the pass number (1 or 2)", "n" },
2635     { "passlogfile",  OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
2636                       OPT_OUTPUT,                                                { .off = OFFSET(passlogfiles) },
2637         "select two pass log file name prefix", "prefix" },
2638     { "vstats",       OPT_VIDEO | OPT_EXPERT ,                                   { &opt_vstats },
2639         "dump video coding statistics to file" },
2640     { "vstats_file",  OPT_VIDEO | HAS_ARG | OPT_EXPERT ,                         { opt_vstats_file },
2641         "dump video coding statistics to file", "file" },
2642     { "vf",           OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_video_filters },
2643         "video filters", "filter list" },
2644     { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
2645                       OPT_OUTPUT,                                                { .off = OFFSET(intra_matrices) },
2646         "specify intra matrix coeffs", "matrix" },
2647     { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
2648                       OPT_OUTPUT,                                                { .off = OFFSET(inter_matrices) },
2649         "specify inter matrix coeffs", "matrix" },
2650     { "top",          OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_INT| OPT_SPEC |
2651                       OPT_OUTPUT,                                                { .off = OFFSET(top_field_first) },
2652         "top=1/bottom=0/auto=-1 field first", "" },
2653     { "dc",           OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT ,               { &intra_dc_precision },
2654         "intra_dc_precision", "precision" },
2655     { "vtag",         OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_PERFILE |
2656                       OPT_OUTPUT,                                                { .func_arg = opt_video_tag },
2657         "force video tag/fourcc", "fourcc/tag" },
2658     { "qphist",       OPT_VIDEO | OPT_BOOL | OPT_EXPERT ,                        { &qp_hist },
2659         "show QP histogram" },
2660     { "force_fps",    OPT_VIDEO | OPT_BOOL | OPT_EXPERT  | OPT_SPEC |
2661                       OPT_OUTPUT,                                                { .off = OFFSET(force_fps) },
2662         "force the selected framerate, disable the best supported framerate selection" },
2663     { "streamid",     OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2664                       OPT_OUTPUT,                                                { .func_arg = opt_streamid },
2665         "set the value of an outfile streamid", "streamIndex:value" },
2666     { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2667                           OPT_SPEC | OPT_OUTPUT,                                 { .off = OFFSET(forced_key_frames) },
2668         "force key frames at specified timestamps", "timestamps" },
2669     { "hwaccel",          OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2670                           OPT_SPEC | OPT_INPUT,                                  { .off = OFFSET(hwaccels) },
2671         "use HW accelerated decoding", "hwaccel name" },
2672     { "hwaccel_device",   OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2673                           OPT_SPEC | OPT_INPUT,                                  { .off = OFFSET(hwaccel_devices) },
2674         "select a device for HW acceleration", "devicename" },
2675     { "hwaccel_output_format", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2676                           OPT_SPEC | OPT_INPUT,                                  { .off = OFFSET(hwaccel_output_formats) },
2677         "select output format used with HW accelerated decoding", "format" },
2678
2679     { "hwaccels",         OPT_EXIT,                                              { .func_arg = show_hwaccels },
2680         "show available HW acceleration methods" },
2681     { "autorotate",       HAS_ARG | OPT_BOOL | OPT_SPEC |
2682                           OPT_EXPERT | OPT_INPUT,                                { .off = OFFSET(autorotate) },
2683         "automatically insert correct rotate filters" },
2684     { "hwaccel_lax_profile_check", OPT_BOOL | OPT_EXPERT,                        { &hwaccel_lax_profile_check},
2685         "attempt to decode anyway if HW accelerated decoder's supported profiles do not exactly match the stream" },
2686
2687     /* audio options */
2688     { "aframes",        OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_frames },
2689         "set the number of audio frames to record", "number" },
2690     { "aq",             OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_qscale },
2691         "set audio quality (codec-specific)", "quality", },
2692     { "ar",             OPT_AUDIO | HAS_ARG  | OPT_INT | OPT_SPEC |
2693                         OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(audio_sample_rate) },
2694         "set audio sampling rate (in Hz)", "rate" },
2695     { "ac",             OPT_AUDIO | HAS_ARG  | OPT_INT | OPT_SPEC |
2696                         OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(audio_channels) },
2697         "set number of audio channels", "channels" },
2698     { "an",             OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_OUTPUT,            { .off = OFFSET(audio_disable) },
2699         "disable audio" },
2700     { "acodec",         OPT_AUDIO | HAS_ARG  | OPT_PERFILE |
2701                         OPT_INPUT | OPT_OUTPUT,                                    { .func_arg = opt_audio_codec },
2702         "force audio codec ('copy' to copy stream)", "codec" },
2703     { "atag",           OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_PERFILE |
2704                         OPT_OUTPUT,                                                { .func_arg = opt_audio_tag },
2705         "force audio tag/fourcc", "fourcc/tag" },
2706     { "vol",            OPT_AUDIO | HAS_ARG  | OPT_INT,                            { &audio_volume },
2707         "change audio volume (256=normal)" , "volume" },
2708     { "sample_fmt",     OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_SPEC |
2709                         OPT_STRING | OPT_INPUT | OPT_OUTPUT,                       { .off = OFFSET(sample_fmts) },
2710         "set sample format", "format" },
2711     { "channel_layout", OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_PERFILE |
2712                         OPT_INPUT | OPT_OUTPUT,                                    { .func_arg = opt_channel_layout },
2713         "set channel layout", "layout" },
2714     { "af",             OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_filters },
2715         "audio filters", "filter list" },
2716
2717     /* subtitle options */
2718     { "sn",     OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
2719         "disable subtitle" },
2720     { "scodec", OPT_SUBTITLE | HAS_ARG  | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
2721         "force subtitle codec ('copy' to copy stream)", "codec" },
2722     { "stag",   OPT_SUBTITLE | HAS_ARG  | OPT_EXPERT  | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_subtitle_tag }
2723         , "force subtitle tag/fourcc", "fourcc/tag" },
2724
2725     /* grab options */
2726     { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
2727
2728     /* muxer options */
2729     { "muxdelay",   OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
2730         "set the maximum demux-decode delay", "seconds" },
2731     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
2732         "set the initial demux-decode delay", "seconds" },
2733
2734     { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
2735         "A comma-separated list of bitstream filters", "bitstream_filters" },
2736
2737     { "max_muxing_queue_size", HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(max_muxing_queue_size) },
2738         "maximum number of packets that can be buffered while waiting for all streams to initialize", "packets" },
2739
2740     /* data codec support */
2741     { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
2742         "force data codec ('copy' to copy stream)", "codec" },
2743
2744 #if CONFIG_VAAPI
2745     { "vaapi_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vaapi_device },
2746         "set VAAPI hardware device (DRM path or X11 display name)", "device" },
2747 #endif
2748
2749     { NULL, },
2750 };