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