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