Merge commit '666fe5da47d127074be7f0e2bac93db6af8b4a30'
[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     return ost;
1318 }
1319
1320 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1321 {
1322     AVStream *st;
1323     OutputStream *ost;
1324     AVCodecContext *subtitle_enc;
1325
1326     ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1327     st  = ost->st;
1328     subtitle_enc = st->codec;
1329
1330     subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1331
1332     MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1333
1334     if (!ost->stream_copy) {
1335         char *frame_size = NULL;
1336
1337         MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1338         if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1339             av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1340             exit(1);
1341         }
1342     }
1343
1344     return ost;
1345 }
1346
1347 /* arg format is "output-stream-index:streamid-value". */
1348 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1349 {
1350     OptionsContext *o = optctx;
1351     int idx;
1352     char *p;
1353     char idx_str[16];
1354
1355     av_strlcpy(idx_str, arg, sizeof(idx_str));
1356     p = strchr(idx_str, ':');
1357     if (!p) {
1358         av_log(NULL, AV_LOG_FATAL,
1359                "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1360                arg, opt);
1361         exit(1);
1362     }
1363     *p++ = '\0';
1364     idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1365     o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1366     o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1367     return 0;
1368 }
1369
1370 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1371 {
1372     AVFormatContext *is = ifile->ctx;
1373     AVFormatContext *os = ofile->ctx;
1374     AVChapter **tmp;
1375     int i;
1376
1377     tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1378     if (!tmp)
1379         return AVERROR(ENOMEM);
1380     os->chapters = tmp;
1381
1382     for (i = 0; i < is->nb_chapters; i++) {
1383         AVChapter *in_ch = is->chapters[i], *out_ch;
1384         int64_t ts_off   = av_rescale_q(ofile->start_time - ifile->ts_offset,
1385                                        AV_TIME_BASE_Q, in_ch->time_base);
1386         int64_t rt       = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1387                            av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1388
1389
1390         if (in_ch->end < ts_off)
1391             continue;
1392         if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1393             break;
1394
1395         out_ch = av_mallocz(sizeof(AVChapter));
1396         if (!out_ch)
1397             return AVERROR(ENOMEM);
1398
1399         out_ch->id        = in_ch->id;
1400         out_ch->time_base = in_ch->time_base;
1401         out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
1402         out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
1403
1404         if (copy_metadata)
1405             av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1406
1407         os->chapters[os->nb_chapters++] = out_ch;
1408     }
1409     return 0;
1410 }
1411
1412 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
1413 {
1414     int i, err;
1415     AVFormatContext *ic = avformat_alloc_context();
1416
1417     ic->interrupt_callback = int_cb;
1418     err = avformat_open_input(&ic, filename, NULL, NULL);
1419     if (err < 0)
1420         return err;
1421     /* copy stream format */
1422     for(i=0;i<ic->nb_streams;i++) {
1423         AVStream *st;
1424         OutputStream *ost;
1425         AVCodec *codec;
1426         AVCodecContext *avctx;
1427
1428         codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
1429         ost   = new_output_stream(o, s, codec->type, -1);
1430         st    = ost->st;
1431         avctx = st->codec;
1432         ost->enc = codec;
1433
1434         // FIXME: a more elegant solution is needed
1435         memcpy(st, ic->streams[i], sizeof(AVStream));
1436         st->cur_dts = 0;
1437         st->info = av_malloc(sizeof(*st->info));
1438         memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
1439         st->codec= avctx;
1440         avcodec_copy_context(st->codec, ic->streams[i]->codec);
1441
1442         if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
1443             choose_sample_fmt(st, codec);
1444         else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
1445             choose_pixel_fmt(st, codec, st->codec->pix_fmt);
1446     }
1447
1448     /* ffserver seeking with date=... needs a date reference */
1449     err = parse_option(o, "metadata", "creation_time=now", options);
1450
1451     avformat_close_input(&ic);
1452     return err;
1453 }
1454
1455 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1456                                AVFormatContext *oc)
1457 {
1458     OutputStream *ost;
1459
1460     switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1461                                   ofilter->out_tmp->pad_idx)) {
1462     case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
1463     case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
1464     default:
1465         av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1466                "currently.\n");
1467         exit(1);
1468     }
1469
1470     ost->source_index = -1;
1471     ost->filter       = ofilter;
1472
1473     ofilter->ost      = ost;
1474
1475     if (ost->stream_copy) {
1476         av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1477                "which is fed from a complex filtergraph. Filtering and streamcopy "
1478                "cannot be used together.\n", ost->file_index, ost->index);
1479         exit(1);
1480     }
1481
1482     if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
1483         av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
1484         exit(1);
1485     }
1486     avfilter_inout_free(&ofilter->out_tmp);
1487 }
1488
1489 static int configure_complex_filters(void)
1490 {
1491     int i, ret = 0;
1492
1493     for (i = 0; i < nb_filtergraphs; i++)
1494         if (!filtergraphs[i]->graph &&
1495             (ret = configure_filtergraph(filtergraphs[i])) < 0)
1496             return ret;
1497     return 0;
1498 }
1499
1500 static int open_output_file(OptionsContext *o, const char *filename)
1501 {
1502     AVFormatContext *oc;
1503     int i, j, err;
1504     AVOutputFormat *file_oformat;
1505     OutputFile *of;
1506     OutputStream *ost;
1507     InputStream  *ist;
1508     AVDictionary *unused_opts = NULL;
1509     AVDictionaryEntry *e = NULL;
1510
1511     if (configure_complex_filters() < 0) {
1512         av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
1513         exit(1);
1514     }
1515
1516     if (!strcmp(filename, "-"))
1517         filename = "pipe:";
1518
1519     err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
1520     if (!oc) {
1521         print_error(filename, err);
1522         exit(1);
1523     }
1524     file_oformat= oc->oformat;
1525     oc->interrupt_callback = int_cb;
1526
1527     /* create streams for all unlabeled output pads */
1528     for (i = 0; i < nb_filtergraphs; i++) {
1529         FilterGraph *fg = filtergraphs[i];
1530         for (j = 0; j < fg->nb_outputs; j++) {
1531             OutputFilter *ofilter = fg->outputs[j];
1532
1533             if (!ofilter->out_tmp || ofilter->out_tmp->name)
1534                 continue;
1535
1536             switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1537                                           ofilter->out_tmp->pad_idx)) {
1538             case AVMEDIA_TYPE_VIDEO:    o->video_disable    = 1; break;
1539             case AVMEDIA_TYPE_AUDIO:    o->audio_disable    = 1; break;
1540             case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1541             }
1542             init_output_filter(ofilter, o, oc);
1543         }
1544     }
1545
1546     if (!strcmp(file_oformat->name, "ffm") &&
1547         av_strstart(filename, "http:", NULL)) {
1548         int j;
1549         /* special case for files sent to ffserver: we get the stream
1550            parameters from ffserver */
1551         int err = read_ffserver_streams(o, oc, filename);
1552         if (err < 0) {
1553             print_error(filename, err);
1554             exit(1);
1555         }
1556         for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
1557             ost = output_streams[j];
1558             for (i = 0; i < nb_input_streams; i++) {
1559                 ist = input_streams[i];
1560                 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
1561                     ost->sync_ist= ist;
1562                     ost->source_index= i;
1563                     if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
1564                     if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
1565                     ist->discard = 0;
1566                     ist->st->discard = AVDISCARD_NONE;
1567                     break;
1568                 }
1569             }
1570             if(!ost->sync_ist){
1571                 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));
1572                 exit(1);
1573             }
1574         }
1575     } else if (!o->nb_stream_maps) {
1576         char *subtitle_codec_name = NULL;
1577         /* pick the "best" stream of each type */
1578
1579         /* video: highest resolution */
1580         if (!o->video_disable && oc->oformat->video_codec != AV_CODEC_ID_NONE) {
1581             int area = 0, idx = -1;
1582             int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
1583             for (i = 0; i < nb_input_streams; i++) {
1584                 int new_area;
1585                 ist = input_streams[i];
1586                 new_area = ist->st->codec->width * ist->st->codec->height;
1587                 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1588                     new_area = 1;
1589                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1590                     new_area > area) {
1591                     if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1592                         continue;
1593                     area = new_area;
1594                     idx = i;
1595                 }
1596             }
1597             if (idx >= 0)
1598                 new_video_stream(o, oc, idx);
1599         }
1600
1601         /* audio: most channels */
1602         if (!o->audio_disable && oc->oformat->audio_codec != AV_CODEC_ID_NONE) {
1603             int channels = 0, idx = -1;
1604             for (i = 0; i < nb_input_streams; i++) {
1605                 ist = input_streams[i];
1606                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1607                     ist->st->codec->channels > channels) {
1608                     channels = ist->st->codec->channels;
1609                     idx = i;
1610                 }
1611             }
1612             if (idx >= 0)
1613                 new_audio_stream(o, oc, idx);
1614         }
1615
1616         /* subtitles: pick first */
1617         MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
1618         if (!o->subtitle_disable && (oc->oformat->subtitle_codec != AV_CODEC_ID_NONE || subtitle_codec_name)) {
1619             for (i = 0; i < nb_input_streams; i++)
1620                 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1621                     new_subtitle_stream(o, oc, i);
1622                     break;
1623                 }
1624         }
1625         /* do something with data? */
1626     } else {
1627         for (i = 0; i < o->nb_stream_maps; i++) {
1628             StreamMap *map = &o->stream_maps[i];
1629             int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
1630
1631             if (map->disabled)
1632                 continue;
1633
1634             if (map->linklabel) {
1635                 FilterGraph *fg;
1636                 OutputFilter *ofilter = NULL;
1637                 int j, k;
1638
1639                 for (j = 0; j < nb_filtergraphs; j++) {
1640                     fg = filtergraphs[j];
1641                     for (k = 0; k < fg->nb_outputs; k++) {
1642                         AVFilterInOut *out = fg->outputs[k]->out_tmp;
1643                         if (out && !strcmp(out->name, map->linklabel)) {
1644                             ofilter = fg->outputs[k];
1645                             goto loop_end;
1646                         }
1647                     }
1648                 }
1649 loop_end:
1650                 if (!ofilter) {
1651                     av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1652                            "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
1653                     exit(1);
1654                 }
1655                 init_output_filter(ofilter, o, oc);
1656             } else {
1657                 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
1658                 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
1659                     continue;
1660                 if(o->   audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1661                     continue;
1662                 if(o->   video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
1663                     continue;
1664                 if(o->    data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
1665                     continue;
1666
1667                 switch (ist->st->codec->codec_type) {
1668                 case AVMEDIA_TYPE_VIDEO:      ost = new_video_stream     (o, oc, src_idx); break;
1669                 case AVMEDIA_TYPE_AUDIO:      ost = new_audio_stream     (o, oc, src_idx); break;
1670                 case AVMEDIA_TYPE_SUBTITLE:   ost = new_subtitle_stream  (o, oc, src_idx); break;
1671                 case AVMEDIA_TYPE_DATA:       ost = new_data_stream      (o, oc, src_idx); break;
1672                 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
1673                 default:
1674                     av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
1675                            map->file_index, map->stream_index);
1676                     exit(1);
1677                 }
1678             }
1679         }
1680     }
1681
1682     /* handle attached files */
1683     for (i = 0; i < o->nb_attachments; i++) {
1684         AVIOContext *pb;
1685         uint8_t *attachment;
1686         const char *p;
1687         int64_t len;
1688
1689         if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
1690             av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
1691                    o->attachments[i]);
1692             exit(1);
1693         }
1694         if ((len = avio_size(pb)) <= 0) {
1695             av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
1696                    o->attachments[i]);
1697             exit(1);
1698         }
1699         if (!(attachment = av_malloc(len))) {
1700             av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
1701                    o->attachments[i]);
1702             exit(1);
1703         }
1704         avio_read(pb, attachment, len);
1705
1706         ost = new_attachment_stream(o, oc, -1);
1707         ost->stream_copy               = 0;
1708         ost->attachment_filename       = o->attachments[i];
1709         ost->finished                  = 1;
1710         ost->st->codec->extradata      = attachment;
1711         ost->st->codec->extradata_size = len;
1712
1713         p = strrchr(o->attachments[i], '/');
1714         av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
1715         avio_close(pb);
1716     }
1717
1718     for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
1719         AVDictionaryEntry *e;
1720         ost = output_streams[i];
1721
1722         if ((ost->stream_copy || ost->attachment_filename)
1723             && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
1724             && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
1725             if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
1726                 exit(1);
1727     }
1728
1729     if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
1730         o->stop_time = INT64_MAX;
1731         av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
1732     }
1733
1734     if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
1735         if (o->stop_time <= o->start_time) {
1736             av_log(NULL, AV_LOG_WARNING, "-to value smaller than -ss; ignoring -to.\n");
1737             o->stop_time = INT64_MAX;
1738         } else {
1739             o->recording_time = o->stop_time - o->start_time;
1740         }
1741     }
1742
1743     GROW_ARRAY(output_files, nb_output_files);
1744     of = av_mallocz(sizeof(*of));
1745     if (!of)
1746         exit(1);
1747     output_files[nb_output_files - 1] = of;
1748
1749     of->ctx            = oc;
1750     of->ost_index      = nb_output_streams - oc->nb_streams;
1751     of->recording_time = o->recording_time;
1752     if (o->recording_time != INT64_MAX)
1753         oc->duration = o->recording_time;
1754     of->start_time     = o->start_time;
1755     of->limit_filesize = o->limit_filesize;
1756     of->shortest       = o->shortest;
1757     av_dict_copy(&of->opts, o->g->format_opts, 0);
1758
1759
1760     /* check if all codec options have been used */
1761     unused_opts = strip_specifiers(o->g->codec_opts);
1762     for (i = of->ost_index; i < nb_output_streams; i++) {
1763         e = NULL;
1764         while ((e = av_dict_get(output_streams[i]->opts, "", e,
1765                                 AV_DICT_IGNORE_SUFFIX)))
1766             av_dict_set(&unused_opts, e->key, NULL, 0);
1767     }
1768
1769     e = NULL;
1770     while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
1771         const AVClass *class = avcodec_get_class();
1772         const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
1773                                              AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1774         if (!option)
1775             continue;
1776         if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
1777             av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
1778                    "output file #%d (%s) is not an encoding option.\n", e->key,
1779                    option->help ? option->help : "", nb_output_files - 1,
1780                    filename);
1781             exit(1);
1782         }
1783
1784         av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
1785                "output file #%d (%s) has not been used for any stream. The most "
1786                "likely reason is either wrong type (e.g. a video option with "
1787                "no video streams) or that it is a private option of some encoder "
1788                "which was not actually used for any stream.\n", e->key,
1789                option->help ? option->help : "", nb_output_files - 1, filename);
1790     }
1791     av_dict_free(&unused_opts);
1792
1793     /* check filename in case of an image number is expected */
1794     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
1795         if (!av_filename_number_test(oc->filename)) {
1796             print_error(oc->filename, AVERROR(EINVAL));
1797             exit(1);
1798         }
1799     }
1800
1801     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
1802         /* test if it already exists to avoid losing precious files */
1803         assert_file_overwrite(filename);
1804
1805         /* open the file */
1806         if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
1807                               &oc->interrupt_callback,
1808                               &of->opts)) < 0) {
1809             print_error(filename, err);
1810             exit(1);
1811         }
1812     } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
1813         assert_file_overwrite(filename);
1814
1815     if (o->mux_preload) {
1816         uint8_t buf[64];
1817         snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
1818         av_dict_set(&of->opts, "preload", buf, 0);
1819     }
1820     oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
1821
1822     /* copy metadata */
1823     for (i = 0; i < o->nb_metadata_map; i++) {
1824         char *p;
1825         int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
1826
1827         if (in_file_index >= nb_input_files) {
1828             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
1829             exit(1);
1830         }
1831         copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
1832                       in_file_index >= 0 ?
1833                       input_files[in_file_index]->ctx : NULL, o);
1834     }
1835
1836     /* copy chapters */
1837     if (o->chapters_input_file >= nb_input_files) {
1838         if (o->chapters_input_file == INT_MAX) {
1839             /* copy chapters from the first input file that has them*/
1840             o->chapters_input_file = -1;
1841             for (i = 0; i < nb_input_files; i++)
1842                 if (input_files[i]->ctx->nb_chapters) {
1843                     o->chapters_input_file = i;
1844                     break;
1845                 }
1846         } else {
1847             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
1848                    o->chapters_input_file);
1849             exit(1);
1850         }
1851     }
1852     if (o->chapters_input_file >= 0)
1853         copy_chapters(input_files[o->chapters_input_file], of,
1854                       !o->metadata_chapters_manual);
1855
1856     /* copy global metadata by default */
1857     if (!o->metadata_global_manual && nb_input_files){
1858         av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
1859                      AV_DICT_DONT_OVERWRITE);
1860         if(o->recording_time != INT64_MAX)
1861             av_dict_set(&oc->metadata, "duration", NULL, 0);
1862         av_dict_set(&oc->metadata, "creation_time", NULL, 0);
1863     }
1864     if (!o->metadata_streams_manual)
1865         for (i = of->ost_index; i < nb_output_streams; i++) {
1866             InputStream *ist;
1867             if (output_streams[i]->source_index < 0)         /* this is true e.g. for attached files */
1868                 continue;
1869             ist = input_streams[output_streams[i]->source_index];
1870             av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
1871         }
1872
1873     /* process manually set metadata */
1874     for (i = 0; i < o->nb_metadata; i++) {
1875         AVDictionary **m;
1876         char type, *val;
1877         const char *stream_spec;
1878         int index = 0, j, ret = 0;
1879
1880         val = strchr(o->metadata[i].u.str, '=');
1881         if (!val) {
1882             av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
1883                    o->metadata[i].u.str);
1884             exit(1);
1885         }
1886         *val++ = 0;
1887
1888         parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
1889         if (type == 's') {
1890             for (j = 0; j < oc->nb_streams; j++) {
1891                 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
1892                     av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
1893                 } else if (ret < 0)
1894                     exit(1);
1895             }
1896         }
1897         else {
1898             switch (type) {
1899             case 'g':
1900                 m = &oc->metadata;
1901                 break;
1902             case 'c':
1903                 if (index < 0 || index >= oc->nb_chapters) {
1904                     av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
1905                     exit(1);
1906                 }
1907                 m = &oc->chapters[index]->metadata;
1908                 break;
1909             default:
1910                 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
1911                 exit(1);
1912             }
1913             av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
1914         }
1915     }
1916
1917     return 0;
1918 }
1919
1920 static int opt_target(void *optctx, const char *opt, const char *arg)
1921 {
1922     OptionsContext *o = optctx;
1923     enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
1924     static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
1925
1926     if (!strncmp(arg, "pal-", 4)) {
1927         norm = PAL;
1928         arg += 4;
1929     } else if (!strncmp(arg, "ntsc-", 5)) {
1930         norm = NTSC;
1931         arg += 5;
1932     } else if (!strncmp(arg, "film-", 5)) {
1933         norm = FILM;
1934         arg += 5;
1935     } else {
1936         /* Try to determine PAL/NTSC by peeking in the input files */
1937         if (nb_input_files) {
1938             int i, j, fr;
1939             for (j = 0; j < nb_input_files; j++) {
1940                 for (i = 0; i < input_files[j]->nb_streams; i++) {
1941                     AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
1942                     if (c->codec_type != AVMEDIA_TYPE_VIDEO)
1943                         continue;
1944                     fr = c->time_base.den * 1000 / c->time_base.num;
1945                     if (fr == 25000) {
1946                         norm = PAL;
1947                         break;
1948                     } else if ((fr == 29970) || (fr == 23976)) {
1949                         norm = NTSC;
1950                         break;
1951                     }
1952                 }
1953                 if (norm != UNKNOWN)
1954                     break;
1955             }
1956         }
1957         if (norm != UNKNOWN)
1958             av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
1959     }
1960
1961     if (norm == UNKNOWN) {
1962         av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
1963         av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
1964         av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
1965         exit(1);
1966     }
1967
1968     if (!strcmp(arg, "vcd")) {
1969         opt_video_codec(o, "c:v", "mpeg1video");
1970         opt_audio_codec(o, "c:a", "mp2");
1971         parse_option(o, "f", "vcd", options);
1972         av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
1973
1974         parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
1975         parse_option(o, "r", frame_rates[norm], options);
1976         av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", 0);
1977
1978         av_dict_set(&o->g->codec_opts, "b:v", "1150000", 0);
1979         av_dict_set(&o->g->codec_opts, "maxrate", "1150000", 0);
1980         av_dict_set(&o->g->codec_opts, "minrate", "1150000", 0);
1981         av_dict_set(&o->g->codec_opts, "bufsize", "327680", 0); // 40*1024*8;
1982
1983         av_dict_set(&o->g->codec_opts, "b:a", "224000", 0);
1984         parse_option(o, "ar", "44100", options);
1985         parse_option(o, "ac", "2", options);
1986
1987         av_dict_set(&o->g->format_opts, "packetsize", "2324", 0);
1988         av_dict_set(&o->g->format_opts, "muxrate", "1411200", 0); // 2352 * 75 * 8;
1989
1990         /* We have to offset the PTS, so that it is consistent with the SCR.
1991            SCR starts at 36000, but the first two packs contain only padding
1992            and the first pack from the other stream, respectively, may also have
1993            been written before.
1994            So the real data starts at SCR 36000+3*1200. */
1995         o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
1996     } else if (!strcmp(arg, "svcd")) {
1997
1998         opt_video_codec(o, "c:v", "mpeg2video");
1999         opt_audio_codec(o, "c:a", "mp2");
2000         parse_option(o, "f", "svcd", options);
2001
2002         parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2003         parse_option(o, "r", frame_rates[norm], options);
2004         parse_option(o, "pix_fmt", "yuv420p", options);
2005         av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", 0);
2006
2007         av_dict_set(&o->g->codec_opts, "b:v", "2040000", 0);
2008         av_dict_set(&o->g->codec_opts, "maxrate", "2516000", 0);
2009         av_dict_set(&o->g->codec_opts, "minrate", "0", 0); // 1145000;
2010         av_dict_set(&o->g->codec_opts, "bufsize", "1835008", 0); // 224*1024*8;
2011         av_dict_set(&o->g->codec_opts, "scan_offset", "1", 0);
2012
2013         av_dict_set(&o->g->codec_opts, "b:a", "224000", 0);
2014         parse_option(o, "ar", "44100", options);
2015
2016         av_dict_set(&o->g->format_opts, "packetsize", "2324", 0);
2017
2018     } else if (!strcmp(arg, "dvd")) {
2019
2020         opt_video_codec(o, "c:v", "mpeg2video");
2021         opt_audio_codec(o, "c:a", "ac3");
2022         parse_option(o, "f", "dvd", options);
2023
2024         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2025         parse_option(o, "r", frame_rates[norm], options);
2026         parse_option(o, "pix_fmt", "yuv420p", options);
2027         av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", 0);
2028
2029         av_dict_set(&o->g->codec_opts, "b:v", "6000000", 0);
2030         av_dict_set(&o->g->codec_opts, "maxrate", "9000000", 0);
2031         av_dict_set(&o->g->codec_opts, "minrate", "0", 0); // 1500000;
2032         av_dict_set(&o->g->codec_opts, "bufsize", "1835008", 0); // 224*1024*8;
2033
2034         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.
2035         av_dict_set(&o->g->format_opts, "muxrate", "10080000", 0); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2036
2037         av_dict_set(&o->g->codec_opts, "b:a", "448000", 0);
2038         parse_option(o, "ar", "48000", options);
2039
2040     } else if (!strncmp(arg, "dv", 2)) {
2041
2042         parse_option(o, "f", "dv", options);
2043
2044         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2045         parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2046                           norm == PAL ? "yuv420p" : "yuv411p", options);
2047         parse_option(o, "r", frame_rates[norm], options);
2048
2049         parse_option(o, "ar", "48000", options);
2050         parse_option(o, "ac", "2", options);
2051
2052     } else {
2053         av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2054         return AVERROR(EINVAL);
2055     }
2056     return 0;
2057 }
2058
2059 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2060 {
2061     av_free (vstats_filename);
2062     vstats_filename = av_strdup (arg);
2063     return 0;
2064 }
2065
2066 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2067 {
2068     char filename[40];
2069     time_t today2 = time(NULL);
2070     struct tm *today = localtime(&today2);
2071
2072     snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2073              today->tm_sec);
2074     return opt_vstats_file(NULL, opt, filename);
2075 }
2076
2077 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2078 {
2079     OptionsContext *o = optctx;
2080     return parse_option(o, "frames:v", arg, options);
2081 }
2082
2083 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2084 {
2085     OptionsContext *o = optctx;
2086     return parse_option(o, "frames:a", arg, options);
2087 }
2088
2089 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2090 {
2091     OptionsContext *o = optctx;
2092     return parse_option(o, "frames:d", arg, options);
2093 }
2094
2095 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2096 {
2097     int ret;
2098     AVDictionary *cbak = codec_opts;
2099     AVDictionary *fbak = format_opts;
2100     codec_opts = NULL;
2101     format_opts = NULL;
2102
2103     ret = opt_default(NULL, opt, arg);
2104
2105     av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2106     av_dict_copy(&o->g->format_opts, format_opts, 0);
2107     av_dict_free(&codec_opts);
2108     av_dict_free(&format_opts);
2109     codec_opts = cbak;
2110     format_opts = fbak;
2111
2112     return ret;
2113 }
2114
2115 static int opt_preset(void *optctx, const char *opt, const char *arg)
2116 {
2117     OptionsContext *o = optctx;
2118     FILE *f=NULL;
2119     char filename[1000], line[1000], tmp_line[1000];
2120     const char *codec_name = NULL;
2121
2122     tmp_line[0] = *opt;
2123     tmp_line[1] = 0;
2124     MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2125
2126     if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2127         if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2128             av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2129         }else
2130             av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2131         exit(1);
2132     }
2133
2134     while (fgets(line, sizeof(line), f)) {
2135         char *key = tmp_line, *value, *endptr;
2136
2137         if (strcspn(line, "#\n\r") == 0)
2138             continue;
2139         strcpy(tmp_line, line);
2140         if (!av_strtok(key,   "=",    &value) ||
2141             !av_strtok(value, "\r\n", &endptr)) {
2142             av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2143             exit(1);
2144         }
2145         av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2146
2147         if      (!strcmp(key, "acodec")) opt_audio_codec   (o, key, value);
2148         else if (!strcmp(key, "vcodec")) opt_video_codec   (o, key, value);
2149         else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2150         else if (!strcmp(key, "dcodec")) opt_data_codec    (o, key, value);
2151         else if (opt_default_new(o, key, value) < 0) {
2152             av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2153                    filename, line, key, value);
2154             exit(1);
2155         }
2156     }
2157
2158     fclose(f);
2159
2160     return 0;
2161 }
2162
2163 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2164 {
2165     OptionsContext *o = optctx;
2166     char *s = av_asprintf("%s:%c", opt + 1, *opt);
2167     int ret = parse_option(o, s, arg, options);
2168     av_free(s);
2169     return ret;
2170 }
2171
2172 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2173 {
2174     OptionsContext *o = optctx;
2175     if(!strcmp(opt, "b")){
2176         av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2177         av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2178         return 0;
2179     }
2180     av_dict_set(&o->g->codec_opts, opt, arg, 0);
2181     return 0;
2182 }
2183
2184 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2185 {
2186     OptionsContext *o = optctx;
2187     char *s;
2188     int ret;
2189     if(!strcmp(opt, "qscale")){
2190         av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2191         return parse_option(o, "q:v", arg, options);
2192     }
2193     s = av_asprintf("q%s", opt + 6);
2194     ret = parse_option(o, s, arg, options);
2195     av_free(s);
2196     return ret;
2197 }
2198
2199 static int opt_profile(void *optctx, const char *opt, const char *arg)
2200 {
2201     OptionsContext *o = optctx;
2202     if(!strcmp(opt, "profile")){
2203         av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2204         av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
2205         return 0;
2206     }
2207     av_dict_set(&o->g->codec_opts, opt, arg, 0);
2208     return 0;
2209 }
2210
2211 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2212 {
2213     OptionsContext *o = optctx;
2214     return parse_option(o, "filter:v", arg, options);
2215 }
2216
2217 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2218 {
2219     OptionsContext *o = optctx;
2220     return parse_option(o, "filter:a", arg, options);
2221 }
2222
2223 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2224 {
2225     if      (!av_strcasecmp(arg, "cfr"))         video_sync_method = VSYNC_CFR;
2226     else if (!av_strcasecmp(arg, "vfr"))         video_sync_method = VSYNC_VFR;
2227     else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2228     else if (!av_strcasecmp(arg, "drop"))        video_sync_method = VSYNC_DROP;
2229
2230     if (video_sync_method == VSYNC_AUTO)
2231         video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
2232     return 0;
2233 }
2234
2235 #if FF_API_DEINTERLACE
2236 static int opt_deinterlace(void *optctx, const char *opt, const char *arg)
2237 {
2238     av_log(NULL, AV_LOG_WARNING, "-%s is deprecated, use -filter:v yadif instead\n", opt);
2239     do_deinterlace = 1;
2240     return 0;
2241 }
2242 #endif
2243
2244 static int opt_timecode(void *optctx, const char *opt, const char *arg)
2245 {
2246     OptionsContext *o = optctx;
2247     char *tcr = av_asprintf("timecode=%s", arg);
2248     int ret = parse_option(o, "metadata:g", tcr, options);
2249     if (ret >= 0)
2250         ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
2251     av_free(tcr);
2252     return 0;
2253 }
2254
2255 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2256 {
2257     OptionsContext *o = optctx;
2258     char layout_str[32];
2259     char *stream_str;
2260     char *ac_str;
2261     int ret, channels, ac_str_size;
2262     uint64_t layout;
2263
2264     layout = av_get_channel_layout(arg);
2265     if (!layout) {
2266         av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2267         return AVERROR(EINVAL);
2268     }
2269     snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2270     ret = opt_default_new(o, opt, layout_str);
2271     if (ret < 0)
2272         return ret;
2273
2274     /* set 'ac' option based on channel layout */
2275     channels = av_get_channel_layout_nb_channels(layout);
2276     snprintf(layout_str, sizeof(layout_str), "%d", channels);
2277     stream_str = strchr(opt, ':');
2278     ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2279     ac_str = av_mallocz(ac_str_size);
2280     if (!ac_str)
2281         return AVERROR(ENOMEM);
2282     av_strlcpy(ac_str, "ac", 3);
2283     if (stream_str)
2284         av_strlcat(ac_str, stream_str, ac_str_size);
2285     ret = parse_option(o, ac_str, layout_str, options);
2286     av_free(ac_str);
2287
2288     return ret;
2289 }
2290
2291 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2292 {
2293     OptionsContext *o = optctx;
2294     return parse_option(o, "q:a", arg, options);
2295 }
2296
2297 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2298 {
2299     GROW_ARRAY(filtergraphs, nb_filtergraphs);
2300     if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2301         return AVERROR(ENOMEM);
2302     filtergraphs[nb_filtergraphs - 1]->index       = nb_filtergraphs - 1;
2303     filtergraphs[nb_filtergraphs - 1]->graph_desc = arg;
2304     return 0;
2305 }
2306
2307 void show_help_default(const char *opt, const char *arg)
2308 {
2309     /* per-file options have at least one of those set */
2310     const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2311     int show_advanced = 0, show_avoptions = 0;
2312
2313     if (opt && *opt) {
2314         if (!strcmp(opt, "long"))
2315             show_advanced = 1;
2316         else if (!strcmp(opt, "full"))
2317             show_advanced = show_avoptions = 1;
2318         else
2319             av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2320     }
2321
2322     show_usage();
2323
2324     printf("Getting help:\n"
2325            "    -h      -- print basic options\n"
2326            "    -h long -- print more options\n"
2327            "    -h full -- print all options (including all format and codec specific options, very long)\n"
2328            "    See man %s for detailed description of the options.\n"
2329            "\n", program_name);
2330
2331     show_help_options(options, "Print help / information / capabilities:",
2332                       OPT_EXIT, 0, 0);
2333
2334     show_help_options(options, "Global options (affect whole program "
2335                       "instead of just one file:",
2336                       0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2337     if (show_advanced)
2338         show_help_options(options, "Advanced global options:", OPT_EXPERT,
2339                           per_file | OPT_EXIT, 0);
2340
2341     show_help_options(options, "Per-file main options:", 0,
2342                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
2343                       OPT_EXIT, per_file);
2344     if (show_advanced)
2345         show_help_options(options, "Advanced per-file options:",
2346                           OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2347
2348     show_help_options(options, "Video options:",
2349                       OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
2350     if (show_advanced)
2351         show_help_options(options, "Advanced Video options:",
2352                           OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2353
2354     show_help_options(options, "Audio options:",
2355                       OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2356     if (show_advanced)
2357         show_help_options(options, "Advanced Audio options:",
2358                           OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2359     show_help_options(options, "Subtitle options:",
2360                       OPT_SUBTITLE, 0, 0);
2361     printf("\n");
2362
2363     if (show_avoptions) {
2364         int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2365         show_help_children(avcodec_get_class(), flags);
2366         show_help_children(avformat_get_class(), flags);
2367         show_help_children(sws_get_class(), flags);
2368         show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
2369         show_help_children(avfilter_get_class(), AV_OPT_FLAG_FILTERING_PARAM);
2370     }
2371 }
2372
2373 void show_usage(void)
2374 {
2375     av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
2376     av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2377     av_log(NULL, AV_LOG_INFO, "\n");
2378 }
2379
2380 enum OptGroup {
2381     GROUP_OUTFILE,
2382     GROUP_INFILE,
2383 };
2384
2385 static const OptionGroupDef groups[] = {
2386     [GROUP_OUTFILE] = { "output file",  NULL, OPT_OUTPUT },
2387     [GROUP_INFILE]  = { "input file",   "i",  OPT_INPUT },
2388 };
2389
2390 static int open_files(OptionGroupList *l, const char *inout,
2391                       int (*open_file)(OptionsContext*, const char*))
2392 {
2393     int i, ret;
2394
2395     for (i = 0; i < l->nb_groups; i++) {
2396         OptionGroup *g = &l->groups[i];
2397         OptionsContext o;
2398
2399         init_options(&o, !strcmp(inout, "input"));
2400         o.g = g;
2401
2402         ret = parse_optgroup(&o, g);
2403         if (ret < 0) {
2404             av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
2405                    "%s.\n", inout, g->arg);
2406             return ret;
2407         }
2408
2409         av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
2410         ret = open_file(&o, g->arg);
2411         uninit_options(&o, !strcmp(inout, "input"));
2412         if (ret < 0) {
2413             av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
2414                    inout, g->arg);
2415             return ret;
2416         }
2417         av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
2418     }
2419
2420     return 0;
2421 }
2422
2423 int ffmpeg_parse_options(int argc, char **argv)
2424 {
2425     OptionParseContext octx;
2426     uint8_t error[128];
2427     int ret;
2428
2429     memset(&octx, 0, sizeof(octx));
2430
2431     /* split the commandline into an internal representation */
2432     ret = split_commandline(&octx, argc, argv, options, groups,
2433                             FF_ARRAY_ELEMS(groups));
2434     if (ret < 0) {
2435         av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
2436         goto fail;
2437     }
2438
2439     /* apply global options */
2440     ret = parse_optgroup(NULL, &octx.global_opts);
2441     if (ret < 0) {
2442         av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
2443         goto fail;
2444     }
2445
2446     /* open input files */
2447     ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
2448     if (ret < 0) {
2449         av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
2450         goto fail;
2451     }
2452
2453     /* open output files */
2454     ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
2455     if (ret < 0) {
2456         av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
2457         goto fail;
2458     }
2459
2460 fail:
2461     uninit_parse_context(&octx);
2462     if (ret < 0) {
2463         av_strerror(ret, error, sizeof(error));
2464         av_log(NULL, AV_LOG_FATAL, "%s\n", error);
2465     }
2466     return ret;
2467 }
2468
2469 static int opt_progress(void *optctx, const char *opt, const char *arg)
2470 {
2471     AVIOContext *avio = NULL;
2472     int ret;
2473
2474     if (!strcmp(arg, "-"))
2475         arg = "pipe:";
2476     ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
2477     if (ret < 0) {
2478         av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
2479                arg, av_err2str(ret));
2480         return ret;
2481     }
2482     progress_avio = avio;
2483     return 0;
2484 }
2485
2486 #define OFFSET(x) offsetof(OptionsContext, x)
2487 const OptionDef options[] = {
2488     /* main options */
2489 #include "cmdutils_common_opts.h"
2490     { "f",              HAS_ARG | OPT_STRING | OPT_OFFSET |
2491                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(format) },
2492         "force format", "fmt" },
2493     { "y",              OPT_BOOL,                                    {              &file_overwrite },
2494         "overwrite output files" },
2495     { "n",              OPT_BOOL,                                    {              &no_file_overwrite },
2496         "do not overwrite output files" },
2497     { "c",              HAS_ARG | OPT_STRING | OPT_SPEC |
2498                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(codec_names) },
2499         "codec name", "codec" },
2500     { "codec",          HAS_ARG | OPT_STRING | OPT_SPEC |
2501                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(codec_names) },
2502         "codec name", "codec" },
2503     { "pre",            HAS_ARG | OPT_STRING | OPT_SPEC |
2504                         OPT_OUTPUT,                                  { .off       = OFFSET(presets) },
2505         "preset name", "preset" },
2506     { "map",            HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2507                         OPT_OUTPUT,                                  { .func_arg = opt_map },
2508         "set input stream mapping",
2509         "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
2510     { "map_channel",    HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
2511         "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
2512     { "map_metadata",   HAS_ARG | OPT_STRING | OPT_SPEC |
2513                         OPT_OUTPUT,                                  { .off       = OFFSET(metadata_map) },
2514         "set metadata information of outfile from infile",
2515         "outfile[,metadata]:infile[,metadata]" },
2516     { "map_chapters",   HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
2517                         OPT_OUTPUT,                                  { .off = OFFSET(chapters_input_file) },
2518         "set chapters mapping", "input_file_index" },
2519     { "t",              HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
2520         "record or transcode \"duration\" seconds of audio/video",
2521         "duration" },
2522     { "to",             HAS_ARG | OPT_TIME | OPT_OFFSET,             { .off = OFFSET(stop_time) },
2523         "record or transcode stop time", "time_stop" },
2524     { "fs",             HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
2525         "set the limit file size in bytes", "limit_size" },
2526     { "ss",             HAS_ARG | OPT_TIME | OPT_OFFSET |
2527                         OPT_INPUT | OPT_OUTPUT,                      { .off = OFFSET(start_time) },
2528         "set the start time offset", "time_off" },
2529     { "itsoffset",      HAS_ARG | OPT_TIME | OPT_OFFSET |
2530                         OPT_EXPERT | OPT_INPUT,                      { .off = OFFSET(input_ts_offset) },
2531         "set the input ts offset", "time_off" },
2532     { "itsscale",       HAS_ARG | OPT_DOUBLE | OPT_SPEC |
2533                         OPT_EXPERT | OPT_INPUT,                      { .off = OFFSET(ts_scale) },
2534         "set the input ts scale", "scale" },
2535     { "timestamp",      HAS_ARG | OPT_PERFILE,                       { .func_arg = opt_recording_timestamp },
2536         "set the recording timestamp ('now' to set the current time)", "time" },
2537     { "metadata",       HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
2538         "add metadata", "string=string" },
2539     { "dframes",        HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2540                         OPT_OUTPUT,                                  { .func_arg = opt_data_frames },
2541         "set the number of data frames to record", "number" },
2542     { "benchmark",      OPT_BOOL | OPT_EXPERT,                       { &do_benchmark },
2543         "add timings for benchmarking" },
2544     { "benchmark_all",  OPT_BOOL | OPT_EXPERT,                       { &do_benchmark_all },
2545       "add timings for each task" },
2546     { "progress",       HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_progress },
2547       "write program-readable progress information", "url" },
2548     { "stdin",          OPT_BOOL | OPT_EXPERT,                       { &stdin_interaction },
2549       "enable or disable interaction on standard input" },
2550     { "timelimit",      HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_timelimit },
2551         "set max runtime in seconds", "limit" },
2552     { "dump",           OPT_BOOL | OPT_EXPERT,                       { &do_pkt_dump },
2553         "dump each input packet" },
2554     { "hex",            OPT_BOOL | OPT_EXPERT,                       { &do_hex_dump },
2555         "when dumping packets, also dump the payload" },
2556     { "re",             OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2557                         OPT_INPUT,                                   { .off = OFFSET(rate_emu) },
2558         "read input at native frame rate", "" },
2559     { "target",         HAS_ARG | OPT_PERFILE | OPT_OUTPUT,          { .func_arg = opt_target },
2560         "specify target file type (\"vcd\", \"svcd\", \"dvd\","
2561         " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2562     { "vsync",          HAS_ARG | OPT_EXPERT,                        { opt_vsync },
2563         "video sync method", "" },
2564     { "async",          HAS_ARG | OPT_INT | OPT_EXPERT,              { &audio_sync_method },
2565         "audio sync method", "" },
2566     { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,          { &audio_drift_threshold },
2567         "audio drift threshold", "threshold" },
2568     { "copyts",         OPT_BOOL | OPT_EXPERT,                       { &copy_ts },
2569         "copy timestamps" },
2570     { "copytb",         HAS_ARG | OPT_INT | OPT_EXPERT,              { &copy_tb },
2571         "copy input stream time base when stream copying", "mode" },
2572     { "shortest",       OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2573                         OPT_OUTPUT,                                  { .off = OFFSET(shortest) },
2574         "finish encoding within shortest input" },
2575     { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,       { &dts_delta_threshold },
2576         "timestamp discontinuity delta threshold", "threshold" },
2577     { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,       { &dts_error_threshold },
2578         "timestamp error delta threshold", "threshold" },
2579     { "xerror",         OPT_BOOL | OPT_EXPERT,                       { &exit_on_error },
2580         "exit on error", "error" },
2581     { "copyinkf",       OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2582                         OPT_OUTPUT,                                  { .off = OFFSET(copy_initial_nonkeyframes) },
2583         "copy initial non-keyframes" },
2584     { "copypriorss",    OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT,   { .off = OFFSET(copy_prior_start) },
2585         "copy or discard frames before start time" },
2586     { "frames",         OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
2587         "set the number of frames to record", "number" },
2588     { "tag",            OPT_STRING | HAS_ARG | OPT_SPEC |
2589                         OPT_EXPERT | OPT_OUTPUT,                     { .off = OFFSET(codec_tags) },
2590         "force codec tag/fourcc", "fourcc/tag" },
2591     { "q",              HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
2592                         OPT_SPEC | OPT_OUTPUT,                       { .off = OFFSET(qscale) },
2593         "use fixed quality scale (VBR)", "q" },
2594     { "qscale",         HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2595                         OPT_OUTPUT,                                  { .func_arg = opt_qscale },
2596         "use fixed quality scale (VBR)", "q" },
2597     { "profile",        HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
2598         "set profile", "profile" },
2599     { "filter",         HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
2600         "set stream filtergraph", "filter_graph" },
2601     { "reinit_filter",  HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT,    { .off = OFFSET(reinit_filters) },
2602         "reinit filtergraph on input parameter changes", "" },
2603     { "filter_complex", HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_filter_complex },
2604         "create a complex filtergraph", "graph_description" },
2605     { "stats",          OPT_BOOL,                                    { &print_stats },
2606         "print progress report during encoding", },
2607     { "attach",         HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2608                         OPT_OUTPUT,                                  { .func_arg = opt_attach },
2609         "add an attachment to the output file", "filename" },
2610     { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
2611                          OPT_EXPERT | OPT_INPUT,                     { .off = OFFSET(dump_attachment) },
2612         "extract an attachment into a file", "filename" },
2613     { "debug_ts",       OPT_BOOL | OPT_EXPERT,                       { &debug_ts },
2614         "print timestamp debugging info" },
2615
2616     /* video options */
2617     { "vframes",      OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_video_frames },
2618         "set the number of video frames to record", "number" },
2619     { "r",            OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC |
2620                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_rates) },
2621         "set frame rate (Hz value, fraction or abbreviation)", "rate" },
2622     { "s",            OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC |
2623                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_sizes) },
2624         "set frame size (WxH or abbreviation)", "size" },
2625     { "aspect",       OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC |
2626                       OPT_OUTPUT,                                                { .off = OFFSET(frame_aspect_ratios) },
2627         "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
2628     { "pix_fmt",      OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
2629                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_pix_fmts) },
2630         "set pixel format", "format" },
2631     { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG,                      { &frame_bits_per_raw_sample },
2632         "set the number of bits per raw sample", "number" },
2633     { "intra",        OPT_VIDEO | OPT_BOOL | OPT_EXPERT,                         { &intra_only },
2634         "deprecated use -g 1" },
2635     { "vn",           OPT_VIDEO | OPT_BOOL  | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) },
2636         "disable video" },
2637     { "vdt",          OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT ,               { &video_discard },
2638         "discard threshold", "n" },
2639     { "rc_override",  OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
2640                       OPT_OUTPUT,                                                { .off = OFFSET(rc_overrides) },
2641         "rate control override for specific intervals", "override" },
2642     { "vcodec",       OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_INPUT |
2643                       OPT_OUTPUT,                                                { .func_arg = opt_video_codec },
2644         "force video codec ('copy' to copy stream)", "codec" },
2645     { "sameq",        OPT_VIDEO | OPT_EXPERT ,                                   { .func_arg = opt_sameq },
2646         "Removed" },
2647     { "same_quant",   OPT_VIDEO | OPT_EXPERT ,                                   { .func_arg = opt_sameq },
2648         "Removed" },
2649     { "timecode",     OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT,            { .func_arg = opt_timecode },
2650         "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
2651     { "pass",         OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT,     { .off = OFFSET(pass) },
2652         "select the pass number (1 to 3)", "n" },
2653     { "passlogfile",  OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
2654                       OPT_OUTPUT,                                                { .off = OFFSET(passlogfiles) },
2655         "select two pass log file name prefix", "prefix" },
2656 #if FF_API_DEINTERLACE
2657     { "deinterlace",  OPT_VIDEO | OPT_EXPERT ,                                   { .func_arg = opt_deinterlace },
2658         "this option is deprecated, use the yadif filter instead" },
2659 #endif
2660     { "psnr",         OPT_VIDEO | OPT_BOOL | OPT_EXPERT,                         { &do_psnr },
2661         "calculate PSNR of compressed frames" },
2662     { "vstats",       OPT_VIDEO | OPT_EXPERT ,                                   { &opt_vstats },
2663         "dump video coding statistics to file" },
2664     { "vstats_file",  OPT_VIDEO | HAS_ARG | OPT_EXPERT ,                         { opt_vstats_file },
2665         "dump video coding statistics to file", "file" },
2666     { "vf",           OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_video_filters },
2667         "set video filters", "filter_graph" },
2668     { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
2669                       OPT_OUTPUT,                                                { .off = OFFSET(intra_matrices) },
2670         "specify intra matrix coeffs", "matrix" },
2671     { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
2672                       OPT_OUTPUT,                                                { .off = OFFSET(inter_matrices) },
2673         "specify inter matrix coeffs", "matrix" },
2674     { "top",          OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_INT| OPT_SPEC |
2675                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(top_field_first) },
2676         "top=1/bottom=0/auto=-1 field first", "" },
2677     { "dc",           OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT ,               { &intra_dc_precision },
2678         "intra_dc_precision", "precision" },
2679     { "vtag",         OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_PERFILE |
2680                       OPT_OUTPUT,                                                { .func_arg = opt_old2new },
2681         "force video tag/fourcc", "fourcc/tag" },
2682     { "qphist",       OPT_VIDEO | OPT_BOOL | OPT_EXPERT ,                        { &qp_hist },
2683         "show QP histogram" },
2684     { "force_fps",    OPT_VIDEO | OPT_BOOL | OPT_EXPERT  | OPT_SPEC |
2685                       OPT_OUTPUT,                                                { .off = OFFSET(force_fps) },
2686         "force the selected framerate, disable the best supported framerate selection" },
2687     { "streamid",     OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2688                       OPT_OUTPUT,                                                { .func_arg = opt_streamid },
2689         "set the value of an outfile streamid", "streamIndex:value" },
2690     { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2691                           OPT_SPEC | OPT_OUTPUT,                                 { .off = OFFSET(forced_key_frames) },
2692         "force key frames at specified timestamps", "timestamps" },
2693     { "b",            OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT,            { .func_arg = opt_bitrate },
2694         "video bitrate (please use -b:v)", "bitrate" },
2695
2696     /* audio options */
2697     { "aframes",        OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_frames },
2698         "set the number of audio frames to record", "number" },
2699     { "aq",             OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_qscale },
2700         "set audio quality (codec-specific)", "quality", },
2701     { "ar",             OPT_AUDIO | HAS_ARG  | OPT_INT | OPT_SPEC |
2702                         OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(audio_sample_rate) },
2703         "set audio sampling rate (in Hz)", "rate" },
2704     { "ac",             OPT_AUDIO | HAS_ARG  | OPT_INT | OPT_SPEC |
2705                         OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(audio_channels) },
2706         "set number of audio channels", "channels" },
2707     { "an",             OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) },
2708         "disable audio" },
2709     { "acodec",         OPT_AUDIO | HAS_ARG  | OPT_PERFILE |
2710                         OPT_INPUT | OPT_OUTPUT,                                    { .func_arg = opt_audio_codec },
2711         "force audio codec ('copy' to copy stream)", "codec" },
2712     { "atag",           OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_PERFILE |
2713                         OPT_OUTPUT,                                                { .func_arg = opt_old2new },
2714         "force audio tag/fourcc", "fourcc/tag" },
2715     { "vol",            OPT_AUDIO | HAS_ARG  | OPT_INT,                            { &audio_volume },
2716         "change audio volume (256=normal)" , "volume" },
2717     { "sample_fmt",     OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_SPEC |
2718                         OPT_STRING | OPT_INPUT | OPT_OUTPUT,                       { .off = OFFSET(sample_fmts) },
2719         "set sample format", "format" },
2720     { "channel_layout", OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_PERFILE |
2721                         OPT_INPUT | OPT_OUTPUT,                                    { .func_arg = opt_channel_layout },
2722         "set channel layout", "layout" },
2723     { "af",             OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_filters },
2724         "set audio filters", "filter_graph" },
2725     { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT,   { .off = OFFSET(guess_layout_max) },
2726       "set the maximum number of channels to try to guess the channel layout" },
2727
2728     /* subtitle options */
2729     { "sn",     OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
2730         "disable subtitle" },
2731     { "scodec", OPT_SUBTITLE | HAS_ARG  | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
2732         "force subtitle codec ('copy' to copy stream)", "codec" },
2733     { "stag",   OPT_SUBTITLE | HAS_ARG  | OPT_EXPERT  | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
2734         , "force subtitle tag/fourcc", "fourcc/tag" },
2735     { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC, { .off = OFFSET(fix_sub_duration) },
2736         "fix subtitles duration" },
2737     { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(canvas_sizes) },
2738         "set canvas size (WxH or abbreviation)", "size" },
2739
2740     /* grab options */
2741     { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
2742         "deprecated, use -channel", "channel" },
2743     { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
2744         "deprecated, use -standard", "standard" },
2745     { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
2746
2747     /* muxer options */
2748     { "muxdelay",   OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
2749         "set the maximum demux-decode delay", "seconds" },
2750     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
2751         "set the initial demux-decode delay", "seconds" },
2752
2753     { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
2754         "A comma-separated list of bitstream filters", "bitstream_filters" },
2755     { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
2756         "deprecated", "audio bitstream_filters" },
2757     { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
2758         "deprecated", "video bitstream_filters" },
2759
2760     { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT,    { .func_arg = opt_preset },
2761         "set the audio options to the indicated preset", "preset" },
2762     { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT,    { .func_arg = opt_preset },
2763         "set the video options to the indicated preset", "preset" },
2764     { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
2765         "set the subtitle options to the indicated preset", "preset" },
2766     { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT,                { .func_arg = opt_preset },
2767         "set options from indicated preset file", "filename" },
2768     /* data codec support */
2769     { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
2770         "force data codec ('copy' to copy stream)", "codec" },
2771     { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },
2772         "disable data" },
2773
2774     { NULL, },
2775 };