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