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