f4ff1605f07890f029b2068a32ce890dbaea4f41
[ffmpeg.git] / fftools / ffmpeg_opt.c
1 /*
2  * ffmpeg option parsing
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg 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  * FFmpeg 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 FFmpeg; 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 "ffmpeg.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 "ffmpeg2pass"
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 #define MATCH_PER_TYPE_OPT(name, type, outvar, fmtctx, mediatype)\
59 {\
60     int i;\
61     for (i = 0; i < o->nb_ ## name; i++) {\
62         char *spec = o->name[i].specifier;\
63         if (!strcmp(spec, mediatype))\
64             outvar = o->name[i].u.type;\
65     }\
66 }
67
68 const HWAccel hwaccels[] = {
69 #if HAVE_VDPAU_X11
70     { "vdpau", hwaccel_decode_init, HWACCEL_VDPAU, AV_PIX_FMT_VDPAU,
71       AV_HWDEVICE_TYPE_VDPAU },
72 #endif
73 #if CONFIG_D3D11VA
74     { "d3d11va", hwaccel_decode_init, HWACCEL_D3D11VA, AV_PIX_FMT_D3D11,
75       AV_HWDEVICE_TYPE_D3D11VA },
76 #endif
77 #if CONFIG_DXVA2
78     { "dxva2", hwaccel_decode_init, HWACCEL_DXVA2, AV_PIX_FMT_DXVA2_VLD,
79       AV_HWDEVICE_TYPE_DXVA2 },
80 #endif
81 #if CONFIG_VIDEOTOOLBOX
82     { "videotoolbox",   videotoolbox_init,   HWACCEL_VIDEOTOOLBOX,   AV_PIX_FMT_VIDEOTOOLBOX,
83       AV_HWDEVICE_TYPE_NONE },
84 #endif
85 #if CONFIG_LIBMFX
86     { "qsv",   qsv_init,   HWACCEL_QSV,   AV_PIX_FMT_QSV,
87       AV_HWDEVICE_TYPE_NONE },
88 #endif
89 #if CONFIG_VAAPI
90     { "vaapi", hwaccel_decode_init, HWACCEL_VAAPI, AV_PIX_FMT_VAAPI,
91       AV_HWDEVICE_TYPE_VAAPI },
92 #endif
93 #if CONFIG_CUVID
94     { "cuvid", cuvid_init, HWACCEL_CUVID, AV_PIX_FMT_CUDA,
95       AV_HWDEVICE_TYPE_NONE },
96 #endif
97     { 0 },
98 };
99 AVBufferRef *hw_device_ctx;
100 HWDevice *filter_hw_device;
101
102 char *vstats_filename;
103 char *sdp_filename;
104
105 float audio_drift_threshold = 0.1;
106 float dts_delta_threshold   = 10;
107 float dts_error_threshold   = 3600*30;
108
109 int audio_volume      = 256;
110 int audio_sync_method = 0;
111 int video_sync_method = VSYNC_AUTO;
112 float frame_drop_threshold = 0;
113 int do_deinterlace    = 0;
114 int do_benchmark      = 0;
115 int do_benchmark_all  = 0;
116 int do_hex_dump       = 0;
117 int do_pkt_dump       = 0;
118 int copy_ts           = 0;
119 int start_at_zero     = 0;
120 int copy_tb           = -1;
121 int debug_ts          = 0;
122 int exit_on_error     = 0;
123 int abort_on_flags    = 0;
124 int print_stats       = -1;
125 int qp_hist           = 0;
126 int stdin_interaction = 1;
127 int frame_bits_per_raw_sample = 0;
128 float max_error_rate  = 2.0/3;
129 int filter_nbthreads = 0;
130 int filter_complex_nbthreads = 0;
131 int vstats_version = 2;
132
133
134 static int intra_only         = 0;
135 static int file_overwrite     = 0;
136 static int no_file_overwrite  = 0;
137 static int do_psnr            = 0;
138 static int input_sync;
139 static int override_ffserver  = 0;
140 static int input_stream_potentially_available = 0;
141 static int ignore_unknown_streams = 0;
142 static int copy_unknown_streams = 0;
143 static int find_stream_info = 1;
144
145 static void uninit_options(OptionsContext *o)
146 {
147     const OptionDef *po = options;
148     int i;
149
150     /* all OPT_SPEC and OPT_STRING can be freed in generic way */
151     while (po->name) {
152         void *dst = (uint8_t*)o + po->u.off;
153
154         if (po->flags & OPT_SPEC) {
155             SpecifierOpt **so = dst;
156             int i, *count = (int*)(so + 1);
157             for (i = 0; i < *count; i++) {
158                 av_freep(&(*so)[i].specifier);
159                 if (po->flags & OPT_STRING)
160                     av_freep(&(*so)[i].u.str);
161             }
162             av_freep(so);
163             *count = 0;
164         } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
165             av_freep(dst);
166         po++;
167     }
168
169     for (i = 0; i < o->nb_stream_maps; i++)
170         av_freep(&o->stream_maps[i].linklabel);
171     av_freep(&o->stream_maps);
172     av_freep(&o->audio_channel_maps);
173     av_freep(&o->streamid_map);
174     av_freep(&o->attachments);
175 }
176
177 static void init_options(OptionsContext *o)
178 {
179     memset(o, 0, sizeof(*o));
180
181     o->stop_time = INT64_MAX;
182     o->mux_max_delay  = 0.7;
183     o->start_time     = AV_NOPTS_VALUE;
184     o->start_time_eof = AV_NOPTS_VALUE;
185     o->recording_time = INT64_MAX;
186     o->limit_filesize = UINT64_MAX;
187     o->chapters_input_file = INT_MAX;
188     o->accurate_seek  = 1;
189 }
190
191 static int show_hwaccels(void *optctx, const char *opt, const char *arg)
192 {
193     int i;
194
195     printf("Hardware acceleration methods:\n");
196     for (i = 0; hwaccels[i].name; i++) {
197         printf("%s\n", hwaccels[i].name);
198     }
199     printf("\n");
200     return 0;
201 }
202
203 /* return a copy of the input with the stream specifiers removed from the keys */
204 static AVDictionary *strip_specifiers(AVDictionary *dict)
205 {
206     AVDictionaryEntry *e = NULL;
207     AVDictionary    *ret = NULL;
208
209     while ((e = av_dict_get(dict, "", e, AV_DICT_IGNORE_SUFFIX))) {
210         char *p = strchr(e->key, ':');
211
212         if (p)
213             *p = 0;
214         av_dict_set(&ret, e->key, e->value, 0);
215         if (p)
216             *p = ':';
217     }
218     return ret;
219 }
220
221 static int opt_abort_on(void *optctx, const char *opt, const char *arg)
222 {
223     static const AVOption opts[] = {
224         { "abort_on"        , NULL, 0, AV_OPT_TYPE_FLAGS, { .i64 = 0 }, INT64_MIN, INT64_MAX, .unit = "flags" },
225         { "empty_output"    , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = ABORT_ON_FLAG_EMPTY_OUTPUT     },    .unit = "flags" },
226         { NULL },
227     };
228     static const AVClass class = {
229         .class_name = "",
230         .item_name  = av_default_item_name,
231         .option     = opts,
232         .version    = LIBAVUTIL_VERSION_INT,
233     };
234     const AVClass *pclass = &class;
235
236     return av_opt_eval_flags(&pclass, &opts[0], arg, &abort_on_flags);
237 }
238
239 static int opt_sameq(void *optctx, const char *opt, const char *arg)
240 {
241     av_log(NULL, AV_LOG_ERROR, "Option '%s' was removed. "
242            "If you are looking for an option to preserve the quality (which is not "
243            "what -%s was for), use -qscale 0 or an equivalent quality factor option.\n",
244            opt, opt);
245     return AVERROR(EINVAL);
246 }
247
248 static int opt_video_channel(void *optctx, const char *opt, const char *arg)
249 {
250     av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
251     return opt_default(optctx, "channel", arg);
252 }
253
254 static int opt_video_standard(void *optctx, const char *opt, const char *arg)
255 {
256     av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
257     return opt_default(optctx, "standard", arg);
258 }
259
260 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
261 {
262     OptionsContext *o = optctx;
263     return parse_option(o, "codec:a", arg, options);
264 }
265
266 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
267 {
268     OptionsContext *o = optctx;
269     return parse_option(o, "codec:v", arg, options);
270 }
271
272 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
273 {
274     OptionsContext *o = optctx;
275     return parse_option(o, "codec:s", arg, options);
276 }
277
278 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
279 {
280     OptionsContext *o = optctx;
281     return parse_option(o, "codec:d", arg, options);
282 }
283
284 static int opt_map(void *optctx, const char *opt, const char *arg)
285 {
286     OptionsContext *o = optctx;
287     StreamMap *m = NULL;
288     int i, negative = 0, file_idx;
289     int sync_file_idx = -1, sync_stream_idx = 0;
290     char *p, *sync;
291     char *map;
292     char *allow_unused;
293
294     if (*arg == '-') {
295         negative = 1;
296         arg++;
297     }
298     map = av_strdup(arg);
299     if (!map)
300         return AVERROR(ENOMEM);
301
302     /* parse sync stream first, just pick first matching stream */
303     if (sync = strchr(map, ',')) {
304         *sync = 0;
305         sync_file_idx = strtol(sync + 1, &sync, 0);
306         if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
307             av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
308             exit_program(1);
309         }
310         if (*sync)
311             sync++;
312         for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
313             if (check_stream_specifier(input_files[sync_file_idx]->ctx,
314                                        input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
315                 sync_stream_idx = i;
316                 break;
317             }
318         if (i == input_files[sync_file_idx]->nb_streams) {
319             av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
320                                        "match any streams.\n", arg);
321             exit_program(1);
322         }
323     }
324
325
326     if (map[0] == '[') {
327         /* this mapping refers to lavfi output */
328         const char *c = map + 1;
329         GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
330         m = &o->stream_maps[o->nb_stream_maps - 1];
331         m->linklabel = av_get_token(&c, "]");
332         if (!m->linklabel) {
333             av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
334             exit_program(1);
335         }
336     } else {
337         if (allow_unused = strchr(map, '?'))
338             *allow_unused = 0;
339         file_idx = strtol(map, &p, 0);
340         if (file_idx >= nb_input_files || file_idx < 0) {
341             av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
342             exit_program(1);
343         }
344         if (negative)
345             /* disable some already defined maps */
346             for (i = 0; i < o->nb_stream_maps; i++) {
347                 m = &o->stream_maps[i];
348                 if (file_idx == m->file_index &&
349                     check_stream_specifier(input_files[m->file_index]->ctx,
350                                            input_files[m->file_index]->ctx->streams[m->stream_index],
351                                            *p == ':' ? p + 1 : p) > 0)
352                     m->disabled = 1;
353             }
354         else
355             for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
356                 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
357                             *p == ':' ? p + 1 : p) <= 0)
358                     continue;
359                 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
360                 m = &o->stream_maps[o->nb_stream_maps - 1];
361
362                 m->file_index   = file_idx;
363                 m->stream_index = i;
364
365                 if (sync_file_idx >= 0) {
366                     m->sync_file_index   = sync_file_idx;
367                     m->sync_stream_index = sync_stream_idx;
368                 } else {
369                     m->sync_file_index   = file_idx;
370                     m->sync_stream_index = i;
371                 }
372             }
373     }
374
375     if (!m) {
376         if (allow_unused) {
377             av_log(NULL, AV_LOG_VERBOSE, "Stream map '%s' matches no streams; ignoring.\n", arg);
378         } else {
379             av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n"
380                                        "To ignore this, add a trailing '?' to the map.\n", arg);
381             exit_program(1);
382         }
383     }
384
385     av_freep(&map);
386     return 0;
387 }
388
389 static int opt_attach(void *optctx, const char *opt, const char *arg)
390 {
391     OptionsContext *o = optctx;
392     GROW_ARRAY(o->attachments, o->nb_attachments);
393     o->attachments[o->nb_attachments - 1] = arg;
394     return 0;
395 }
396
397 static int opt_map_channel(void *optctx, const char *opt, const char *arg)
398 {
399     OptionsContext *o = optctx;
400     int n;
401     AVStream *st;
402     AudioChannelMap *m;
403     char *allow_unused;
404     char *mapchan;
405     mapchan = av_strdup(arg);
406     if (!mapchan)
407         return AVERROR(ENOMEM);
408
409     GROW_ARRAY(o->audio_channel_maps, o->nb_audio_channel_maps);
410     m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];
411
412     /* muted channel syntax */
413     n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
414     if ((n == 1 || n == 3) && m->channel_idx == -1) {
415         m->file_idx = m->stream_idx = -1;
416         if (n == 1)
417             m->ofile_idx = m->ostream_idx = -1;
418         av_free(mapchan);
419         return 0;
420     }
421
422     /* normal syntax */
423     n = sscanf(arg, "%d.%d.%d:%d.%d",
424                &m->file_idx,  &m->stream_idx, &m->channel_idx,
425                &m->ofile_idx, &m->ostream_idx);
426
427     if (n != 3 && n != 5) {
428         av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
429                "[file.stream.channel|-1][:syncfile:syncstream]\n");
430         exit_program(1);
431     }
432
433     if (n != 5) // only file.stream.channel specified
434         m->ofile_idx = m->ostream_idx = -1;
435
436     /* check input */
437     if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
438         av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
439                m->file_idx);
440         exit_program(1);
441     }
442     if (m->stream_idx < 0 ||
443         m->stream_idx >= input_files[m->file_idx]->nb_streams) {
444         av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
445                m->file_idx, m->stream_idx);
446         exit_program(1);
447     }
448     st = input_files[m->file_idx]->ctx->streams[m->stream_idx];
449     if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO) {
450         av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
451                m->file_idx, m->stream_idx);
452         exit_program(1);
453     }
454     /* allow trailing ? to map_channel */
455     if (allow_unused = strchr(mapchan, '?'))
456         *allow_unused = 0;
457     if (m->channel_idx < 0 || m->channel_idx >= st->codecpar->channels) {
458         if (allow_unused) {
459             av_log(NULL, AV_LOG_VERBOSE, "mapchan: invalid audio channel #%d.%d.%d\n",
460                     m->file_idx, m->stream_idx, m->channel_idx);
461         } else {
462             av_log(NULL, AV_LOG_FATAL,  "mapchan: invalid audio channel #%d.%d.%d\n"
463                     "To ignore this, add a trailing '?' to the map_channel.\n",
464                     m->file_idx, m->stream_idx, m->channel_idx);
465             exit_program(1);
466         }
467
468     }
469     av_free(mapchan);
470     return 0;
471 }
472
473 static int opt_sdp_file(void *optctx, const char *opt, const char *arg)
474 {
475     av_free(sdp_filename);
476     sdp_filename = av_strdup(arg);
477     return 0;
478 }
479
480 #if CONFIG_VAAPI
481 static int opt_vaapi_device(void *optctx, const char *opt, const char *arg)
482 {
483     HWDevice *dev;
484     const char *prefix = "vaapi:";
485     char *tmp;
486     int err;
487     tmp = av_asprintf("%s%s", prefix, arg);
488     if (!tmp)
489         return AVERROR(ENOMEM);
490     err = hw_device_init_from_string(tmp, &dev);
491     av_free(tmp);
492     if (err < 0)
493         return err;
494     hw_device_ctx = av_buffer_ref(dev->device_ref);
495     if (!hw_device_ctx)
496         return AVERROR(ENOMEM);
497     return 0;
498 }
499 #endif
500
501 static int opt_init_hw_device(void *optctx, const char *opt, const char *arg)
502 {
503     if (!strcmp(arg, "list")) {
504         enum AVHWDeviceType type = AV_HWDEVICE_TYPE_NONE;
505         printf("Supported hardware device types:\n");
506         while ((type = av_hwdevice_iterate_types(type)) !=
507                AV_HWDEVICE_TYPE_NONE)
508             printf("%s\n", av_hwdevice_get_type_name(type));
509         printf("\n");
510         exit_program(0);
511     } else {
512         return hw_device_init_from_string(arg, NULL);
513     }
514 }
515
516 static int opt_filter_hw_device(void *optctx, const char *opt, const char *arg)
517 {
518     if (filter_hw_device) {
519         av_log(NULL, AV_LOG_ERROR, "Only one filter device can be used.\n");
520         return AVERROR(EINVAL);
521     }
522     filter_hw_device = hw_device_get_by_name(arg);
523     if (!filter_hw_device) {
524         av_log(NULL, AV_LOG_ERROR, "Invalid filter device %s.\n", arg);
525         return AVERROR(EINVAL);
526     }
527     return 0;
528 }
529
530 /**
531  * Parse a metadata specifier passed as 'arg' parameter.
532  * @param arg  metadata string to parse
533  * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
534  * @param index for type c/p, chapter/program index is written here
535  * @param stream_spec for type s, the stream specifier is written here
536  */
537 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
538 {
539     if (*arg) {
540         *type = *arg;
541         switch (*arg) {
542         case 'g':
543             break;
544         case 's':
545             if (*(++arg) && *arg != ':') {
546                 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
547                 exit_program(1);
548             }
549             *stream_spec = *arg == ':' ? arg + 1 : "";
550             break;
551         case 'c':
552         case 'p':
553             if (*(++arg) == ':')
554                 *index = strtol(++arg, NULL, 0);
555             break;
556         default:
557             av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
558             exit_program(1);
559         }
560     } else
561         *type = 'g';
562 }
563
564 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
565 {
566     AVDictionary **meta_in = NULL;
567     AVDictionary **meta_out = NULL;
568     int i, ret = 0;
569     char type_in, type_out;
570     const char *istream_spec = NULL, *ostream_spec = NULL;
571     int idx_in = 0, idx_out = 0;
572
573     parse_meta_type(inspec,  &type_in,  &idx_in,  &istream_spec);
574     parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
575
576     if (!ic) {
577         if (type_out == 'g' || !*outspec)
578             o->metadata_global_manual = 1;
579         if (type_out == 's' || !*outspec)
580             o->metadata_streams_manual = 1;
581         if (type_out == 'c' || !*outspec)
582             o->metadata_chapters_manual = 1;
583         return 0;
584     }
585
586     if (type_in == 'g' || type_out == 'g')
587         o->metadata_global_manual = 1;
588     if (type_in == 's' || type_out == 's')
589         o->metadata_streams_manual = 1;
590     if (type_in == 'c' || type_out == 'c')
591         o->metadata_chapters_manual = 1;
592
593     /* ic is NULL when just disabling automatic mappings */
594     if (!ic)
595         return 0;
596
597 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
598     if ((index) < 0 || (index) >= (nb_elems)) {\
599         av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
600                 (desc), (index));\
601         exit_program(1);\
602     }
603
604 #define SET_DICT(type, meta, context, index)\
605         switch (type) {\
606         case 'g':\
607             meta = &context->metadata;\
608             break;\
609         case 'c':\
610             METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
611             meta = &context->chapters[index]->metadata;\
612             break;\
613         case 'p':\
614             METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
615             meta = &context->programs[index]->metadata;\
616             break;\
617         case 's':\
618             break; /* handled separately below */ \
619         default: av_assert0(0);\
620         }\
621
622     SET_DICT(type_in, meta_in, ic, idx_in);
623     SET_DICT(type_out, meta_out, oc, idx_out);
624
625     /* for input streams choose first matching stream */
626     if (type_in == 's') {
627         for (i = 0; i < ic->nb_streams; i++) {
628             if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
629                 meta_in = &ic->streams[i]->metadata;
630                 break;
631             } else if (ret < 0)
632                 exit_program(1);
633         }
634         if (!meta_in) {
635             av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match  any streams.\n", istream_spec);
636             exit_program(1);
637         }
638     }
639
640     if (type_out == 's') {
641         for (i = 0; i < oc->nb_streams; i++) {
642             if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
643                 meta_out = &oc->streams[i]->metadata;
644                 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
645             } else if (ret < 0)
646                 exit_program(1);
647         }
648     } else
649         av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
650
651     return 0;
652 }
653
654 static int opt_recording_timestamp(void *optctx, const char *opt, const char *arg)
655 {
656     OptionsContext *o = optctx;
657     char buf[128];
658     int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
659     struct tm time = *gmtime((time_t*)&recording_timestamp);
660     if (!strftime(buf, sizeof(buf), "creation_time=%Y-%m-%dT%H:%M:%S%z", &time))
661         return -1;
662     parse_option(o, "metadata", buf, options);
663
664     av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
665                                  "tag instead.\n", opt);
666     return 0;
667 }
668
669 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
670 {
671     const AVCodecDescriptor *desc;
672     const char *codec_string = encoder ? "encoder" : "decoder";
673     AVCodec *codec;
674
675     codec = encoder ?
676         avcodec_find_encoder_by_name(name) :
677         avcodec_find_decoder_by_name(name);
678
679     if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
680         codec = encoder ? avcodec_find_encoder(desc->id) :
681                           avcodec_find_decoder(desc->id);
682         if (codec)
683             av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
684                    codec_string, codec->name, desc->name);
685     }
686
687     if (!codec) {
688         av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
689         exit_program(1);
690     }
691     if (codec->type != type) {
692         av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
693         exit_program(1);
694     }
695     return codec;
696 }
697
698 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
699 {
700     char *codec_name = NULL;
701
702     MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
703     if (codec_name) {
704         AVCodec *codec = find_codec_or_die(codec_name, st->codecpar->codec_type, 0);
705         st->codecpar->codec_id = codec->id;
706         return codec;
707     } else
708         return avcodec_find_decoder(st->codecpar->codec_id);
709 }
710
711 /* Add all the streams from the given input file to the global
712  * list of input streams. */
713 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
714 {
715     int i, ret;
716
717     for (i = 0; i < ic->nb_streams; i++) {
718         AVStream *st = ic->streams[i];
719         AVCodecParameters *par = st->codecpar;
720         InputStream *ist = av_mallocz(sizeof(*ist));
721         char *framerate = NULL, *hwaccel = NULL, *hwaccel_device = NULL;
722         char *hwaccel_output_format = NULL;
723         char *codec_tag = NULL;
724         char *next;
725         char *discard_str = NULL;
726         const AVClass *cc = avcodec_get_class();
727         const AVOption *discard_opt = av_opt_find(&cc, "skip_frame", NULL, 0, 0);
728
729         if (!ist)
730             exit_program(1);
731
732         GROW_ARRAY(input_streams, nb_input_streams);
733         input_streams[nb_input_streams - 1] = ist;
734
735         ist->st = st;
736         ist->file_index = nb_input_files;
737         ist->discard = 1;
738         st->discard  = AVDISCARD_ALL;
739         ist->nb_samples = 0;
740         ist->min_pts = INT64_MAX;
741         ist->max_pts = INT64_MIN;
742
743         ist->ts_scale = 1.0;
744         MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
745
746         ist->autorotate = 1;
747         MATCH_PER_STREAM_OPT(autorotate, i, ist->autorotate, ic, st);
748
749         MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
750         if (codec_tag) {
751             uint32_t tag = strtol(codec_tag, &next, 0);
752             if (*next)
753                 tag = AV_RL32(codec_tag);
754             st->codecpar->codec_tag = tag;
755         }
756
757         ist->dec = choose_decoder(o, ic, st);
758         ist->decoder_opts = filter_codec_opts(o->g->codec_opts, ist->st->codecpar->codec_id, ic, st, ist->dec);
759
760         ist->reinit_filters = -1;
761         MATCH_PER_STREAM_OPT(reinit_filters, i, ist->reinit_filters, ic, st);
762
763         MATCH_PER_STREAM_OPT(discard, str, discard_str, ic, st);
764         ist->user_set_discard = AVDISCARD_NONE;
765         if (discard_str && av_opt_eval_int(&cc, discard_opt, discard_str, &ist->user_set_discard) < 0) {
766             av_log(NULL, AV_LOG_ERROR, "Error parsing discard %s.\n",
767                     discard_str);
768             exit_program(1);
769         }
770
771         ist->filter_in_rescale_delta_last = AV_NOPTS_VALUE;
772
773         ist->dec_ctx = avcodec_alloc_context3(ist->dec);
774         if (!ist->dec_ctx) {
775             av_log(NULL, AV_LOG_ERROR, "Error allocating the decoder context.\n");
776             exit_program(1);
777         }
778
779         ret = avcodec_parameters_to_context(ist->dec_ctx, par);
780         if (ret < 0) {
781             av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
782             exit_program(1);
783         }
784
785         if (o->bitexact)
786             ist->dec_ctx->flags |= AV_CODEC_FLAG_BITEXACT;
787
788         switch (par->codec_type) {
789         case AVMEDIA_TYPE_VIDEO:
790             if(!ist->dec)
791                 ist->dec = avcodec_find_decoder(par->codec_id);
792 #if FF_API_LOWRES
793             if (av_codec_get_lowres(st->codec)) {
794                 av_codec_set_lowres(ist->dec_ctx, av_codec_get_lowres(st->codec));
795                 ist->dec_ctx->width  = st->codec->width;
796                 ist->dec_ctx->height = st->codec->height;
797                 ist->dec_ctx->coded_width  = st->codec->coded_width;
798                 ist->dec_ctx->coded_height = st->codec->coded_height;
799             }
800 #endif
801
802             // avformat_find_stream_info() doesn't set this for us anymore.
803             ist->dec_ctx->framerate = st->avg_frame_rate;
804
805             MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
806             if (framerate && av_parse_video_rate(&ist->framerate,
807                                                  framerate) < 0) {
808                 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
809                        framerate);
810                 exit_program(1);
811             }
812
813             ist->top_field_first = -1;
814             MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);
815
816             MATCH_PER_STREAM_OPT(hwaccels, str, hwaccel, ic, st);
817             if (hwaccel) {
818                 if (!strcmp(hwaccel, "none"))
819                     ist->hwaccel_id = HWACCEL_NONE;
820                 else if (!strcmp(hwaccel, "auto"))
821                     ist->hwaccel_id = HWACCEL_AUTO;
822                 else {
823                     int i;
824                     for (i = 0; hwaccels[i].name; i++) {
825                         if (!strcmp(hwaccels[i].name, hwaccel)) {
826                             ist->hwaccel_id = hwaccels[i].id;
827                             break;
828                         }
829                     }
830
831                     if (!ist->hwaccel_id) {
832                         av_log(NULL, AV_LOG_FATAL, "Unrecognized hwaccel: %s.\n",
833                                hwaccel);
834                         av_log(NULL, AV_LOG_FATAL, "Supported hwaccels: ");
835                         for (i = 0; hwaccels[i].name; i++)
836                             av_log(NULL, AV_LOG_FATAL, "%s ", hwaccels[i].name);
837                         av_log(NULL, AV_LOG_FATAL, "\n");
838                         exit_program(1);
839                     }
840                 }
841             }
842
843             MATCH_PER_STREAM_OPT(hwaccel_devices, str, hwaccel_device, ic, st);
844             if (hwaccel_device) {
845                 ist->hwaccel_device = av_strdup(hwaccel_device);
846                 if (!ist->hwaccel_device)
847                     exit_program(1);
848             }
849
850             MATCH_PER_STREAM_OPT(hwaccel_output_formats, str,
851                                  hwaccel_output_format, ic, st);
852             if (hwaccel_output_format) {
853                 ist->hwaccel_output_format = av_get_pix_fmt(hwaccel_output_format);
854                 if (ist->hwaccel_output_format == AV_PIX_FMT_NONE) {
855                     av_log(NULL, AV_LOG_FATAL, "Unrecognised hwaccel output "
856                            "format: %s", hwaccel_output_format);
857                 }
858             } else {
859                 ist->hwaccel_output_format = AV_PIX_FMT_NONE;
860             }
861
862             ist->hwaccel_pix_fmt = AV_PIX_FMT_NONE;
863
864             break;
865         case AVMEDIA_TYPE_AUDIO:
866             ist->guess_layout_max = INT_MAX;
867             MATCH_PER_STREAM_OPT(guess_layout_max, i, ist->guess_layout_max, ic, st);
868             guess_input_channel_layout(ist);
869             break;
870         case AVMEDIA_TYPE_DATA:
871         case AVMEDIA_TYPE_SUBTITLE: {
872             char *canvas_size = NULL;
873             if(!ist->dec)
874                 ist->dec = avcodec_find_decoder(par->codec_id);
875             MATCH_PER_STREAM_OPT(fix_sub_duration, i, ist->fix_sub_duration, ic, st);
876             MATCH_PER_STREAM_OPT(canvas_sizes, str, canvas_size, ic, st);
877             if (canvas_size &&
878                 av_parse_video_size(&ist->dec_ctx->width, &ist->dec_ctx->height, canvas_size) < 0) {
879                 av_log(NULL, AV_LOG_FATAL, "Invalid canvas size: %s.\n", canvas_size);
880                 exit_program(1);
881             }
882             break;
883         }
884         case AVMEDIA_TYPE_ATTACHMENT:
885         case AVMEDIA_TYPE_UNKNOWN:
886             break;
887         default:
888             abort();
889         }
890
891         ret = avcodec_parameters_from_context(par, ist->dec_ctx);
892         if (ret < 0) {
893             av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
894             exit_program(1);
895         }
896     }
897 }
898
899 static void assert_file_overwrite(const char *filename)
900 {
901     if (file_overwrite && no_file_overwrite) {
902         fprintf(stderr, "Error, both -y and -n supplied. Exiting.\n");
903         exit_program(1);
904     }
905
906     if (!file_overwrite) {
907         const char *proto_name = avio_find_protocol_name(filename);
908         if (proto_name && !strcmp(proto_name, "file") && avio_check(filename, 0) == 0) {
909             if (stdin_interaction && !no_file_overwrite) {
910                 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
911                 fflush(stderr);
912                 term_exit();
913                 signal(SIGINT, SIG_DFL);
914                 if (!read_yesno()) {
915                     av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
916                     exit_program(1);
917                 }
918                 term_init();
919             }
920             else {
921                 av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
922                 exit_program(1);
923             }
924         }
925     }
926 }
927
928 static void dump_attachment(AVStream *st, const char *filename)
929 {
930     int ret;
931     AVIOContext *out = NULL;
932     AVDictionaryEntry *e;
933
934     if (!st->codecpar->extradata_size) {
935         av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
936                nb_input_files - 1, st->index);
937         return;
938     }
939     if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
940         filename = e->value;
941     if (!*filename) {
942         av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
943                "in stream #%d:%d.\n", nb_input_files - 1, st->index);
944         exit_program(1);
945     }
946
947     assert_file_overwrite(filename);
948
949     if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
950         av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
951                filename);
952         exit_program(1);
953     }
954
955     avio_write(out, st->codecpar->extradata, st->codecpar->extradata_size);
956     avio_flush(out);
957     avio_close(out);
958 }
959
960 static int open_input_file(OptionsContext *o, const char *filename)
961 {
962     InputFile *f;
963     AVFormatContext *ic;
964     AVInputFormat *file_iformat = NULL;
965     int err, i, ret;
966     int64_t timestamp;
967     AVDictionary *unused_opts = NULL;
968     AVDictionaryEntry *e = NULL;
969     char *   video_codec_name = NULL;
970     char *   audio_codec_name = NULL;
971     char *subtitle_codec_name = NULL;
972     char *    data_codec_name = NULL;
973     int scan_all_pmts_set = 0;
974
975     if (o->format) {
976         if (!(file_iformat = av_find_input_format(o->format))) {
977             av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
978             exit_program(1);
979         }
980     }
981
982     if (!strcmp(filename, "-"))
983         filename = "pipe:";
984
985     stdin_interaction &= strncmp(filename, "pipe:", 5) &&
986                          strcmp(filename, "/dev/stdin");
987
988     /* get default parameters from command line */
989     ic = avformat_alloc_context();
990     if (!ic) {
991         print_error(filename, AVERROR(ENOMEM));
992         exit_program(1);
993     }
994     if (o->nb_audio_sample_rate) {
995         av_dict_set_int(&o->g->format_opts, "sample_rate", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i, 0);
996     }
997     if (o->nb_audio_channels) {
998         /* because we set audio_channels based on both the "ac" and
999          * "channel_layout" options, we need to check that the specified
1000          * demuxer actually has the "channels" option before setting it */
1001         if (file_iformat && file_iformat->priv_class &&
1002             av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
1003                         AV_OPT_SEARCH_FAKE_OBJ)) {
1004             av_dict_set_int(&o->g->format_opts, "channels", o->audio_channels[o->nb_audio_channels - 1].u.i, 0);
1005         }
1006     }
1007     if (o->nb_frame_rates) {
1008         /* set the format-level framerate option;
1009          * this is important for video grabbers, e.g. x11 */
1010         if (file_iformat && file_iformat->priv_class &&
1011             av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
1012                         AV_OPT_SEARCH_FAKE_OBJ)) {
1013             av_dict_set(&o->g->format_opts, "framerate",
1014                         o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
1015         }
1016     }
1017     if (o->nb_frame_sizes) {
1018         av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
1019     }
1020     if (o->nb_frame_pix_fmts)
1021         av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
1022
1023     MATCH_PER_TYPE_OPT(codec_names, str,    video_codec_name, ic, "v");
1024     MATCH_PER_TYPE_OPT(codec_names, str,    audio_codec_name, ic, "a");
1025     MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, ic, "s");
1026     MATCH_PER_TYPE_OPT(codec_names, str,     data_codec_name, ic, "d");
1027
1028     ic->video_codec_id   = video_codec_name ?
1029         find_codec_or_die(video_codec_name   , AVMEDIA_TYPE_VIDEO   , 0)->id : AV_CODEC_ID_NONE;
1030     ic->audio_codec_id   = audio_codec_name ?
1031         find_codec_or_die(audio_codec_name   , AVMEDIA_TYPE_AUDIO   , 0)->id : AV_CODEC_ID_NONE;
1032     ic->subtitle_codec_id= subtitle_codec_name ?
1033         find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : AV_CODEC_ID_NONE;
1034     ic->data_codec_id    = data_codec_name ?
1035         find_codec_or_die(data_codec_name, AVMEDIA_TYPE_DATA, 0)->id : AV_CODEC_ID_NONE;
1036
1037     if (video_codec_name)
1038         av_format_set_video_codec   (ic, find_codec_or_die(video_codec_name   , AVMEDIA_TYPE_VIDEO   , 0));
1039     if (audio_codec_name)
1040         av_format_set_audio_codec   (ic, find_codec_or_die(audio_codec_name   , AVMEDIA_TYPE_AUDIO   , 0));
1041     if (subtitle_codec_name)
1042         av_format_set_subtitle_codec(ic, find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0));
1043     if (data_codec_name)
1044         av_format_set_data_codec(ic, find_codec_or_die(data_codec_name, AVMEDIA_TYPE_DATA, 0));
1045
1046     ic->flags |= AVFMT_FLAG_NONBLOCK;
1047     if (o->bitexact)
1048         ic->flags |= AVFMT_FLAG_BITEXACT;
1049     ic->interrupt_callback = int_cb;
1050
1051     if (!av_dict_get(o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE)) {
1052         av_dict_set(&o->g->format_opts, "scan_all_pmts", "1", AV_DICT_DONT_OVERWRITE);
1053         scan_all_pmts_set = 1;
1054     }
1055     /* open the input file with generic avformat function */
1056     err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
1057     if (err < 0) {
1058         print_error(filename, err);
1059         if (err == AVERROR_PROTOCOL_NOT_FOUND)
1060             av_log(NULL, AV_LOG_ERROR, "Did you mean file:%s?\n", filename);
1061         exit_program(1);
1062     }
1063     if (scan_all_pmts_set)
1064         av_dict_set(&o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE);
1065     remove_avoptions(&o->g->format_opts, o->g->codec_opts);
1066     assert_avoptions(o->g->format_opts);
1067
1068     /* apply forced codec ids */
1069     for (i = 0; i < ic->nb_streams; i++)
1070         choose_decoder(o, ic, ic->streams[i]);
1071
1072     if (find_stream_info) {
1073         AVDictionary **opts = setup_find_stream_info_opts(ic, o->g->codec_opts);
1074         int orig_nb_streams = ic->nb_streams;
1075
1076         /* If not enough info to get the stream parameters, we decode the
1077            first frames to get it. (used in mpeg case for example) */
1078         ret = avformat_find_stream_info(ic, opts);
1079
1080         for (i = 0; i < orig_nb_streams; i++)
1081             av_dict_free(&opts[i]);
1082         av_freep(&opts);
1083
1084         if (ret < 0) {
1085             av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
1086             if (ic->nb_streams == 0) {
1087                 avformat_close_input(&ic);
1088                 exit_program(1);
1089             }
1090         }
1091     }
1092
1093     if (o->start_time_eof != AV_NOPTS_VALUE) {
1094         if (ic->duration>0) {
1095             o->start_time = o->start_time_eof + ic->duration;
1096         } else
1097             av_log(NULL, AV_LOG_WARNING, "Cannot use -sseof, duration of %s not known\n", filename);
1098     }
1099     timestamp = (o->start_time == AV_NOPTS_VALUE) ? 0 : o->start_time;
1100     /* add the stream start time */
1101     if (!o->seek_timestamp && ic->start_time != AV_NOPTS_VALUE)
1102         timestamp += ic->start_time;
1103
1104     /* if seeking requested, we execute it */
1105     if (o->start_time != AV_NOPTS_VALUE) {
1106         int64_t seek_timestamp = timestamp;
1107
1108         if (!(ic->iformat->flags & AVFMT_SEEK_TO_PTS)) {
1109             int dts_heuristic = 0;
1110             for (i=0; i<ic->nb_streams; i++) {
1111                 const AVCodecParameters *par = ic->streams[i]->codecpar;
1112                 if (par->video_delay)
1113                     dts_heuristic = 1;
1114             }
1115             if (dts_heuristic) {
1116                 seek_timestamp -= 3*AV_TIME_BASE / 23;
1117             }
1118         }
1119         ret = avformat_seek_file(ic, -1, INT64_MIN, seek_timestamp, seek_timestamp, 0);
1120         if (ret < 0) {
1121             av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
1122                    filename, (double)timestamp / AV_TIME_BASE);
1123         }
1124     }
1125
1126     /* update the current parameters so that they match the one of the input stream */
1127     add_input_streams(o, ic);
1128
1129     /* dump the file content */
1130     av_dump_format(ic, nb_input_files, filename, 0);
1131
1132     GROW_ARRAY(input_files, nb_input_files);
1133     f = av_mallocz(sizeof(*f));
1134     if (!f)
1135         exit_program(1);
1136     input_files[nb_input_files - 1] = f;
1137
1138     f->ctx        = ic;
1139     f->ist_index  = nb_input_streams - ic->nb_streams;
1140     f->start_time = o->start_time;
1141     f->recording_time = o->recording_time;
1142     f->input_ts_offset = o->input_ts_offset;
1143     f->ts_offset  = o->input_ts_offset - (copy_ts ? (start_at_zero && ic->start_time != AV_NOPTS_VALUE ? ic->start_time : 0) : timestamp);
1144     f->nb_streams = ic->nb_streams;
1145     f->rate_emu   = o->rate_emu;
1146     f->accurate_seek = o->accurate_seek;
1147     f->loop = o->loop;
1148     f->duration = 0;
1149     f->time_base = (AVRational){ 1, 1 };
1150 #if HAVE_PTHREADS
1151     f->thread_queue_size = o->thread_queue_size > 0 ? o->thread_queue_size : 8;
1152 #endif
1153
1154     /* check if all codec options have been used */
1155     unused_opts = strip_specifiers(o->g->codec_opts);
1156     for (i = f->ist_index; i < nb_input_streams; i++) {
1157         e = NULL;
1158         while ((e = av_dict_get(input_streams[i]->decoder_opts, "", e,
1159                                 AV_DICT_IGNORE_SUFFIX)))
1160             av_dict_set(&unused_opts, e->key, NULL, 0);
1161     }
1162
1163     e = NULL;
1164     while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
1165         const AVClass *class = avcodec_get_class();
1166         const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
1167                                              AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1168         const AVClass *fclass = avformat_get_class();
1169         const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
1170                                              AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1171         if (!option || foption)
1172             continue;
1173
1174
1175         if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) {
1176             av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
1177                    "input file #%d (%s) is not a decoding option.\n", e->key,
1178                    option->help ? option->help : "", nb_input_files - 1,
1179                    filename);
1180             exit_program(1);
1181         }
1182
1183         av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
1184                "input file #%d (%s) has not been used for any stream. The most "
1185                "likely reason is either wrong type (e.g. a video option with "
1186                "no video streams) or that it is a private option of some decoder "
1187                "which was not actually used for any stream.\n", e->key,
1188                option->help ? option->help : "", nb_input_files - 1, filename);
1189     }
1190     av_dict_free(&unused_opts);
1191
1192     for (i = 0; i < o->nb_dump_attachment; i++) {
1193         int j;
1194
1195         for (j = 0; j < ic->nb_streams; j++) {
1196             AVStream *st = ic->streams[j];
1197
1198             if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
1199                 dump_attachment(st, o->dump_attachment[i].u.str);
1200         }
1201     }
1202
1203     input_stream_potentially_available = 1;
1204
1205     return 0;
1206 }
1207
1208 static uint8_t *get_line(AVIOContext *s)
1209 {
1210     AVIOContext *line;
1211     uint8_t *buf;
1212     char c;
1213
1214     if (avio_open_dyn_buf(&line) < 0) {
1215         av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
1216         exit_program(1);
1217     }
1218
1219     while ((c = avio_r8(s)) && c != '\n')
1220         avio_w8(line, c);
1221     avio_w8(line, 0);
1222     avio_close_dyn_buf(line, &buf);
1223
1224     return buf;
1225 }
1226
1227 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
1228 {
1229     int i, ret = -1;
1230     char filename[1000];
1231     const char *base[3] = { getenv("AVCONV_DATADIR"),
1232                             getenv("HOME"),
1233                             AVCONV_DATADIR,
1234                             };
1235
1236     for (i = 0; i < FF_ARRAY_ELEMS(base) && ret < 0; i++) {
1237         if (!base[i])
1238             continue;
1239         if (codec_name) {
1240             snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
1241                      i != 1 ? "" : "/.avconv", codec_name, preset_name);
1242             ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1243         }
1244         if (ret < 0) {
1245             snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
1246                      i != 1 ? "" : "/.avconv", preset_name);
1247             ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1248         }
1249     }
1250     return ret;
1251 }
1252
1253 static int choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
1254 {
1255     enum AVMediaType type = ost->st->codecpar->codec_type;
1256     char *codec_name = NULL;
1257
1258     if (type == AVMEDIA_TYPE_VIDEO || type == AVMEDIA_TYPE_AUDIO || type == AVMEDIA_TYPE_SUBTITLE) {
1259         MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
1260         if (!codec_name) {
1261             ost->st->codecpar->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
1262                                                          NULL, ost->st->codecpar->codec_type);
1263             ost->enc = avcodec_find_encoder(ost->st->codecpar->codec_id);
1264             if (!ost->enc) {
1265                 av_log(NULL, AV_LOG_FATAL, "Automatic encoder selection failed for "
1266                        "output stream #%d:%d. Default encoder for format %s (codec %s) is "
1267                        "probably disabled. Please choose an encoder manually.\n",
1268                        ost->file_index, ost->index, s->oformat->name,
1269                        avcodec_get_name(ost->st->codecpar->codec_id));
1270                 return AVERROR_ENCODER_NOT_FOUND;
1271             }
1272         } else if (!strcmp(codec_name, "copy"))
1273             ost->stream_copy = 1;
1274         else {
1275             ost->enc = find_codec_or_die(codec_name, ost->st->codecpar->codec_type, 1);
1276             ost->st->codecpar->codec_id = ost->enc->id;
1277         }
1278         ost->encoding_needed = !ost->stream_copy;
1279     } else {
1280         /* no encoding supported for other media types */
1281         ost->stream_copy     = 1;
1282         ost->encoding_needed = 0;
1283     }
1284
1285     return 0;
1286 }
1287
1288 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
1289 {
1290     OutputStream *ost;
1291     AVStream *st = avformat_new_stream(oc, NULL);
1292     int idx      = oc->nb_streams - 1, ret = 0;
1293     const char *bsfs = NULL, *time_base = NULL;
1294     char *next, *codec_tag = NULL;
1295     double qscale = -1;
1296     int i;
1297
1298     if (!st) {
1299         av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
1300         exit_program(1);
1301     }
1302
1303     if (oc->nb_streams - 1 < o->nb_streamid_map)
1304         st->id = o->streamid_map[oc->nb_streams - 1];
1305
1306     GROW_ARRAY(output_streams, nb_output_streams);
1307     if (!(ost = av_mallocz(sizeof(*ost))))
1308         exit_program(1);
1309     output_streams[nb_output_streams - 1] = ost;
1310
1311     ost->file_index = nb_output_files - 1;
1312     ost->index      = idx;
1313     ost->st         = st;
1314     st->codecpar->codec_type = type;
1315
1316     ret = choose_encoder(o, oc, ost);
1317     if (ret < 0) {
1318         av_log(NULL, AV_LOG_FATAL, "Error selecting an encoder for stream "
1319                "%d:%d\n", ost->file_index, ost->index);
1320         exit_program(1);
1321     }
1322
1323     ost->enc_ctx = avcodec_alloc_context3(ost->enc);
1324     if (!ost->enc_ctx) {
1325         av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding context.\n");
1326         exit_program(1);
1327     }
1328     ost->enc_ctx->codec_type = type;
1329
1330     ost->ref_par = avcodec_parameters_alloc();
1331     if (!ost->ref_par) {
1332         av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding parameters.\n");
1333         exit_program(1);
1334     }
1335
1336     if (ost->enc) {
1337         AVIOContext *s = NULL;
1338         char *buf = NULL, *arg = NULL, *preset = NULL;
1339
1340         ost->encoder_opts  = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
1341
1342         MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
1343         if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
1344             do  {
1345                 buf = get_line(s);
1346                 if (!buf[0] || buf[0] == '#') {
1347                     av_free(buf);
1348                     continue;
1349                 }
1350                 if (!(arg = strchr(buf, '='))) {
1351                     av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
1352                     exit_program(1);
1353                 }
1354                 *arg++ = 0;
1355                 av_dict_set(&ost->encoder_opts, buf, arg, AV_DICT_DONT_OVERWRITE);
1356                 av_free(buf);
1357             } while (!s->eof_reached);
1358             avio_closep(&s);
1359         }
1360         if (ret) {
1361             av_log(NULL, AV_LOG_FATAL,
1362                    "Preset %s specified for stream %d:%d, but could not be opened.\n",
1363                    preset, ost->file_index, ost->index);
1364             exit_program(1);
1365         }
1366     } else {
1367         ost->encoder_opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
1368     }
1369
1370
1371     if (o->bitexact)
1372         ost->enc_ctx->flags |= AV_CODEC_FLAG_BITEXACT;
1373
1374     MATCH_PER_STREAM_OPT(time_bases, str, time_base, oc, st);
1375     if (time_base) {
1376         AVRational q;
1377         if (av_parse_ratio(&q, time_base, INT_MAX, 0, NULL) < 0 ||
1378             q.num <= 0 || q.den <= 0) {
1379             av_log(NULL, AV_LOG_FATAL, "Invalid time base: %s\n", time_base);
1380             exit_program(1);
1381         }
1382         st->time_base = q;
1383     }
1384
1385     MATCH_PER_STREAM_OPT(enc_time_bases, str, time_base, oc, st);
1386     if (time_base) {
1387         AVRational q;
1388         if (av_parse_ratio(&q, time_base, INT_MAX, 0, NULL) < 0 ||
1389             q.den <= 0) {
1390             av_log(NULL, AV_LOG_FATAL, "Invalid time base: %s\n", time_base);
1391             exit_program(1);
1392         }
1393         ost->enc_timebase = q;
1394     }
1395
1396     ost->max_frames = INT64_MAX;
1397     MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
1398     for (i = 0; i<o->nb_max_frames; i++) {
1399         char *p = o->max_frames[i].specifier;
1400         if (!*p && type != AVMEDIA_TYPE_VIDEO) {
1401             av_log(NULL, AV_LOG_WARNING, "Applying unspecific -frames to non video streams, maybe you meant -vframes ?\n");
1402             break;
1403         }
1404     }
1405
1406     ost->copy_prior_start = -1;
1407     MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
1408
1409     MATCH_PER_STREAM_OPT(bitstream_filters, str, bsfs, oc, st);
1410     while (bsfs && *bsfs) {
1411         const AVBitStreamFilter *filter;
1412         char *bsf, *bsf_options_str, *bsf_name;
1413
1414         bsf = av_get_token(&bsfs, ",");
1415         if (!bsf)
1416             exit_program(1);
1417         bsf_name = av_strtok(bsf, "=", &bsf_options_str);
1418         if (!bsf_name)
1419             exit_program(1);
1420
1421         filter = av_bsf_get_by_name(bsf_name);
1422         if (!filter) {
1423             av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf_name);
1424             exit_program(1);
1425         }
1426
1427         ost->bsf_ctx = av_realloc_array(ost->bsf_ctx,
1428                                         ost->nb_bitstream_filters + 1,
1429                                         sizeof(*ost->bsf_ctx));
1430         if (!ost->bsf_ctx)
1431             exit_program(1);
1432
1433         ret = av_bsf_alloc(filter, &ost->bsf_ctx[ost->nb_bitstream_filters]);
1434         if (ret < 0) {
1435             av_log(NULL, AV_LOG_ERROR, "Error allocating a bitstream filter context\n");
1436             exit_program(1);
1437         }
1438
1439         ost->nb_bitstream_filters++;
1440
1441         if (bsf_options_str && filter->priv_class) {
1442             const AVOption *opt = av_opt_next(ost->bsf_ctx[ost->nb_bitstream_filters-1]->priv_data, NULL);
1443             const char * shorthand[2] = {NULL};
1444
1445             if (opt)
1446                 shorthand[0] = opt->name;
1447
1448             ret = av_opt_set_from_string(ost->bsf_ctx[ost->nb_bitstream_filters-1]->priv_data, bsf_options_str, shorthand, "=", ":");
1449             if (ret < 0) {
1450                 av_log(NULL, AV_LOG_ERROR, "Error parsing options for bitstream filter %s\n", bsf_name);
1451                 exit_program(1);
1452             }
1453         }
1454         av_freep(&bsf);
1455
1456         if (*bsfs)
1457             bsfs++;
1458     }
1459
1460     MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1461     if (codec_tag) {
1462         uint32_t tag = strtol(codec_tag, &next, 0);
1463         if (*next)
1464             tag = AV_RL32(codec_tag);
1465         ost->st->codecpar->codec_tag =
1466         ost->enc_ctx->codec_tag = tag;
1467     }
1468
1469     MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1470     if (qscale >= 0) {
1471         ost->enc_ctx->flags |= AV_CODEC_FLAG_QSCALE;
1472         ost->enc_ctx->global_quality = FF_QP2LAMBDA * qscale;
1473     }
1474
1475     MATCH_PER_STREAM_OPT(disposition, str, ost->disposition, oc, st);
1476     ost->disposition = av_strdup(ost->disposition);
1477
1478     ost->max_muxing_queue_size = 128;
1479     MATCH_PER_STREAM_OPT(max_muxing_queue_size, i, ost->max_muxing_queue_size, oc, st);
1480     ost->max_muxing_queue_size *= sizeof(AVPacket);
1481
1482     if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1483         ost->enc_ctx->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
1484
1485     av_dict_copy(&ost->sws_dict, o->g->sws_dict, 0);
1486
1487     av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0);
1488     if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24)
1489         av_dict_set(&ost->swr_opts, "output_sample_bits", "24", 0);
1490
1491     av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1492
1493     ost->source_index = source_index;
1494     if (source_index >= 0) {
1495         ost->sync_ist = input_streams[source_index];
1496         input_streams[source_index]->discard = 0;
1497         input_streams[source_index]->st->discard = input_streams[source_index]->user_set_discard;
1498     }
1499     ost->last_mux_dts = AV_NOPTS_VALUE;
1500
1501     ost->muxing_queue = av_fifo_alloc(8 * sizeof(AVPacket));
1502     if (!ost->muxing_queue)
1503         exit_program(1);
1504
1505     return ost;
1506 }
1507
1508 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1509 {
1510     int i;
1511     const char *p = str;
1512     for (i = 0;; i++) {
1513         dest[i] = atoi(p);
1514         if (i == 63)
1515             break;
1516         p = strchr(p, ',');
1517         if (!p) {
1518             av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1519             exit_program(1);
1520         }
1521         p++;
1522     }
1523 }
1524
1525 /* read file contents into a string */
1526 static uint8_t *read_file(const char *filename)
1527 {
1528     AVIOContext *pb      = NULL;
1529     AVIOContext *dyn_buf = NULL;
1530     int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1531     uint8_t buf[1024], *str;
1532
1533     if (ret < 0) {
1534         av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1535         return NULL;
1536     }
1537
1538     ret = avio_open_dyn_buf(&dyn_buf);
1539     if (ret < 0) {
1540         avio_closep(&pb);
1541         return NULL;
1542     }
1543     while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1544         avio_write(dyn_buf, buf, ret);
1545     avio_w8(dyn_buf, 0);
1546     avio_closep(&pb);
1547
1548     ret = avio_close_dyn_buf(dyn_buf, &str);
1549     if (ret < 0)
1550         return NULL;
1551     return str;
1552 }
1553
1554 static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
1555                              OutputStream *ost)
1556 {
1557     AVStream *st = ost->st;
1558
1559     if (ost->filters_script && ost->filters) {
1560         av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1561                "output stream #%d:%d.\n", nb_output_files, st->index);
1562         exit_program(1);
1563     }
1564
1565     if (ost->filters_script)
1566         return read_file(ost->filters_script);
1567     else if (ost->filters)
1568         return av_strdup(ost->filters);
1569
1570     return av_strdup(st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ?
1571                      "null" : "anull");
1572 }
1573
1574 static void check_streamcopy_filters(OptionsContext *o, AVFormatContext *oc,
1575                                      const OutputStream *ost, enum AVMediaType type)
1576 {
1577     if (ost->filters_script || ost->filters) {
1578         av_log(NULL, AV_LOG_ERROR,
1579                "%s '%s' was defined for %s output stream %d:%d but codec copy was selected.\n"
1580                "Filtering and streamcopy cannot be used together.\n",
1581                ost->filters ? "Filtergraph" : "Filtergraph script",
1582                ost->filters ? ost->filters : ost->filters_script,
1583                av_get_media_type_string(type), ost->file_index, ost->index);
1584         exit_program(1);
1585     }
1586 }
1587
1588 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1589 {
1590     AVStream *st;
1591     OutputStream *ost;
1592     AVCodecContext *video_enc;
1593     char *frame_rate = NULL, *frame_aspect_ratio = NULL;
1594
1595     ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1596     st  = ost->st;
1597     video_enc = ost->enc_ctx;
1598
1599     MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1600     if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1601         av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1602         exit_program(1);
1603     }
1604     if (frame_rate && video_sync_method == VSYNC_PASSTHROUGH)
1605         av_log(NULL, AV_LOG_ERROR, "Using -vsync 0 and -r can produce invalid output files\n");
1606
1607     MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1608     if (frame_aspect_ratio) {
1609         AVRational q;
1610         if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1611             q.num <= 0 || q.den <= 0) {
1612             av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1613             exit_program(1);
1614         }
1615         ost->frame_aspect_ratio = q;
1616     }
1617
1618     MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1619     MATCH_PER_STREAM_OPT(filters,        str, ost->filters,        oc, st);
1620
1621     if (!ost->stream_copy) {
1622         const char *p = NULL;
1623         char *frame_size = NULL;
1624         char *frame_pix_fmt = NULL;
1625         char *intra_matrix = NULL, *inter_matrix = NULL;
1626         char *chroma_intra_matrix = NULL;
1627         int do_pass = 0;
1628         int i;
1629
1630         MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1631         if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1632             av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1633             exit_program(1);
1634         }
1635
1636         video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1637         MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1638         if (frame_pix_fmt && *frame_pix_fmt == '+') {
1639             ost->keep_pix_fmt = 1;
1640             if (!*++frame_pix_fmt)
1641                 frame_pix_fmt = NULL;
1642         }
1643         if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1644             av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1645             exit_program(1);
1646         }
1647         st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1648
1649         if (intra_only)
1650             video_enc->gop_size = 0;
1651         MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1652         if (intra_matrix) {
1653             if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1654                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1655                 exit_program(1);
1656             }
1657             parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1658         }
1659         MATCH_PER_STREAM_OPT(chroma_intra_matrices, str, chroma_intra_matrix, oc, st);
1660         if (chroma_intra_matrix) {
1661             uint16_t *p = av_mallocz(sizeof(*video_enc->chroma_intra_matrix) * 64);
1662             if (!p) {
1663                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1664                 exit_program(1);
1665             }
1666             av_codec_set_chroma_intra_matrix(video_enc, p);
1667             parse_matrix_coeffs(p, chroma_intra_matrix);
1668         }
1669         MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1670         if (inter_matrix) {
1671             if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1672                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1673                 exit_program(1);
1674             }
1675             parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1676         }
1677
1678         MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1679         for (i = 0; p; i++) {
1680             int start, end, q;
1681             int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1682             if (e != 3) {
1683                 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1684                 exit_program(1);
1685             }
1686             video_enc->rc_override =
1687                 av_realloc_array(video_enc->rc_override,
1688                                  i + 1, sizeof(RcOverride));
1689             if (!video_enc->rc_override) {
1690                 av_log(NULL, AV_LOG_FATAL, "Could not (re)allocate memory for rc_override.\n");
1691                 exit_program(1);
1692             }
1693             video_enc->rc_override[i].start_frame = start;
1694             video_enc->rc_override[i].end_frame   = end;
1695             if (q > 0) {
1696                 video_enc->rc_override[i].qscale         = q;
1697                 video_enc->rc_override[i].quality_factor = 1.0;
1698             }
1699             else {
1700                 video_enc->rc_override[i].qscale         = 0;
1701                 video_enc->rc_override[i].quality_factor = -q/100.0;
1702             }
1703             p = strchr(p, '/');
1704             if (p) p++;
1705         }
1706         video_enc->rc_override_count = i;
1707
1708         if (do_psnr)
1709             video_enc->flags|= AV_CODEC_FLAG_PSNR;
1710
1711         /* two pass mode */
1712         MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1713         if (do_pass) {
1714             if (do_pass & 1) {
1715                 video_enc->flags |= AV_CODEC_FLAG_PASS1;
1716                 av_dict_set(&ost->encoder_opts, "flags", "+pass1", AV_DICT_APPEND);
1717             }
1718             if (do_pass & 2) {
1719                 video_enc->flags |= AV_CODEC_FLAG_PASS2;
1720                 av_dict_set(&ost->encoder_opts, "flags", "+pass2", AV_DICT_APPEND);
1721             }
1722         }
1723
1724         MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1725         if (ost->logfile_prefix &&
1726             !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1727             exit_program(1);
1728
1729         if (do_pass) {
1730             char logfilename[1024];
1731             FILE *f;
1732
1733             snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1734                      ost->logfile_prefix ? ost->logfile_prefix :
1735                                            DEFAULT_PASS_LOGFILENAME_PREFIX,
1736                      i);
1737             if (!strcmp(ost->enc->name, "libx264")) {
1738                 av_dict_set(&ost->encoder_opts, "stats", logfilename, AV_DICT_DONT_OVERWRITE);
1739             } else {
1740                 if (video_enc->flags & AV_CODEC_FLAG_PASS2) {
1741                     char  *logbuffer = read_file(logfilename);
1742
1743                     if (!logbuffer) {
1744                         av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
1745                                logfilename);
1746                         exit_program(1);
1747                     }
1748                     video_enc->stats_in = logbuffer;
1749                 }
1750                 if (video_enc->flags & AV_CODEC_FLAG_PASS1) {
1751                     f = av_fopen_utf8(logfilename, "wb");
1752                     if (!f) {
1753                         av_log(NULL, AV_LOG_FATAL,
1754                                "Cannot write log file '%s' for pass-1 encoding: %s\n",
1755                                logfilename, strerror(errno));
1756                         exit_program(1);
1757                     }
1758                     ost->logfile = f;
1759                 }
1760             }
1761         }
1762
1763         MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1764         if (ost->forced_keyframes)
1765             ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1766
1767         MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1768
1769         ost->top_field_first = -1;
1770         MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1771
1772
1773         ost->avfilter = get_ost_filters(o, oc, ost);
1774         if (!ost->avfilter)
1775             exit_program(1);
1776     } else {
1777         MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1778     }
1779
1780     if (ost->stream_copy)
1781         check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_VIDEO);
1782
1783     return ost;
1784 }
1785
1786 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1787 {
1788     int n;
1789     AVStream *st;
1790     OutputStream *ost;
1791     AVCodecContext *audio_enc;
1792
1793     ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1794     st  = ost->st;
1795
1796     audio_enc = ost->enc_ctx;
1797     audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1798
1799     MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1800     MATCH_PER_STREAM_OPT(filters,        str, ost->filters,        oc, st);
1801
1802     if (!ost->stream_copy) {
1803         char *sample_fmt = NULL;
1804
1805         MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1806
1807         MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1808         if (sample_fmt &&
1809             (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1810             av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1811             exit_program(1);
1812         }
1813
1814         MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1815
1816         MATCH_PER_STREAM_OPT(apad, str, ost->apad, oc, st);
1817         ost->apad = av_strdup(ost->apad);
1818
1819         ost->avfilter = get_ost_filters(o, oc, ost);
1820         if (!ost->avfilter)
1821             exit_program(1);
1822
1823         /* check for channel mapping for this audio stream */
1824         for (n = 0; n < o->nb_audio_channel_maps; n++) {
1825             AudioChannelMap *map = &o->audio_channel_maps[n];
1826             if ((map->ofile_idx   == -1 || ost->file_index == map->ofile_idx) &&
1827                 (map->ostream_idx == -1 || ost->st->index  == map->ostream_idx)) {
1828                 InputStream *ist;
1829
1830                 if (map->channel_idx == -1) {
1831                     ist = NULL;
1832                 } else if (ost->source_index < 0) {
1833                     av_log(NULL, AV_LOG_FATAL, "Cannot determine input stream for channel mapping %d.%d\n",
1834                            ost->file_index, ost->st->index);
1835                     continue;
1836                 } else {
1837                     ist = input_streams[ost->source_index];
1838                 }
1839
1840                 if (!ist || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) {
1841                     if (av_reallocp_array(&ost->audio_channels_map,
1842                                           ost->audio_channels_mapped + 1,
1843                                           sizeof(*ost->audio_channels_map)
1844                                           ) < 0 )
1845                         exit_program(1);
1846
1847                     ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1848                 }
1849             }
1850         }
1851     }
1852
1853     if (ost->stream_copy)
1854         check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_AUDIO);
1855
1856     return ost;
1857 }
1858
1859 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1860 {
1861     OutputStream *ost;
1862
1863     ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1864     if (!ost->stream_copy) {
1865         av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1866         exit_program(1);
1867     }
1868
1869     return ost;
1870 }
1871
1872 static OutputStream *new_unknown_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1873 {
1874     OutputStream *ost;
1875
1876     ost = new_output_stream(o, oc, AVMEDIA_TYPE_UNKNOWN, source_index);
1877     if (!ost->stream_copy) {
1878         av_log(NULL, AV_LOG_FATAL, "Unknown stream encoding not supported yet (only streamcopy)\n");
1879         exit_program(1);
1880     }
1881
1882     return ost;
1883 }
1884
1885 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1886 {
1887     OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1888     ost->stream_copy = 1;
1889     ost->finished    = 1;
1890     return ost;
1891 }
1892
1893 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1894 {
1895     AVStream *st;
1896     OutputStream *ost;
1897     AVCodecContext *subtitle_enc;
1898
1899     ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1900     st  = ost->st;
1901     subtitle_enc = ost->enc_ctx;
1902
1903     subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1904
1905     MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1906
1907     if (!ost->stream_copy) {
1908         char *frame_size = NULL;
1909
1910         MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1911         if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1912             av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1913             exit_program(1);
1914         }
1915     }
1916
1917     return ost;
1918 }
1919
1920 /* arg format is "output-stream-index:streamid-value". */
1921 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1922 {
1923     OptionsContext *o = optctx;
1924     int idx;
1925     char *p;
1926     char idx_str[16];
1927
1928     av_strlcpy(idx_str, arg, sizeof(idx_str));
1929     p = strchr(idx_str, ':');
1930     if (!p) {
1931         av_log(NULL, AV_LOG_FATAL,
1932                "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1933                arg, opt);
1934         exit_program(1);
1935     }
1936     *p++ = '\0';
1937     idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1938     o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1939     o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1940     return 0;
1941 }
1942
1943 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1944 {
1945     AVFormatContext *is = ifile->ctx;
1946     AVFormatContext *os = ofile->ctx;
1947     AVChapter **tmp;
1948     int i;
1949
1950     tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1951     if (!tmp)
1952         return AVERROR(ENOMEM);
1953     os->chapters = tmp;
1954
1955     for (i = 0; i < is->nb_chapters; i++) {
1956         AVChapter *in_ch = is->chapters[i], *out_ch;
1957         int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
1958         int64_t ts_off   = av_rescale_q(start_time - ifile->ts_offset,
1959                                        AV_TIME_BASE_Q, in_ch->time_base);
1960         int64_t rt       = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1961                            av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1962
1963
1964         if (in_ch->end < ts_off)
1965             continue;
1966         if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1967             break;
1968
1969         out_ch = av_mallocz(sizeof(AVChapter));
1970         if (!out_ch)
1971             return AVERROR(ENOMEM);
1972
1973         out_ch->id        = in_ch->id;
1974         out_ch->time_base = in_ch->time_base;
1975         out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
1976         out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
1977
1978         if (copy_metadata)
1979             av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1980
1981         os->chapters[os->nb_chapters++] = out_ch;
1982     }
1983     return 0;
1984 }
1985
1986 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
1987 {
1988     int i, err;
1989     AVFormatContext *ic = avformat_alloc_context();
1990
1991     ic->interrupt_callback = int_cb;
1992     err = avformat_open_input(&ic, filename, NULL, NULL);
1993     if (err < 0)
1994         return err;
1995     /* copy stream format */
1996     for(i=0;i<ic->nb_streams;i++) {
1997         AVStream *st;
1998         OutputStream *ost;
1999         AVCodec *codec;
2000         const char *enc_config;
2001
2002         codec = avcodec_find_encoder(ic->streams[i]->codecpar->codec_id);
2003         if (!codec) {
2004             av_log(s, AV_LOG_ERROR, "no encoder found for codec id %i\n", ic->streams[i]->codecpar->codec_id);
2005             return AVERROR(EINVAL);
2006         }
2007         if (codec->type == AVMEDIA_TYPE_AUDIO)
2008             opt_audio_codec(o, "c:a", codec->name);
2009         else if (codec->type == AVMEDIA_TYPE_VIDEO)
2010             opt_video_codec(o, "c:v", codec->name);
2011         ost   = new_output_stream(o, s, codec->type, -1);
2012         st    = ost->st;
2013
2014         avcodec_get_context_defaults3(st->codec, codec);
2015         enc_config = av_stream_get_recommended_encoder_configuration(ic->streams[i]);
2016         if (enc_config) {
2017             AVDictionary *opts = NULL;
2018             av_dict_parse_string(&opts, enc_config, "=", ",", 0);
2019             av_opt_set_dict2(st->codec, &opts, AV_OPT_SEARCH_CHILDREN);
2020             av_dict_free(&opts);
2021         }
2022
2023         if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
2024             choose_sample_fmt(st, codec);
2025         else if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
2026             choose_pixel_fmt(st, st->codec, codec, st->codecpar->format);
2027         avcodec_copy_context(ost->enc_ctx, st->codec);
2028         if (enc_config)
2029             av_dict_parse_string(&ost->encoder_opts, enc_config, "=", ",", 0);
2030     }
2031
2032     avformat_close_input(&ic);
2033     return err;
2034 }
2035
2036 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
2037                                AVFormatContext *oc)
2038 {
2039     OutputStream *ost;
2040
2041     switch (ofilter->type) {
2042     case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
2043     case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
2044     default:
2045         av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
2046                "currently.\n");
2047         exit_program(1);
2048     }
2049
2050     ost->source_index = -1;
2051     ost->filter       = ofilter;
2052
2053     ofilter->ost      = ost;
2054     ofilter->format   = -1;
2055
2056     if (ost->stream_copy) {
2057         av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
2058                "which is fed from a complex filtergraph. Filtering and streamcopy "
2059                "cannot be used together.\n", ost->file_index, ost->index);
2060         exit_program(1);
2061     }
2062
2063     if (ost->avfilter && (ost->filters || ost->filters_script)) {
2064         const char *opt = ost->filters ? "-vf/-af/-filter" : "-filter_script";
2065         av_log(NULL, AV_LOG_ERROR,
2066                "%s '%s' was specified through the %s option "
2067                "for output stream %d:%d, which is fed from a complex filtergraph.\n"
2068                "%s and -filter_complex cannot be used together for the same stream.\n",
2069                ost->filters ? "Filtergraph" : "Filtergraph script",
2070                ost->filters ? ost->filters : ost->filters_script,
2071                opt, ost->file_index, ost->index, opt);
2072         exit_program(1);
2073     }
2074
2075     avfilter_inout_free(&ofilter->out_tmp);
2076 }
2077
2078 static int init_complex_filters(void)
2079 {
2080     int i, ret = 0;
2081
2082     for (i = 0; i < nb_filtergraphs; i++) {
2083         ret = init_complex_filtergraph(filtergraphs[i]);
2084         if (ret < 0)
2085             return ret;
2086     }
2087     return 0;
2088 }
2089
2090 static int open_output_file(OptionsContext *o, const char *filename)
2091 {
2092     AVFormatContext *oc;
2093     int i, j, err;
2094     AVOutputFormat *file_oformat;
2095     OutputFile *of;
2096     OutputStream *ost;
2097     InputStream  *ist;
2098     AVDictionary *unused_opts = NULL;
2099     AVDictionaryEntry *e = NULL;
2100     int format_flags = 0;
2101
2102     if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
2103         o->stop_time = INT64_MAX;
2104         av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
2105     }
2106
2107     if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
2108         int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
2109         if (o->stop_time <= start_time) {
2110             av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
2111             exit_program(1);
2112         } else {
2113             o->recording_time = o->stop_time - start_time;
2114         }
2115     }
2116
2117     GROW_ARRAY(output_files, nb_output_files);
2118     of = av_mallocz(sizeof(*of));
2119     if (!of)
2120         exit_program(1);
2121     output_files[nb_output_files - 1] = of;
2122
2123     of->ost_index      = nb_output_streams;
2124     of->recording_time = o->recording_time;
2125     of->start_time     = o->start_time;
2126     of->limit_filesize = o->limit_filesize;
2127     of->shortest       = o->shortest;
2128     av_dict_copy(&of->opts, o->g->format_opts, 0);
2129
2130     if (!strcmp(filename, "-"))
2131         filename = "pipe:";
2132
2133     err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
2134     if (!oc) {
2135         print_error(filename, err);
2136         exit_program(1);
2137     }
2138
2139     of->ctx = oc;
2140     if (o->recording_time != INT64_MAX)
2141         oc->duration = o->recording_time;
2142
2143     file_oformat= oc->oformat;
2144     oc->interrupt_callback = int_cb;
2145
2146     e = av_dict_get(o->g->format_opts, "fflags", NULL, 0);
2147     if (e) {
2148         const AVOption *o = av_opt_find(oc, "fflags", NULL, 0, 0);
2149         av_opt_eval_flags(oc, o, e->value, &format_flags);
2150     }
2151     if (o->bitexact) {
2152         format_flags |= AVFMT_FLAG_BITEXACT;
2153         oc->flags    |= AVFMT_FLAG_BITEXACT;
2154     }
2155
2156     /* create streams for all unlabeled output pads */
2157     for (i = 0; i < nb_filtergraphs; i++) {
2158         FilterGraph *fg = filtergraphs[i];
2159         for (j = 0; j < fg->nb_outputs; j++) {
2160             OutputFilter *ofilter = fg->outputs[j];
2161
2162             if (!ofilter->out_tmp || ofilter->out_tmp->name)
2163                 continue;
2164
2165             switch (ofilter->type) {
2166             case AVMEDIA_TYPE_VIDEO:    o->video_disable    = 1; break;
2167             case AVMEDIA_TYPE_AUDIO:    o->audio_disable    = 1; break;
2168             case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
2169             }
2170             init_output_filter(ofilter, o, oc);
2171         }
2172     }
2173
2174     /* ffserver seeking with date=... needs a date reference */
2175     if (!strcmp(file_oformat->name, "ffm") &&
2176         !(format_flags & AVFMT_FLAG_BITEXACT) &&
2177         av_strstart(filename, "http:", NULL)) {
2178         int err = parse_option(o, "metadata", "creation_time=now", options);
2179         if (err < 0) {
2180             print_error(filename, err);
2181             exit_program(1);
2182         }
2183     }
2184
2185     if (!strcmp(file_oformat->name, "ffm") && !override_ffserver &&
2186         av_strstart(filename, "http:", NULL)) {
2187         int j;
2188         /* special case for files sent to ffserver: we get the stream
2189            parameters from ffserver */
2190         int err = read_ffserver_streams(o, oc, filename);
2191         if (err < 0) {
2192             print_error(filename, err);
2193             exit_program(1);
2194         }
2195         for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
2196             ost = output_streams[j];
2197             for (i = 0; i < nb_input_streams; i++) {
2198                 ist = input_streams[i];
2199                 if(ist->st->codecpar->codec_type == ost->st->codecpar->codec_type){
2200                     ost->sync_ist= ist;
2201                     ost->source_index= i;
2202                     if(ost->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
2203                     if(ost->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
2204                     ist->discard = 0;
2205                     ist->st->discard = ist->user_set_discard;
2206                     break;
2207                 }
2208             }
2209             if(!ost->sync_ist){
2210                 av_log(NULL, AV_LOG_FATAL, "Missing %s stream which is required by this ffm\n", av_get_media_type_string(ost->st->codecpar->codec_type));
2211                 exit_program(1);
2212             }
2213         }
2214     } else if (!o->nb_stream_maps) {
2215         char *subtitle_codec_name = NULL;
2216         /* pick the "best" stream of each type */
2217
2218         /* video: highest resolution */
2219         if (!o->video_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_VIDEO) != AV_CODEC_ID_NONE) {
2220             int area = 0, idx = -1;
2221             int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
2222             for (i = 0; i < nb_input_streams; i++) {
2223                 int new_area;
2224                 ist = input_streams[i];
2225                 new_area = ist->st->codecpar->width * ist->st->codecpar->height + 100000000*!!ist->st->codec_info_nb_frames;
2226                 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2227                     new_area = 1;
2228                 if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
2229                     new_area > area) {
2230                     if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2231                         continue;
2232                     area = new_area;
2233                     idx = i;
2234                 }
2235             }
2236             if (idx >= 0)
2237                 new_video_stream(o, oc, idx);
2238         }
2239
2240         /* audio: most channels */
2241         if (!o->audio_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_AUDIO) != AV_CODEC_ID_NONE) {
2242             int best_score = 0, idx = -1;
2243             for (i = 0; i < nb_input_streams; i++) {
2244                 int score;
2245                 ist = input_streams[i];
2246                 score = ist->st->codecpar->channels + 100000000*!!ist->st->codec_info_nb_frames;
2247                 if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
2248                     score > best_score) {
2249                     best_score = score;
2250                     idx = i;
2251                 }
2252             }
2253             if (idx >= 0)
2254                 new_audio_stream(o, oc, idx);
2255         }
2256
2257         /* subtitles: pick first */
2258         MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
2259         if (!o->subtitle_disable && (avcodec_find_encoder(oc->oformat->subtitle_codec) || subtitle_codec_name)) {
2260             for (i = 0; i < nb_input_streams; i++)
2261                 if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2262                     AVCodecDescriptor const *input_descriptor =
2263                         avcodec_descriptor_get(input_streams[i]->st->codecpar->codec_id);
2264                     AVCodecDescriptor const *output_descriptor = NULL;
2265                     AVCodec const *output_codec =
2266                         avcodec_find_encoder(oc->oformat->subtitle_codec);
2267                     int input_props = 0, output_props = 0;
2268                     if (output_codec)
2269                         output_descriptor = avcodec_descriptor_get(output_codec->id);
2270                     if (input_descriptor)
2271                         input_props = input_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2272                     if (output_descriptor)
2273                         output_props = output_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2274                     if (subtitle_codec_name ||
2275                         input_props & output_props ||
2276                         // Map dvb teletext which has neither property to any output subtitle encoder
2277                         input_descriptor && output_descriptor &&
2278                         (!input_descriptor->props ||
2279                          !output_descriptor->props)) {
2280                         new_subtitle_stream(o, oc, i);
2281                         break;
2282                     }
2283                 }
2284         }
2285         /* Data only if codec id match */
2286         if (!o->data_disable ) {
2287             enum AVCodecID codec_id = av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_DATA);
2288             for (i = 0; codec_id != AV_CODEC_ID_NONE && i < nb_input_streams; i++) {
2289                 if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_DATA
2290                     && input_streams[i]->st->codecpar->codec_id == codec_id )
2291                     new_data_stream(o, oc, i);
2292             }
2293         }
2294     } else {
2295         for (i = 0; i < o->nb_stream_maps; i++) {
2296             StreamMap *map = &o->stream_maps[i];
2297
2298             if (map->disabled)
2299                 continue;
2300
2301             if (map->linklabel) {
2302                 FilterGraph *fg;
2303                 OutputFilter *ofilter = NULL;
2304                 int j, k;
2305
2306                 for (j = 0; j < nb_filtergraphs; j++) {
2307                     fg = filtergraphs[j];
2308                     for (k = 0; k < fg->nb_outputs; k++) {
2309                         AVFilterInOut *out = fg->outputs[k]->out_tmp;
2310                         if (out && !strcmp(out->name, map->linklabel)) {
2311                             ofilter = fg->outputs[k];
2312                             goto loop_end;
2313                         }
2314                     }
2315                 }
2316 loop_end:
2317                 if (!ofilter) {
2318                     av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
2319                            "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
2320                     exit_program(1);
2321                 }
2322                 init_output_filter(ofilter, o, oc);
2323             } else {
2324                 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
2325
2326                 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
2327                 if(o->subtitle_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE)
2328                     continue;
2329                 if(o->   audio_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
2330                     continue;
2331                 if(o->   video_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
2332                     continue;
2333                 if(o->    data_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_DATA)
2334                     continue;
2335
2336                 ost = NULL;
2337                 switch (ist->st->codecpar->codec_type) {
2338                 case AVMEDIA_TYPE_VIDEO:      ost = new_video_stream     (o, oc, src_idx); break;
2339                 case AVMEDIA_TYPE_AUDIO:      ost = new_audio_stream     (o, oc, src_idx); break;
2340                 case AVMEDIA_TYPE_SUBTITLE:   ost = new_subtitle_stream  (o, oc, src_idx); break;
2341                 case AVMEDIA_TYPE_DATA:       ost = new_data_stream      (o, oc, src_idx); break;
2342                 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
2343                 case AVMEDIA_TYPE_UNKNOWN:
2344                     if (copy_unknown_streams) {
2345                         ost = new_unknown_stream   (o, oc, src_idx);
2346                         break;
2347                     }
2348                 default:
2349                     av_log(NULL, ignore_unknown_streams ? AV_LOG_WARNING : AV_LOG_FATAL,
2350                            "Cannot map stream #%d:%d - unsupported type.\n",
2351                            map->file_index, map->stream_index);
2352                     if (!ignore_unknown_streams) {
2353                         av_log(NULL, AV_LOG_FATAL,
2354                                "If you want unsupported types ignored instead "
2355                                "of failing, please use the -ignore_unknown option\n"
2356                                "If you want them copied, please use -copy_unknown\n");
2357                         exit_program(1);
2358                     }
2359                 }
2360                 if (ost)
2361                     ost->sync_ist = input_streams[  input_files[map->sync_file_index]->ist_index
2362                                                   + map->sync_stream_index];
2363             }
2364         }
2365     }
2366
2367     /* handle attached files */
2368     for (i = 0; i < o->nb_attachments; i++) {
2369         AVIOContext *pb;
2370         uint8_t *attachment;
2371         const char *p;
2372         int64_t len;
2373
2374         if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
2375             av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
2376                    o->attachments[i]);
2377             exit_program(1);
2378         }
2379         if ((len = avio_size(pb)) <= 0) {
2380             av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
2381                    o->attachments[i]);
2382             exit_program(1);
2383         }
2384         if (!(attachment = av_malloc(len))) {
2385             av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
2386                    o->attachments[i]);
2387             exit_program(1);
2388         }
2389         avio_read(pb, attachment, len);
2390
2391         ost = new_attachment_stream(o, oc, -1);
2392         ost->stream_copy               = 0;
2393         ost->attachment_filename       = o->attachments[i];
2394         ost->st->codecpar->extradata      = attachment;
2395         ost->st->codecpar->extradata_size = len;
2396
2397         p = strrchr(o->attachments[i], '/');
2398         av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
2399         avio_closep(&pb);
2400     }
2401
2402 #if FF_API_LAVF_AVCTX
2403     for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
2404         AVDictionaryEntry *e;
2405         ost = output_streams[i];
2406
2407         if ((ost->stream_copy || ost->attachment_filename)
2408             && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
2409             && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
2410             if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
2411                 exit_program(1);
2412     }
2413 #endif
2414
2415     if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
2416         av_dump_format(oc, nb_output_files - 1, oc->filename, 1);
2417         av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", nb_output_files - 1);
2418         exit_program(1);
2419     }
2420
2421     /* check if all codec options have been used */
2422     unused_opts = strip_specifiers(o->g->codec_opts);
2423     for (i = of->ost_index; i < nb_output_streams; i++) {
2424         e = NULL;
2425         while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
2426                                 AV_DICT_IGNORE_SUFFIX)))
2427             av_dict_set(&unused_opts, e->key, NULL, 0);
2428     }
2429
2430     e = NULL;
2431     while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
2432         const AVClass *class = avcodec_get_class();
2433         const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
2434                                              AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2435         const AVClass *fclass = avformat_get_class();
2436         const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
2437                                               AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2438         if (!option || foption)
2439             continue;
2440
2441
2442         if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
2443             av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
2444                    "output file #%d (%s) is not an encoding option.\n", e->key,
2445                    option->help ? option->help : "", nb_output_files - 1,
2446                    filename);
2447             exit_program(1);
2448         }
2449
2450         // gop_timecode is injected by generic code but not always used
2451         if (!strcmp(e->key, "gop_timecode"))
2452             continue;
2453
2454         av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
2455                "output file #%d (%s) has not been used for any stream. The most "
2456                "likely reason is either wrong type (e.g. a video option with "
2457                "no video streams) or that it is a private option of some encoder "
2458                "which was not actually used for any stream.\n", e->key,
2459                option->help ? option->help : "", nb_output_files - 1, filename);
2460     }
2461     av_dict_free(&unused_opts);
2462
2463     /* set the decoding_needed flags and create simple filtergraphs */
2464     for (i = of->ost_index; i < nb_output_streams; i++) {
2465         OutputStream *ost = output_streams[i];
2466
2467         if (ost->encoding_needed && ost->source_index >= 0) {
2468             InputStream *ist = input_streams[ost->source_index];
2469             ist->decoding_needed |= DECODING_FOR_OST;
2470
2471             if (ost->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
2472                 ost->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
2473                 err = init_simple_filtergraph(ist, ost);
2474                 if (err < 0) {
2475                     av_log(NULL, AV_LOG_ERROR,
2476                            "Error initializing a simple filtergraph between streams "
2477                            "%d:%d->%d:%d\n", ist->file_index, ost->source_index,
2478                            nb_output_files - 1, ost->st->index);
2479                     exit_program(1);
2480                 }
2481             }
2482         }
2483
2484         /* set the filter output constraints */
2485         if (ost->filter) {
2486             OutputFilter *f = ost->filter;
2487             int count;
2488             switch (ost->enc_ctx->codec_type) {
2489             case AVMEDIA_TYPE_VIDEO:
2490                 f->frame_rate = ost->frame_rate;
2491                 f->width      = ost->enc_ctx->width;
2492                 f->height     = ost->enc_ctx->height;
2493                 if (ost->enc_ctx->pix_fmt != AV_PIX_FMT_NONE) {
2494                     f->format = ost->enc_ctx->pix_fmt;
2495                 } else if (ost->enc->pix_fmts) {
2496                     count = 0;
2497                     while (ost->enc->pix_fmts[count] != AV_PIX_FMT_NONE)
2498                         count++;
2499                     f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
2500                     if (!f->formats)
2501                         exit_program(1);
2502                     memcpy(f->formats, ost->enc->pix_fmts, (count + 1) * sizeof(*f->formats));
2503                 }
2504                 break;
2505             case AVMEDIA_TYPE_AUDIO:
2506                 if (ost->enc_ctx->sample_fmt != AV_SAMPLE_FMT_NONE) {
2507                     f->format = ost->enc_ctx->sample_fmt;
2508                 } else if (ost->enc->sample_fmts) {
2509                     count = 0;
2510                     while (ost->enc->sample_fmts[count] != AV_SAMPLE_FMT_NONE)
2511                         count++;
2512                     f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
2513                     if (!f->formats)
2514                         exit_program(1);
2515                     memcpy(f->formats, ost->enc->sample_fmts, (count + 1) * sizeof(*f->formats));
2516                 }
2517                 if (ost->enc_ctx->sample_rate) {
2518                     f->sample_rate = ost->enc_ctx->sample_rate;
2519                 } else if (ost->enc->supported_samplerates) {
2520                     count = 0;
2521                     while (ost->enc->supported_samplerates[count])
2522                         count++;
2523                     f->sample_rates = av_mallocz_array(count + 1, sizeof(*f->sample_rates));
2524                     if (!f->sample_rates)
2525                         exit_program(1);
2526                     memcpy(f->sample_rates, ost->enc->supported_samplerates,
2527                            (count + 1) * sizeof(*f->sample_rates));
2528                 }
2529                 if (ost->enc_ctx->channels) {
2530                     f->channel_layout = av_get_default_channel_layout(ost->enc_ctx->channels);
2531                 } else if (ost->enc->channel_layouts) {
2532                     count = 0;
2533                     while (ost->enc->channel_layouts[count])
2534                         count++;
2535                     f->channel_layouts = av_mallocz_array(count + 1, sizeof(*f->channel_layouts));
2536                     if (!f->channel_layouts)
2537                         exit_program(1);
2538                     memcpy(f->channel_layouts, ost->enc->channel_layouts,
2539                            (count + 1) * sizeof(*f->channel_layouts));
2540                 }
2541                 break;
2542             }
2543         }
2544     }
2545
2546     /* check filename in case of an image number is expected */
2547     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
2548         if (!av_filename_number_test(oc->filename)) {
2549             print_error(oc->filename, AVERROR(EINVAL));
2550             exit_program(1);
2551         }
2552     }
2553
2554     if (!(oc->oformat->flags & AVFMT_NOSTREAMS) && !input_stream_potentially_available) {
2555         av_log(NULL, AV_LOG_ERROR,
2556                "No input streams but output needs an input stream\n");
2557         exit_program(1);
2558     }
2559
2560     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
2561         /* test if it already exists to avoid losing precious files */
2562         assert_file_overwrite(filename);
2563
2564         /* open the file */
2565         if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
2566                               &oc->interrupt_callback,
2567                               &of->opts)) < 0) {
2568             print_error(filename, err);
2569             exit_program(1);
2570         }
2571     } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
2572         assert_file_overwrite(filename);
2573
2574     if (o->mux_preload) {
2575         av_dict_set_int(&of->opts, "preload", o->mux_preload*AV_TIME_BASE, 0);
2576     }
2577     oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
2578
2579     /* copy metadata */
2580     for (i = 0; i < o->nb_metadata_map; i++) {
2581         char *p;
2582         int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
2583
2584         if (in_file_index >= nb_input_files) {
2585             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
2586             exit_program(1);
2587         }
2588         copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
2589                       in_file_index >= 0 ?
2590                       input_files[in_file_index]->ctx : NULL, o);
2591     }
2592
2593     /* copy chapters */
2594     if (o->chapters_input_file >= nb_input_files) {
2595         if (o->chapters_input_file == INT_MAX) {
2596             /* copy chapters from the first input file that has them*/
2597             o->chapters_input_file = -1;
2598             for (i = 0; i < nb_input_files; i++)
2599                 if (input_files[i]->ctx->nb_chapters) {
2600                     o->chapters_input_file = i;
2601                     break;
2602                 }
2603         } else {
2604             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
2605                    o->chapters_input_file);
2606             exit_program(1);
2607         }
2608     }
2609     if (o->chapters_input_file >= 0)
2610         copy_chapters(input_files[o->chapters_input_file], of,
2611                       !o->metadata_chapters_manual);
2612
2613     /* copy global metadata by default */
2614     if (!o->metadata_global_manual && nb_input_files){
2615         av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
2616                      AV_DICT_DONT_OVERWRITE);
2617         if(o->recording_time != INT64_MAX)
2618             av_dict_set(&oc->metadata, "duration", NULL, 0);
2619         av_dict_set(&oc->metadata, "creation_time", NULL, 0);
2620     }
2621     if (!o->metadata_streams_manual)
2622         for (i = of->ost_index; i < nb_output_streams; i++) {
2623             InputStream *ist;
2624             if (output_streams[i]->source_index < 0)         /* this is true e.g. for attached files */
2625                 continue;
2626             ist = input_streams[output_streams[i]->source_index];
2627             av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
2628             if (!output_streams[i]->stream_copy) {
2629                 av_dict_set(&output_streams[i]->st->metadata, "encoder", NULL, 0);
2630             }
2631         }
2632
2633     /* process manually set programs */
2634     for (i = 0; i < o->nb_program; i++) {
2635         const char *p = o->program[i].u.str;
2636         int progid = i+1;
2637         AVProgram *program;
2638
2639         while(*p) {
2640             const char *p2 = av_get_token(&p, ":");
2641             const char *to_dealloc = p2;
2642             char *key;
2643             if (!p2)
2644                 break;
2645
2646             if(*p) p++;
2647
2648             key = av_get_token(&p2, "=");
2649             if (!key || !*p2) {
2650                 av_freep(&to_dealloc);
2651                 av_freep(&key);
2652                 break;
2653             }
2654             p2++;
2655
2656             if (!strcmp(key, "program_num"))
2657                 progid = strtol(p2, NULL, 0);
2658             av_freep(&to_dealloc);
2659             av_freep(&key);
2660         }
2661
2662         program = av_new_program(oc, progid);
2663
2664         p = o->program[i].u.str;
2665         while(*p) {
2666             const char *p2 = av_get_token(&p, ":");
2667             const char *to_dealloc = p2;
2668             char *key;
2669             if (!p2)
2670                 break;
2671             if(*p) p++;
2672
2673             key = av_get_token(&p2, "=");
2674             if (!key) {
2675                 av_log(NULL, AV_LOG_FATAL,
2676                        "No '=' character in program string %s.\n",
2677                        p2);
2678                 exit_program(1);
2679             }
2680             if (!*p2)
2681                 exit_program(1);
2682             p2++;
2683
2684             if (!strcmp(key, "title")) {
2685                 av_dict_set(&program->metadata, "title", p2, 0);
2686             } else if (!strcmp(key, "program_num")) {
2687             } else if (!strcmp(key, "st")) {
2688                 int st_num = strtol(p2, NULL, 0);
2689                 av_program_add_stream_index(oc, progid, st_num);
2690             } else {
2691                 av_log(NULL, AV_LOG_FATAL, "Unknown program key %s.\n", key);
2692                 exit_program(1);
2693             }
2694             av_freep(&to_dealloc);
2695             av_freep(&key);
2696         }
2697     }
2698
2699     /* process manually set metadata */
2700     for (i = 0; i < o->nb_metadata; i++) {
2701         AVDictionary **m;
2702         char type, *val;
2703         const char *stream_spec;
2704         int index = 0, j, ret = 0;
2705
2706         val = strchr(o->metadata[i].u.str, '=');
2707         if (!val) {
2708             av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
2709                    o->metadata[i].u.str);
2710             exit_program(1);
2711         }
2712         *val++ = 0;
2713
2714         parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
2715         if (type == 's') {
2716             for (j = 0; j < oc->nb_streams; j++) {
2717                 ost = output_streams[nb_output_streams - oc->nb_streams + j];
2718                 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2719                     if (!strcmp(o->metadata[i].u.str, "rotate")) {
2720                         char *tail;
2721                         double theta = av_strtod(val, &tail);
2722                         if (!*tail) {
2723                             ost->rotate_overridden = 1;
2724                             ost->rotate_override_value = theta;
2725                         }
2726                     } else {
2727                         av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2728                     }
2729                 } else if (ret < 0)
2730                     exit_program(1);
2731             }
2732         }
2733         else {
2734             switch (type) {
2735             case 'g':
2736                 m = &oc->metadata;
2737                 break;
2738             case 'c':
2739                 if (index < 0 || index >= oc->nb_chapters) {
2740                     av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2741                     exit_program(1);
2742                 }
2743                 m = &oc->chapters[index]->metadata;
2744                 break;
2745             case 'p':
2746                 if (index < 0 || index >= oc->nb_programs) {
2747                     av_log(NULL, AV_LOG_FATAL, "Invalid program index %d in metadata specifier.\n", index);
2748                     exit_program(1);
2749                 }
2750                 m = &oc->programs[index]->metadata;
2751                 break;
2752             default:
2753                 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2754                 exit_program(1);
2755             }
2756             av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2757         }
2758     }
2759
2760     return 0;
2761 }
2762
2763 static int opt_target(void *optctx, const char *opt, const char *arg)
2764 {
2765     OptionsContext *o = optctx;
2766     enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2767     static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2768
2769     if (!strncmp(arg, "pal-", 4)) {
2770         norm = PAL;
2771         arg += 4;
2772     } else if (!strncmp(arg, "ntsc-", 5)) {
2773         norm = NTSC;
2774         arg += 5;
2775     } else if (!strncmp(arg, "film-", 5)) {
2776         norm = FILM;
2777         arg += 5;
2778     } else {
2779         /* Try to determine PAL/NTSC by peeking in the input files */
2780         if (nb_input_files) {
2781             int i, j, fr;
2782             for (j = 0; j < nb_input_files; j++) {
2783                 for (i = 0; i < input_files[j]->nb_streams; i++) {
2784                     AVStream *st = input_files[j]->ctx->streams[i];
2785                     if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO)
2786                         continue;
2787                     fr = st->time_base.den * 1000 / st->time_base.num;
2788                     if (fr == 25000) {
2789                         norm = PAL;
2790                         break;
2791                     } else if ((fr == 29970) || (fr == 23976)) {
2792                         norm = NTSC;
2793                         break;
2794                     }
2795                 }
2796                 if (norm != UNKNOWN)
2797                     break;
2798             }
2799         }
2800         if (norm != UNKNOWN)
2801             av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2802     }
2803
2804     if (norm == UNKNOWN) {
2805         av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2806         av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2807         av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2808         exit_program(1);
2809     }
2810
2811     if (!strcmp(arg, "vcd")) {
2812         opt_video_codec(o, "c:v", "mpeg1video");
2813         opt_audio_codec(o, "c:a", "mp2");
2814         parse_option(o, "f", "vcd", options);
2815
2816         parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2817         parse_option(o, "r", frame_rates[norm], options);
2818         opt_default(NULL, "g", norm == PAL ? "15" : "18");
2819
2820         opt_default(NULL, "b:v", "1150000");
2821         opt_default(NULL, "maxrate:v", "1150000");
2822         opt_default(NULL, "minrate:v", "1150000");
2823         opt_default(NULL, "bufsize:v", "327680"); // 40*1024*8;
2824
2825         opt_default(NULL, "b:a", "224000");
2826         parse_option(o, "ar", "44100", options);
2827         parse_option(o, "ac", "2", options);
2828
2829         opt_default(NULL, "packetsize", "2324");
2830         opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
2831
2832         /* We have to offset the PTS, so that it is consistent with the SCR.
2833            SCR starts at 36000, but the first two packs contain only padding
2834            and the first pack from the other stream, respectively, may also have
2835            been written before.
2836            So the real data starts at SCR 36000+3*1200. */
2837         o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2838     } else if (!strcmp(arg, "svcd")) {
2839
2840         opt_video_codec(o, "c:v", "mpeg2video");
2841         opt_audio_codec(o, "c:a", "mp2");
2842         parse_option(o, "f", "svcd", options);
2843
2844         parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2845         parse_option(o, "r", frame_rates[norm], options);
2846         parse_option(o, "pix_fmt", "yuv420p", options);
2847         opt_default(NULL, "g", norm == PAL ? "15" : "18");
2848
2849         opt_default(NULL, "b:v", "2040000");
2850         opt_default(NULL, "maxrate:v", "2516000");
2851         opt_default(NULL, "minrate:v", "0"); // 1145000;
2852         opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2853         opt_default(NULL, "scan_offset", "1");
2854
2855         opt_default(NULL, "b:a", "224000");
2856         parse_option(o, "ar", "44100", options);
2857
2858         opt_default(NULL, "packetsize", "2324");
2859
2860     } else if (!strcmp(arg, "dvd")) {
2861
2862         opt_video_codec(o, "c:v", "mpeg2video");
2863         opt_audio_codec(o, "c:a", "ac3");
2864         parse_option(o, "f", "dvd", options);
2865
2866         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2867         parse_option(o, "r", frame_rates[norm], options);
2868         parse_option(o, "pix_fmt", "yuv420p", options);
2869         opt_default(NULL, "g", norm == PAL ? "15" : "18");
2870
2871         opt_default(NULL, "b:v", "6000000");
2872         opt_default(NULL, "maxrate:v", "9000000");
2873         opt_default(NULL, "minrate:v", "0"); // 1500000;
2874         opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2875
2876         opt_default(NULL, "packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
2877         opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2878
2879         opt_default(NULL, "b:a", "448000");
2880         parse_option(o, "ar", "48000", options);
2881
2882     } else if (!strncmp(arg, "dv", 2)) {
2883
2884         parse_option(o, "f", "dv", options);
2885
2886         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2887         parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2888                           norm == PAL ? "yuv420p" : "yuv411p", options);
2889         parse_option(o, "r", frame_rates[norm], options);
2890
2891         parse_option(o, "ar", "48000", options);
2892         parse_option(o, "ac", "2", options);
2893
2894     } else {
2895         av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2896         return AVERROR(EINVAL);
2897     }
2898
2899     av_dict_copy(&o->g->codec_opts,  codec_opts, AV_DICT_DONT_OVERWRITE);
2900     av_dict_copy(&o->g->format_opts, format_opts, AV_DICT_DONT_OVERWRITE);
2901
2902     return 0;
2903 }
2904
2905 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2906 {
2907     av_free (vstats_filename);
2908     vstats_filename = av_strdup (arg);
2909     return 0;
2910 }
2911
2912 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2913 {
2914     char filename[40];
2915     time_t today2 = time(NULL);
2916     struct tm *today = localtime(&today2);
2917
2918     if (!today) { // maybe tomorrow
2919         av_log(NULL, AV_LOG_FATAL, "Unable to get current time: %s\n", strerror(errno));
2920         exit_program(1);
2921     }
2922
2923     snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2924              today->tm_sec);
2925     return opt_vstats_file(NULL, opt, filename);
2926 }
2927
2928 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2929 {
2930     OptionsContext *o = optctx;
2931     return parse_option(o, "frames:v", arg, options);
2932 }
2933
2934 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2935 {
2936     OptionsContext *o = optctx;
2937     return parse_option(o, "frames:a", arg, options);
2938 }
2939
2940 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2941 {
2942     OptionsContext *o = optctx;
2943     return parse_option(o, "frames:d", arg, options);
2944 }
2945
2946 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2947 {
2948     int ret;
2949     AVDictionary *cbak = codec_opts;
2950     AVDictionary *fbak = format_opts;
2951     codec_opts = NULL;
2952     format_opts = NULL;
2953
2954     ret = opt_default(NULL, opt, arg);
2955
2956     av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2957     av_dict_copy(&o->g->format_opts, format_opts, 0);
2958     av_dict_free(&codec_opts);
2959     av_dict_free(&format_opts);
2960     codec_opts = cbak;
2961     format_opts = fbak;
2962
2963     return ret;
2964 }
2965
2966 static int opt_preset(void *optctx, const char *opt, const char *arg)
2967 {
2968     OptionsContext *o = optctx;
2969     FILE *f=NULL;
2970     char filename[1000], line[1000], tmp_line[1000];
2971     const char *codec_name = NULL;
2972
2973     tmp_line[0] = *opt;
2974     tmp_line[1] = 0;
2975     MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2976
2977     if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2978         if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2979             av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2980         }else
2981             av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2982         exit_program(1);
2983     }
2984
2985     while (fgets(line, sizeof(line), f)) {
2986         char *key = tmp_line, *value, *endptr;
2987
2988         if (strcspn(line, "#\n\r") == 0)
2989             continue;
2990         av_strlcpy(tmp_line, line, sizeof(tmp_line));
2991         if (!av_strtok(key,   "=",    &value) ||
2992             !av_strtok(value, "\r\n", &endptr)) {
2993             av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2994             exit_program(1);
2995         }
2996         av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2997
2998         if      (!strcmp(key, "acodec")) opt_audio_codec   (o, key, value);
2999         else if (!strcmp(key, "vcodec")) opt_video_codec   (o, key, value);
3000         else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
3001         else if (!strcmp(key, "dcodec")) opt_data_codec    (o, key, value);
3002         else if (opt_default_new(o, key, value) < 0) {
3003             av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
3004                    filename, line, key, value);
3005             exit_program(1);
3006         }
3007     }
3008
3009     fclose(f);
3010
3011     return 0;
3012 }
3013
3014 static int opt_old2new(void *optctx, const char *opt, const char *arg)
3015 {
3016     OptionsContext *o = optctx;
3017     char *s = av_asprintf("%s:%c", opt + 1, *opt);
3018     int ret = parse_option(o, s, arg, options);
3019     av_free(s);
3020     return ret;
3021 }
3022
3023 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
3024 {
3025     OptionsContext *o = optctx;
3026
3027     if(!strcmp(opt, "ab")){
3028         av_dict_set(&o->g->codec_opts, "b:a", arg, 0);
3029         return 0;
3030     } else if(!strcmp(opt, "b")){
3031         av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
3032         av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
3033         return 0;
3034     }
3035     av_dict_set(&o->g->codec_opts, opt, arg, 0);
3036     return 0;
3037 }
3038
3039 static int opt_qscale(void *optctx, const char *opt, const char *arg)
3040 {
3041     OptionsContext *o = optctx;
3042     char *s;
3043     int ret;
3044     if(!strcmp(opt, "qscale")){
3045         av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
3046         return parse_option(o, "q:v", arg, options);
3047     }
3048     s = av_asprintf("q%s", opt + 6);
3049     ret = parse_option(o, s, arg, options);
3050     av_free(s);
3051     return ret;
3052 }
3053
3054 static int opt_profile(void *optctx, const char *opt, const char *arg)
3055 {
3056     OptionsContext *o = optctx;
3057     if(!strcmp(opt, "profile")){
3058         av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
3059         av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
3060         return 0;
3061     }
3062     av_dict_set(&o->g->codec_opts, opt, arg, 0);
3063     return 0;
3064 }
3065
3066 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
3067 {
3068     OptionsContext *o = optctx;
3069     return parse_option(o, "filter:v", arg, options);
3070 }
3071
3072 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
3073 {
3074     OptionsContext *o = optctx;
3075     return parse_option(o, "filter:a", arg, options);
3076 }
3077
3078 static int opt_vsync(void *optctx, const char *opt, const char *arg)
3079 {
3080     if      (!av_strcasecmp(arg, "cfr"))         video_sync_method = VSYNC_CFR;
3081     else if (!av_strcasecmp(arg, "vfr"))         video_sync_method = VSYNC_VFR;
3082     else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
3083     else if (!av_strcasecmp(arg, "drop"))        video_sync_method = VSYNC_DROP;
3084
3085     if (video_sync_method == VSYNC_AUTO)
3086         video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
3087     return 0;
3088 }
3089
3090 static int opt_timecode(void *optctx, const char *opt, const char *arg)
3091 {
3092     OptionsContext *o = optctx;
3093     char *tcr = av_asprintf("timecode=%s", arg);
3094     int ret = parse_option(o, "metadata:g", tcr, options);
3095     if (ret >= 0)
3096         ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
3097     av_free(tcr);
3098     return ret;
3099 }
3100
3101 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
3102 {
3103     OptionsContext *o = optctx;
3104     char layout_str[32];
3105     char *stream_str;
3106     char *ac_str;
3107     int ret, channels, ac_str_size;
3108     uint64_t layout;
3109
3110     layout = av_get_channel_layout(arg);
3111     if (!layout) {
3112         av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
3113         return AVERROR(EINVAL);
3114     }
3115     snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
3116     ret = opt_default_new(o, opt, layout_str);
3117     if (ret < 0)
3118         return ret;
3119
3120     /* set 'ac' option based on channel layout */
3121     channels = av_get_channel_layout_nb_channels(layout);
3122     snprintf(layout_str, sizeof(layout_str), "%d", channels);
3123     stream_str = strchr(opt, ':');
3124     ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
3125     ac_str = av_mallocz(ac_str_size);
3126     if (!ac_str)
3127         return AVERROR(ENOMEM);
3128     av_strlcpy(ac_str, "ac", 3);
3129     if (stream_str)
3130         av_strlcat(ac_str, stream_str, ac_str_size);
3131     ret = parse_option(o, ac_str, layout_str, options);
3132     av_free(ac_str);
3133
3134     return ret;
3135 }
3136
3137 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
3138 {
3139     OptionsContext *o = optctx;
3140     return parse_option(o, "q:a", arg, options);
3141 }
3142
3143 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
3144 {
3145     GROW_ARRAY(filtergraphs, nb_filtergraphs);
3146     if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
3147         return AVERROR(ENOMEM);
3148     filtergraphs[nb_filtergraphs - 1]->index      = nb_filtergraphs - 1;
3149     filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
3150     if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
3151         return AVERROR(ENOMEM);
3152
3153     input_stream_potentially_available = 1;
3154
3155     return 0;
3156 }
3157
3158 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
3159 {
3160     uint8_t *graph_desc = read_file(arg);
3161     if (!graph_desc)
3162         return AVERROR(EINVAL);
3163
3164     GROW_ARRAY(filtergraphs, nb_filtergraphs);
3165     if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
3166         return AVERROR(ENOMEM);
3167     filtergraphs[nb_filtergraphs - 1]->index      = nb_filtergraphs - 1;
3168     filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
3169
3170     input_stream_potentially_available = 1;
3171
3172     return 0;
3173 }
3174
3175 void show_help_default(const char *opt, const char *arg)
3176 {
3177     /* per-file options have at least one of those set */
3178     const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
3179     int show_advanced = 0, show_avoptions = 0;
3180
3181     if (opt && *opt) {
3182         if (!strcmp(opt, "long"))
3183             show_advanced = 1;
3184         else if (!strcmp(opt, "full"))
3185             show_advanced = show_avoptions = 1;
3186         else
3187             av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
3188     }
3189
3190     show_usage();
3191
3192     printf("Getting help:\n"
3193            "    -h      -- print basic options\n"
3194            "    -h long -- print more options\n"
3195            "    -h full -- print all options (including all format and codec specific options, very long)\n"
3196            "    -h type=name -- print all options for the named decoder/encoder/demuxer/muxer/filter\n"
3197            "    See man %s for detailed description of the options.\n"
3198            "\n", program_name);
3199
3200     show_help_options(options, "Print help / information / capabilities:",
3201                       OPT_EXIT, 0, 0);
3202
3203     show_help_options(options, "Global options (affect whole program "
3204                       "instead of just one file:",
3205                       0, per_file | OPT_EXIT | OPT_EXPERT, 0);
3206     if (show_advanced)
3207         show_help_options(options, "Advanced global options:", OPT_EXPERT,
3208                           per_file | OPT_EXIT, 0);
3209
3210     show_help_options(options, "Per-file main options:", 0,
3211                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
3212                       OPT_EXIT, per_file);
3213     if (show_advanced)
3214         show_help_options(options, "Advanced per-file options:",
3215                           OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
3216
3217     show_help_options(options, "Video options:",
3218                       OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
3219     if (show_advanced)
3220         show_help_options(options, "Advanced Video options:",
3221                           OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
3222
3223     show_help_options(options, "Audio options:",
3224                       OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
3225     if (show_advanced)
3226         show_help_options(options, "Advanced Audio options:",
3227                           OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
3228     show_help_options(options, "Subtitle options:",
3229                       OPT_SUBTITLE, 0, 0);
3230     printf("\n");
3231
3232     if (show_avoptions) {
3233         int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
3234         show_help_children(avcodec_get_class(), flags);
3235         show_help_children(avformat_get_class(), flags);
3236 #if CONFIG_SWSCALE
3237         show_help_children(sws_get_class(), flags);
3238 #endif
3239         show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
3240         show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM);
3241     }
3242 }
3243
3244 void show_usage(void)
3245 {
3246     av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
3247     av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
3248     av_log(NULL, AV_LOG_INFO, "\n");
3249 }
3250
3251 enum OptGroup {
3252     GROUP_OUTFILE,
3253     GROUP_INFILE,
3254 };
3255
3256 static const OptionGroupDef groups[] = {
3257     [GROUP_OUTFILE] = { "output url",  NULL, OPT_OUTPUT },
3258     [GROUP_INFILE]  = { "input url",   "i",  OPT_INPUT },
3259 };
3260
3261 static int open_files(OptionGroupList *l, const char *inout,
3262                       int (*open_file)(OptionsContext*, const char*))
3263 {
3264     int i, ret;
3265
3266     for (i = 0; i < l->nb_groups; i++) {
3267         OptionGroup *g = &l->groups[i];
3268         OptionsContext o;
3269
3270         init_options(&o);
3271         o.g = g;
3272
3273         ret = parse_optgroup(&o, g);
3274         if (ret < 0) {
3275             av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
3276                    "%s.\n", inout, g->arg);
3277             return ret;
3278         }
3279
3280         av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
3281         ret = open_file(&o, g->arg);
3282         uninit_options(&o);
3283         if (ret < 0) {
3284             av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
3285                    inout, g->arg);
3286             return ret;
3287         }
3288         av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
3289     }
3290
3291     return 0;
3292 }
3293
3294 int ffmpeg_parse_options(int argc, char **argv)
3295 {
3296     OptionParseContext octx;
3297     uint8_t error[128];
3298     int ret;
3299
3300     memset(&octx, 0, sizeof(octx));
3301
3302     /* split the commandline into an internal representation */
3303     ret = split_commandline(&octx, argc, argv, options, groups,
3304                             FF_ARRAY_ELEMS(groups));
3305     if (ret < 0) {
3306         av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
3307         goto fail;
3308     }
3309
3310     /* apply global options */
3311     ret = parse_optgroup(NULL, &octx.global_opts);
3312     if (ret < 0) {
3313         av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
3314         goto fail;
3315     }
3316
3317     /* configure terminal and setup signal handlers */
3318     term_init();
3319
3320     /* open input files */
3321     ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
3322     if (ret < 0) {
3323         av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
3324         goto fail;
3325     }
3326
3327     /* create the complex filtergraphs */
3328     ret = init_complex_filters();
3329     if (ret < 0) {
3330         av_log(NULL, AV_LOG_FATAL, "Error initializing complex filters.\n");
3331         goto fail;
3332     }
3333
3334     /* open output files */
3335     ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
3336     if (ret < 0) {
3337         av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
3338         goto fail;
3339     }
3340
3341     check_filter_outputs();
3342
3343 fail:
3344     uninit_parse_context(&octx);
3345     if (ret < 0) {
3346         av_strerror(ret, error, sizeof(error));
3347         av_log(NULL, AV_LOG_FATAL, "%s\n", error);
3348     }
3349     return ret;
3350 }
3351
3352 static int opt_progress(void *optctx, const char *opt, const char *arg)
3353 {
3354     AVIOContext *avio = NULL;
3355     int ret;
3356
3357     if (!strcmp(arg, "-"))
3358         arg = "pipe:";
3359     ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
3360     if (ret < 0) {
3361         av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
3362                arg, av_err2str(ret));
3363         return ret;
3364     }
3365     progress_avio = avio;
3366     return 0;
3367 }
3368
3369 #define OFFSET(x) offsetof(OptionsContext, x)
3370 const OptionDef options[] = {
3371     /* main options */
3372     CMDUTILS_COMMON_OPTIONS
3373     { "f",              HAS_ARG | OPT_STRING | OPT_OFFSET |
3374                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(format) },
3375         "force format", "fmt" },
3376     { "y",              OPT_BOOL,                                    {              &file_overwrite },
3377         "overwrite output files" },
3378     { "n",              OPT_BOOL,                                    {              &no_file_overwrite },
3379         "never overwrite output files" },
3380     { "ignore_unknown", OPT_BOOL,                                    {              &ignore_unknown_streams },
3381         "Ignore unknown stream types" },
3382     { "copy_unknown",   OPT_BOOL | OPT_EXPERT,                       {              &copy_unknown_streams },
3383         "Copy unknown stream types" },
3384     { "c",              HAS_ARG | OPT_STRING | OPT_SPEC |
3385                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(codec_names) },
3386         "codec name", "codec" },
3387     { "codec",          HAS_ARG | OPT_STRING | OPT_SPEC |
3388                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(codec_names) },
3389         "codec name", "codec" },
3390     { "pre",            HAS_ARG | OPT_STRING | OPT_SPEC |
3391                         OPT_OUTPUT,                                  { .off       = OFFSET(presets) },
3392         "preset name", "preset" },
3393     { "map",            HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3394                         OPT_OUTPUT,                                  { .func_arg = opt_map },
3395         "set input stream mapping",
3396         "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
3397     { "map_channel",    HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
3398         "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
3399     { "map_metadata",   HAS_ARG | OPT_STRING | OPT_SPEC |
3400                         OPT_OUTPUT,                                  { .off       = OFFSET(metadata_map) },
3401         "set metadata information of outfile from infile",
3402         "outfile[,metadata]:infile[,metadata]" },
3403     { "map_chapters",   HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
3404                         OPT_OUTPUT,                                  { .off = OFFSET(chapters_input_file) },
3405         "set chapters mapping", "input_file_index" },
3406     { "t",              HAS_ARG | OPT_TIME | OPT_OFFSET |
3407                         OPT_INPUT | OPT_OUTPUT,                      { .off = OFFSET(recording_time) },
3408         "record or transcode \"duration\" seconds of audio/video",
3409         "duration" },
3410     { "to",             HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_OUTPUT,  { .off = OFFSET(stop_time) },
3411         "record or transcode stop time", "time_stop" },
3412     { "fs",             HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
3413         "set the limit file size in bytes", "limit_size" },
3414     { "ss",             HAS_ARG | OPT_TIME | OPT_OFFSET |
3415                         OPT_INPUT | OPT_OUTPUT,                      { .off = OFFSET(start_time) },
3416         "set the start time offset", "time_off" },
3417     { "sseof",          HAS_ARG | OPT_TIME | OPT_OFFSET |
3418                         OPT_INPUT | OPT_OUTPUT,                      { .off = OFFSET(start_time_eof) },
3419         "set the start time offset relative to EOF", "time_off" },
3420     { "seek_timestamp", HAS_ARG | OPT_INT | OPT_OFFSET |
3421                         OPT_INPUT,                                   { .off = OFFSET(seek_timestamp) },
3422         "enable/disable seeking by timestamp with -ss" },
3423     { "accurate_seek",  OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
3424                         OPT_INPUT,                                   { .off = OFFSET(accurate_seek) },
3425         "enable/disable accurate seeking with -ss" },
3426     { "itsoffset",      HAS_ARG | OPT_TIME | OPT_OFFSET |
3427                         OPT_EXPERT | OPT_INPUT,                      { .off = OFFSET(input_ts_offset) },
3428         "set the input ts offset", "time_off" },
3429     { "itsscale",       HAS_ARG | OPT_DOUBLE | OPT_SPEC |
3430                         OPT_EXPERT | OPT_INPUT,                      { .off = OFFSET(ts_scale) },
3431         "set the input ts scale", "scale" },
3432     { "timestamp",      HAS_ARG | OPT_PERFILE | OPT_OUTPUT,          { .func_arg = opt_recording_timestamp },
3433         "set the recording timestamp ('now' to set the current time)", "time" },
3434     { "metadata",       HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
3435         "add metadata", "string=string" },
3436     { "program",        HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(program) },
3437         "add program with specified streams", "title=string:st=number..." },
3438     { "dframes",        HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3439                         OPT_OUTPUT,                                  { .func_arg = opt_data_frames },
3440         "set the number of data frames to output", "number" },
3441     { "benchmark",      OPT_BOOL | OPT_EXPERT,                       { &do_benchmark },
3442         "add timings for benchmarking" },
3443     { "benchmark_all",  OPT_BOOL | OPT_EXPERT,                       { &do_benchmark_all },
3444       "add timings for each task" },
3445     { "progress",       HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_progress },
3446       "write program-readable progress information", "url" },
3447     { "stdin",          OPT_BOOL | OPT_EXPERT,                       { &stdin_interaction },
3448       "enable or disable interaction on standard input" },
3449     { "timelimit",      HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_timelimit },
3450         "set max runtime in seconds", "limit" },
3451     { "dump",           OPT_BOOL | OPT_EXPERT,                       { &do_pkt_dump },
3452         "dump each input packet" },
3453     { "hex",            OPT_BOOL | OPT_EXPERT,                       { &do_hex_dump },
3454         "when dumping packets, also dump the payload" },
3455     { "re",             OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3456                         OPT_INPUT,                                   { .off = OFFSET(rate_emu) },
3457         "read input at native frame rate", "" },
3458     { "target",         HAS_ARG | OPT_PERFILE | OPT_OUTPUT,          { .func_arg = opt_target },
3459         "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\" or \"dv50\" "
3460         "with optional prefixes \"pal-\", \"ntsc-\" or \"film-\")", "type" },
3461     { "vsync",          HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_vsync },
3462         "video sync method", "" },
3463     { "frame_drop_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,      { &frame_drop_threshold },
3464         "frame drop threshold", "" },
3465     { "async",          HAS_ARG | OPT_INT | OPT_EXPERT,              { &audio_sync_method },
3466         "audio sync method", "" },
3467     { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,          { &audio_drift_threshold },
3468         "audio drift threshold", "threshold" },
3469     { "copyts",         OPT_BOOL | OPT_EXPERT,                       { &copy_ts },
3470         "copy timestamps" },
3471     { "start_at_zero",  OPT_BOOL | OPT_EXPERT,                       { &start_at_zero },
3472         "shift input timestamps to start at 0 when using copyts" },
3473     { "copytb",         HAS_ARG | OPT_INT | OPT_EXPERT,              { &copy_tb },
3474         "copy input stream time base when stream copying", "mode" },
3475     { "shortest",       OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3476                         OPT_OUTPUT,                                  { .off = OFFSET(shortest) },
3477         "finish encoding within shortest input" },
3478     { "bitexact",       OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3479                         OPT_OUTPUT | OPT_INPUT,                      { .off = OFFSET(bitexact) },
3480         "bitexact mode" },
3481     { "apad",           OPT_STRING | HAS_ARG | OPT_SPEC |
3482                         OPT_OUTPUT,                                  { .off = OFFSET(apad) },
3483         "audio pad", "" },
3484     { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,       { &dts_delta_threshold },
3485         "timestamp discontinuity delta threshold", "threshold" },
3486     { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,       { &dts_error_threshold },
3487         "timestamp error delta threshold", "threshold" },
3488     { "xerror",         OPT_BOOL | OPT_EXPERT,                       { &exit_on_error },
3489         "exit on error", "error" },
3490     { "abort_on",       HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_abort_on },
3491         "abort on the specified condition flags", "flags" },
3492     { "copyinkf",       OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3493                         OPT_OUTPUT,                                  { .off = OFFSET(copy_initial_nonkeyframes) },
3494         "copy initial non-keyframes" },
3495     { "copypriorss",    OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT,   { .off = OFFSET(copy_prior_start) },
3496         "copy or discard frames before start time" },
3497     { "frames",         OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
3498         "set the number of frames to output", "number" },
3499     { "tag",            OPT_STRING | HAS_ARG | OPT_SPEC |
3500                         OPT_EXPERT | OPT_OUTPUT | OPT_INPUT,         { .off = OFFSET(codec_tags) },
3501         "force codec tag/fourcc", "fourcc/tag" },
3502     { "q",              HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
3503                         OPT_SPEC | OPT_OUTPUT,                       { .off = OFFSET(qscale) },
3504         "use fixed quality scale (VBR)", "q" },
3505     { "qscale",         HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3506                         OPT_OUTPUT,                                  { .func_arg = opt_qscale },
3507         "use fixed quality scale (VBR)", "q" },
3508     { "profile",        HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
3509         "set profile", "profile" },
3510     { "filter",         HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
3511         "set stream filtergraph", "filter_graph" },
3512     { "filter_threads",  HAS_ARG | OPT_INT,                          { &filter_nbthreads },
3513         "number of non-complex filter threads" },
3514     { "filter_script",  HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
3515         "read stream filtergraph description from a file", "filename" },
3516     { "reinit_filter",  HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT,    { .off = OFFSET(reinit_filters) },
3517         "reinit filtergraph on input parameter changes", "" },
3518     { "filter_complex", HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_filter_complex },
3519         "create a complex filtergraph", "graph_description" },
3520     { "filter_complex_threads", HAS_ARG | OPT_INT,                   { &filter_complex_nbthreads },
3521         "number of threads for -filter_complex" },
3522     { "lavfi",          HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_filter_complex },
3523         "create a complex filtergraph", "graph_description" },
3524     { "filter_complex_script", HAS_ARG | OPT_EXPERT,                 { .func_arg = opt_filter_complex_script },
3525         "read complex filtergraph description from a file", "filename" },
3526     { "stats",          OPT_BOOL,                                    { &print_stats },
3527         "print progress report during encoding", },
3528     { "attach",         HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3529                         OPT_OUTPUT,                                  { .func_arg = opt_attach },
3530         "add an attachment to the output file", "filename" },
3531     { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
3532                          OPT_EXPERT | OPT_INPUT,                     { .off = OFFSET(dump_attachment) },
3533         "extract an attachment into a file", "filename" },
3534     { "stream_loop", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_INPUT |
3535                         OPT_OFFSET,                                  { .off = OFFSET(loop) }, "set number of times input stream shall be looped", "loop count" },
3536     { "debug_ts",       OPT_BOOL | OPT_EXPERT,                       { &debug_ts },
3537         "print timestamp debugging info" },
3538     { "max_error_rate",  HAS_ARG | OPT_FLOAT,                        { &max_error_rate },
3539         "maximum error rate", "ratio of errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success." },
3540     { "discard",        OPT_STRING | HAS_ARG | OPT_SPEC |
3541                         OPT_INPUT,                                   { .off = OFFSET(discard) },
3542         "discard", "" },
3543     { "disposition",    OPT_STRING | HAS_ARG | OPT_SPEC |
3544                         OPT_OUTPUT,                                  { .off = OFFSET(disposition) },
3545         "disposition", "" },
3546     { "thread_queue_size", HAS_ARG | OPT_INT | OPT_OFFSET | OPT_EXPERT | OPT_INPUT,
3547                                                                      { .off = OFFSET(thread_queue_size) },
3548         "set the maximum number of queued packets from the demuxer" },
3549     { "find_stream_info", OPT_BOOL | OPT_PERFILE | OPT_INPUT | OPT_EXPERT, { &find_stream_info },
3550         "read and decode the streams to fill missing information with heuristics" },
3551
3552     /* video options */
3553     { "vframes",      OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_video_frames },
3554         "set the number of video frames to output", "number" },
3555     { "r",            OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC |
3556                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_rates) },
3557         "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3558     { "s",            OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC |
3559                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_sizes) },
3560         "set frame size (WxH or abbreviation)", "size" },
3561     { "aspect",       OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC |
3562                       OPT_OUTPUT,                                                { .off = OFFSET(frame_aspect_ratios) },
3563         "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3564     { "pix_fmt",      OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
3565                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_pix_fmts) },
3566         "set pixel format", "format" },
3567     { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG,                      { &frame_bits_per_raw_sample },
3568         "set the number of bits per raw sample", "number" },
3569     { "intra",        OPT_VIDEO | OPT_BOOL | OPT_EXPERT,                         { &intra_only },
3570         "deprecated use -g 1" },
3571     { "vn",           OPT_VIDEO | OPT_BOOL  | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) },
3572         "disable video" },
3573     { "rc_override",  OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
3574                       OPT_OUTPUT,                                                { .off = OFFSET(rc_overrides) },
3575         "rate control override for specific intervals", "override" },
3576     { "vcodec",       OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_INPUT |
3577                       OPT_OUTPUT,                                                { .func_arg = opt_video_codec },
3578         "force video codec ('copy' to copy stream)", "codec" },
3579     { "sameq",        OPT_VIDEO | OPT_EXPERT ,                                   { .func_arg = opt_sameq },
3580         "Removed" },
3581     { "same_quant",   OPT_VIDEO | OPT_EXPERT ,                                   { .func_arg = opt_sameq },
3582         "Removed" },
3583     { "timecode",     OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT,            { .func_arg = opt_timecode },
3584         "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
3585     { "pass",         OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT,     { .off = OFFSET(pass) },
3586         "select the pass number (1 to 3)", "n" },
3587     { "passlogfile",  OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
3588                       OPT_OUTPUT,                                                { .off = OFFSET(passlogfiles) },
3589         "select two pass log file name prefix", "prefix" },
3590     { "deinterlace",  OPT_VIDEO | OPT_BOOL | OPT_EXPERT,                         { &do_deinterlace },
3591         "this option is deprecated, use the yadif filter instead" },
3592     { "psnr",         OPT_VIDEO | OPT_BOOL | OPT_EXPERT,                         { &do_psnr },
3593         "calculate PSNR of compressed frames" },
3594     { "vstats",       OPT_VIDEO | OPT_EXPERT ,                                   { .func_arg = opt_vstats },
3595         "dump video coding statistics to file" },
3596     { "vstats_file",  OPT_VIDEO | HAS_ARG | OPT_EXPERT ,                         { .func_arg = opt_vstats_file },
3597         "dump video coding statistics to file", "file" },
3598     { "vstats_version",  OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT ,            { &vstats_version },
3599         "Version of the vstats format to use."},
3600     { "vf",           OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_video_filters },
3601         "set video filters", "filter_graph" },
3602     { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
3603                       OPT_OUTPUT,                                                { .off = OFFSET(intra_matrices) },
3604         "specify intra matrix coeffs", "matrix" },
3605     { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
3606                       OPT_OUTPUT,                                                { .off = OFFSET(inter_matrices) },
3607         "specify inter matrix coeffs", "matrix" },
3608     { "chroma_intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
3609                       OPT_OUTPUT,                                                { .off = OFFSET(chroma_intra_matrices) },
3610         "specify intra matrix coeffs", "matrix" },
3611     { "top",          OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_INT| OPT_SPEC |
3612                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(top_field_first) },
3613         "top=1/bottom=0/auto=-1 field first", "" },
3614     { "vtag",         OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_PERFILE |
3615                       OPT_INPUT | OPT_OUTPUT,                                    { .func_arg = opt_old2new },
3616         "force video tag/fourcc", "fourcc/tag" },
3617     { "qphist",       OPT_VIDEO | OPT_BOOL | OPT_EXPERT ,                        { &qp_hist },
3618         "show QP histogram" },
3619     { "force_fps",    OPT_VIDEO | OPT_BOOL | OPT_EXPERT  | OPT_SPEC |
3620                       OPT_OUTPUT,                                                { .off = OFFSET(force_fps) },
3621         "force the selected framerate, disable the best supported framerate selection" },
3622     { "streamid",     OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3623                       OPT_OUTPUT,                                                { .func_arg = opt_streamid },
3624         "set the value of an outfile streamid", "streamIndex:value" },
3625     { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3626                           OPT_SPEC | OPT_OUTPUT,                                 { .off = OFFSET(forced_key_frames) },
3627         "force key frames at specified timestamps", "timestamps" },
3628     { "ab",           OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT,            { .func_arg = opt_bitrate },
3629         "audio bitrate (please use -b:a)", "bitrate" },
3630     { "b",            OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT,            { .func_arg = opt_bitrate },
3631         "video bitrate (please use -b:v)", "bitrate" },
3632     { "hwaccel",          OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3633                           OPT_SPEC | OPT_INPUT,                                  { .off = OFFSET(hwaccels) },
3634         "use HW accelerated decoding", "hwaccel name" },
3635     { "hwaccel_device",   OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3636                           OPT_SPEC | OPT_INPUT,                                  { .off = OFFSET(hwaccel_devices) },
3637         "select a device for HW acceleration", "devicename" },
3638     { "hwaccel_output_format", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3639                           OPT_SPEC | OPT_INPUT,                                  { .off = OFFSET(hwaccel_output_formats) },
3640         "select output format used with HW accelerated decoding", "format" },
3641 #if CONFIG_VIDEOTOOLBOX
3642     { "videotoolbox_pixfmt", HAS_ARG | OPT_STRING | OPT_EXPERT, { &videotoolbox_pixfmt}, "" },
3643 #endif
3644     { "hwaccels",         OPT_EXIT,                                              { .func_arg = show_hwaccels },
3645         "show available HW acceleration methods" },
3646     { "autorotate",       HAS_ARG | OPT_BOOL | OPT_SPEC |
3647                           OPT_EXPERT | OPT_INPUT,                                { .off = OFFSET(autorotate) },
3648         "automatically insert correct rotate filters" },
3649
3650     /* audio options */
3651     { "aframes",        OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_frames },
3652         "set the number of audio frames to output", "number" },
3653     { "aq",             OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_qscale },
3654         "set audio quality (codec-specific)", "quality", },
3655     { "ar",             OPT_AUDIO | HAS_ARG  | OPT_INT | OPT_SPEC |
3656                         OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(audio_sample_rate) },
3657         "set audio sampling rate (in Hz)", "rate" },
3658     { "ac",             OPT_AUDIO | HAS_ARG  | OPT_INT | OPT_SPEC |
3659                         OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(audio_channels) },
3660         "set number of audio channels", "channels" },
3661     { "an",             OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) },
3662         "disable audio" },
3663     { "acodec",         OPT_AUDIO | HAS_ARG  | OPT_PERFILE |
3664                         OPT_INPUT | OPT_OUTPUT,                                    { .func_arg = opt_audio_codec },
3665         "force audio codec ('copy' to copy stream)", "codec" },
3666     { "atag",           OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_PERFILE |
3667                         OPT_OUTPUT,                                                { .func_arg = opt_old2new },
3668         "force audio tag/fourcc", "fourcc/tag" },
3669     { "vol",            OPT_AUDIO | HAS_ARG  | OPT_INT,                            { &audio_volume },
3670         "change audio volume (256=normal)" , "volume" },
3671     { "sample_fmt",     OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_SPEC |
3672                         OPT_STRING | OPT_INPUT | OPT_OUTPUT,                       { .off = OFFSET(sample_fmts) },
3673         "set sample format", "format" },
3674     { "channel_layout", OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_PERFILE |
3675                         OPT_INPUT | OPT_OUTPUT,                                    { .func_arg = opt_channel_layout },
3676         "set channel layout", "layout" },
3677     { "af",             OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_filters },
3678         "set audio filters", "filter_graph" },
3679     { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
3680       "set the maximum number of channels to try to guess the channel layout" },
3681
3682     /* subtitle options */
3683     { "sn",     OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
3684         "disable subtitle" },
3685     { "scodec", OPT_SUBTITLE | HAS_ARG  | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
3686         "force subtitle codec ('copy' to copy stream)", "codec" },
3687     { "stag",   OPT_SUBTITLE | HAS_ARG  | OPT_EXPERT  | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
3688         , "force subtitle tag/fourcc", "fourcc/tag" },
3689     { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
3690         "fix subtitles duration" },
3691     { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
3692         "set canvas size (WxH or abbreviation)", "size" },
3693
3694     /* grab options */
3695     { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
3696         "deprecated, use -channel", "channel" },
3697     { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
3698         "deprecated, use -standard", "standard" },
3699     { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
3700
3701     /* muxer options */
3702     { "muxdelay",   OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
3703         "set the maximum demux-decode delay", "seconds" },
3704     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
3705         "set the initial demux-decode delay", "seconds" },
3706     { "override_ffserver", OPT_BOOL | OPT_EXPERT | OPT_OUTPUT, { &override_ffserver },
3707         "override the options from ffserver", "" },
3708     { "sdp_file", HAS_ARG | OPT_EXPERT | OPT_OUTPUT, { .func_arg = opt_sdp_file },
3709         "specify a file in which to print sdp information", "file" },
3710
3711     { "time_base", HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(time_bases) },
3712         "set the desired time base hint for output stream (1:24, 1:48000 or 0.04166, 2.0833e-5)", "ratio" },
3713     { "enc_time_base", HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(enc_time_bases) },
3714         "set the desired time base for the encoder (1:24, 1:48000 or 0.04166, 2.0833e-5). "
3715         "two special values are defined - "
3716         "0 = use frame rate (video) or sample rate (audio),"
3717         "-1 = match source time base", "ratio" },
3718
3719     { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
3720         "A comma-separated list of bitstream filters", "bitstream_filters" },
3721     { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3722         "deprecated", "audio bitstream_filters" },
3723     { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3724         "deprecated", "video bitstream_filters" },
3725
3726     { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT,    { .func_arg = opt_preset },
3727         "set the audio options to the indicated preset", "preset" },
3728     { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT,    { .func_arg = opt_preset },
3729         "set the video options to the indicated preset", "preset" },
3730     { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3731         "set the subtitle options to the indicated preset", "preset" },
3732     { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT,                { .func_arg = opt_preset },
3733         "set options from indicated preset file", "filename" },
3734
3735     { "max_muxing_queue_size", HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(max_muxing_queue_size) },
3736         "maximum number of packets that can be buffered while waiting for all streams to initialize", "packets" },
3737
3738     /* data codec support */
3739     { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
3740         "force data codec ('copy' to copy stream)", "codec" },
3741     { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },
3742         "disable data" },
3743
3744 #if CONFIG_VAAPI
3745     { "vaapi_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vaapi_device },
3746         "set VAAPI hardware device (DRM path or X11 display name)", "device" },
3747 #endif
3748
3749 #if CONFIG_QSV
3750     { "qsv_device", HAS_ARG | OPT_STRING | OPT_EXPERT, { &qsv_device },
3751         "set QSV hardware device (DirectX adapter index, DRM path or X11 display name)", "device"},
3752 #endif
3753
3754     { "init_hw_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_init_hw_device },
3755         "initialise hardware device", "args" },
3756     { "filter_hw_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_hw_device },
3757         "set hardware device used when filtering", "device" },
3758
3759     { NULL, },
3760 };