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