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