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