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