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