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