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