Merge commit '2b8dd371e4d276ca0d342e82b8b4cc281be0630a'
[ffmpeg.git] / ffmpeg_opt.c
1 /*
2  * ffmpeg option parsing
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * FFmpeg is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with FFmpeg; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20
21 #include <stdint.h>
22
23 #include "ffmpeg.h"
24 #include "cmdutils.h"
25
26 #include "libavformat/avformat.h"
27
28 #include "libavcodec/avcodec.h"
29
30 #include "libavfilter/avfilter.h"
31 #include "libavfilter/avfiltergraph.h"
32
33 #include "libavutil/audioconvert.h"
34 #include "libavutil/avassert.h"
35 #include "libavutil/avstring.h"
36 #include "libavutil/avutil.h"
37 #include "libavutil/intreadwrite.h"
38 #include "libavutil/fifo.h"
39 #include "libavutil/mathematics.h"
40 #include "libavutil/opt.h"
41 #include "libavutil/parseutils.h"
42 #include "libavutil/pixdesc.h"
43 #include "libavutil/pixfmt.h"
44
45 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
46 {\
47     int i, ret;\
48     for (i = 0; i < o->nb_ ## name; i++) {\
49         char *spec = o->name[i].specifier;\
50         if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
51             outvar = o->name[i].u.type;\
52         else if (ret < 0)\
53             exit(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_WARNING, "Ignoring option '%s'\n", opt);
163     return 0;
164 }
165
166 static int opt_video_channel(void *optctx, const char *opt, const char *arg)
167 {
168     av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
169     return opt_default(optctx, "channel", arg);
170 }
171
172 static int opt_video_standard(void *optctx, const char *opt, const char *arg)
173 {
174     av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
175     return opt_default(optctx, "standard", arg);
176 }
177
178 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
179 {
180     OptionsContext *o = optctx;
181     return parse_option(o, "codec:a", arg, options);
182 }
183
184 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
185 {
186     OptionsContext *o = optctx;
187     return parse_option(o, "codec:v", arg, options);
188 }
189
190 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
191 {
192     OptionsContext *o = optctx;
193     return parse_option(o, "codec:s", arg, options);
194 }
195
196 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
197 {
198     OptionsContext *o = optctx;
199     return parse_option(o, "codec:d", arg, options);
200 }
201
202 static int opt_map(void *optctx, const char *opt, const char *arg)
203 {
204     OptionsContext *o = optctx;
205     StreamMap *m = NULL;
206     int i, negative = 0, file_idx;
207     int sync_file_idx = -1, sync_stream_idx = 0;
208     char *p, *sync;
209     char *map;
210
211     if (*arg == '-') {
212         negative = 1;
213         arg++;
214     }
215     map = av_strdup(arg);
216
217     /* parse sync stream first, just pick first matching stream */
218     if (sync = strchr(map, ',')) {
219         *sync = 0;
220         sync_file_idx = strtol(sync + 1, &sync, 0);
221         if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
222             av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
223             exit(1);
224         }
225         if (*sync)
226             sync++;
227         for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
228             if (check_stream_specifier(input_files[sync_file_idx]->ctx,
229                                        input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
230                 sync_stream_idx = i;
231                 break;
232             }
233         if (i == input_files[sync_file_idx]->nb_streams) {
234             av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
235                                        "match any streams.\n", arg);
236             exit(1);
237         }
238     }
239
240
241     if (map[0] == '[') {
242         /* this mapping refers to lavfi output */
243         const char *c = map + 1;
244         o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
245                                     &o->nb_stream_maps, o->nb_stream_maps + 1);
246         m = &o->stream_maps[o->nb_stream_maps - 1];
247         m->linklabel = av_get_token(&c, "]");
248         if (!m->linklabel) {
249             av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
250             exit(1);
251         }
252     } else {
253         file_idx = strtol(map, &p, 0);
254         if (file_idx >= nb_input_files || file_idx < 0) {
255             av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
256             exit(1);
257         }
258         if (negative)
259             /* disable some already defined maps */
260             for (i = 0; i < o->nb_stream_maps; i++) {
261                 m = &o->stream_maps[i];
262                 if (file_idx == m->file_index &&
263                     check_stream_specifier(input_files[m->file_index]->ctx,
264                                            input_files[m->file_index]->ctx->streams[m->stream_index],
265                                            *p == ':' ? p + 1 : p) > 0)
266                     m->disabled = 1;
267             }
268         else
269             for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
270                 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
271                             *p == ':' ? p + 1 : p) <= 0)
272                     continue;
273                 o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
274                                             &o->nb_stream_maps, o->nb_stream_maps + 1);
275                 m = &o->stream_maps[o->nb_stream_maps - 1];
276
277                 m->file_index   = file_idx;
278                 m->stream_index = i;
279
280                 if (sync_file_idx >= 0) {
281                     m->sync_file_index   = sync_file_idx;
282                     m->sync_stream_index = sync_stream_idx;
283                 } else {
284                     m->sync_file_index   = file_idx;
285                     m->sync_stream_index = i;
286                 }
287             }
288     }
289
290     if (!m) {
291         av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
292         exit(1);
293     }
294
295     av_freep(&map);
296     return 0;
297 }
298
299 static int opt_attach(void *optctx, const char *opt, const char *arg)
300 {
301     OptionsContext *o = optctx;
302     o->attachments = grow_array(o->attachments, sizeof(*o->attachments),
303                                 &o->nb_attachments, o->nb_attachments + 1);
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     o->audio_channel_maps =
316         grow_array(o->audio_channel_maps, sizeof(*o->audio_channel_maps),
317                    &o->nb_audio_channel_maps, o->nb_audio_channel_maps + 1);
318     m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];
319
320     /* muted channel syntax */
321     n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
322     if ((n == 1 || n == 3) && m->channel_idx == -1) {
323         m->file_idx = m->stream_idx = -1;
324         if (n == 1)
325             m->ofile_idx = m->ostream_idx = -1;
326         return 0;
327     }
328
329     /* normal syntax */
330     n = sscanf(arg, "%d.%d.%d:%d.%d",
331                &m->file_idx,  &m->stream_idx, &m->channel_idx,
332                &m->ofile_idx, &m->ostream_idx);
333
334     if (n != 3 && n != 5) {
335         av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
336                "[file.stream.channel|-1][:syncfile:syncstream]\n");
337         exit(1);
338     }
339
340     if (n != 5) // only file.stream.channel specified
341         m->ofile_idx = m->ostream_idx = -1;
342
343     /* check input */
344     if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
345         av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
346                m->file_idx);
347         exit(1);
348     }
349     if (m->stream_idx < 0 ||
350         m->stream_idx >= input_files[m->file_idx]->nb_streams) {
351         av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
352                m->file_idx, m->stream_idx);
353         exit(1);
354     }
355     st = input_files[m->file_idx]->ctx->streams[m->stream_idx];
356     if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO) {
357         av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
358                m->file_idx, m->stream_idx);
359         exit(1);
360     }
361     if (m->channel_idx < 0 || m->channel_idx >= st->codec->channels) {
362         av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n",
363                m->file_idx, m->stream_idx, m->channel_idx);
364         exit(1);
365     }
366     return 0;
367 }
368
369 /**
370  * Parse a metadata specifier passed as 'arg' parameter.
371  * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
372  * @param index for type c/p, chapter/program index is written here
373  * @param stream_spec for type s, the stream specifier is written here
374  */
375 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
376 {
377     if (*arg) {
378         *type = *arg;
379         switch (*arg) {
380         case 'g':
381             break;
382         case 's':
383             if (*(++arg) && *arg != ':') {
384                 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
385                 exit(1);
386             }
387             *stream_spec = *arg == ':' ? arg + 1 : "";
388             break;
389         case 'c':
390         case 'p':
391             if (*(++arg) == ':')
392                 *index = strtol(++arg, NULL, 0);
393             break;
394         default:
395             av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
396             exit(1);
397         }
398     } else
399         *type = 'g';
400 }
401
402 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
403 {
404     AVDictionary **meta_in = NULL;
405     AVDictionary **meta_out = NULL;
406     int i, ret = 0;
407     char type_in, type_out;
408     const char *istream_spec = NULL, *ostream_spec = NULL;
409     int idx_in = 0, idx_out = 0;
410
411     parse_meta_type(inspec,  &type_in,  &idx_in,  &istream_spec);
412     parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
413
414     if (!ic) {
415         if (type_out == 'g' || !*outspec)
416             o->metadata_global_manual = 1;
417         if (type_out == 's' || !*outspec)
418             o->metadata_streams_manual = 1;
419         if (type_out == 'c' || !*outspec)
420             o->metadata_chapters_manual = 1;
421         return 0;
422     }
423
424     if (type_in == 'g' || type_out == 'g')
425         o->metadata_global_manual = 1;
426     if (type_in == 's' || type_out == 's')
427         o->metadata_streams_manual = 1;
428     if (type_in == 'c' || type_out == 'c')
429         o->metadata_chapters_manual = 1;
430
431     /* ic is NULL when just disabling automatic mappings */
432     if (!ic)
433         return 0;
434
435 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
436     if ((index) < 0 || (index) >= (nb_elems)) {\
437         av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
438                 (desc), (index));\
439         exit(1);\
440     }
441
442 #define SET_DICT(type, meta, context, index)\
443         switch (type) {\
444         case 'g':\
445             meta = &context->metadata;\
446             break;\
447         case 'c':\
448             METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
449             meta = &context->chapters[index]->metadata;\
450             break;\
451         case 'p':\
452             METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
453             meta = &context->programs[index]->metadata;\
454             break;\
455         default: av_assert0(0);\
456         case 's':\
457             break;\
458         }\
459
460     SET_DICT(type_in, meta_in, ic, idx_in);
461     SET_DICT(type_out, meta_out, oc, idx_out);
462
463     /* for input streams choose first matching stream */
464     if (type_in == 's') {
465         for (i = 0; i < ic->nb_streams; i++) {
466             if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
467                 meta_in = &ic->streams[i]->metadata;
468                 break;
469             } else if (ret < 0)
470                 exit(1);
471         }
472         if (!meta_in) {
473             av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match  any streams.\n", istream_spec);
474             exit(1);
475         }
476     }
477
478     if (type_out == 's') {
479         for (i = 0; i < oc->nb_streams; i++) {
480             if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
481                 meta_out = &oc->streams[i]->metadata;
482                 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
483             } else if (ret < 0)
484                 exit(1);
485         }
486     } else
487         av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
488
489     return 0;
490 }
491
492 static int opt_recording_timestamp(void *optctx, const char *opt, const char *arg)
493 {
494     OptionsContext *o = optctx;
495     char buf[128];
496     int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
497     struct tm time = *gmtime((time_t*)&recording_timestamp);
498     strftime(buf, sizeof(buf), "creation_time=%FT%T%z", &time);
499     parse_option(o, "metadata", buf, options);
500
501     av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
502                                  "tag instead.\n", opt);
503     return 0;
504 }
505
506 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
507 {
508     const AVCodecDescriptor *desc;
509     const char *codec_string = encoder ? "encoder" : "decoder";
510     AVCodec *codec;
511
512     codec = encoder ?
513         avcodec_find_encoder_by_name(name) :
514         avcodec_find_decoder_by_name(name);
515
516     if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
517         codec = encoder ? avcodec_find_encoder(desc->id) :
518                           avcodec_find_decoder(desc->id);
519         if (codec)
520             av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
521                    codec_string, codec->name, desc->name);
522     }
523
524     if (!codec) {
525         av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
526         exit(1);
527     }
528     if (codec->type != type) {
529         av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
530         exit(1);
531     }
532     return codec;
533 }
534
535 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
536 {
537     char *codec_name = NULL;
538
539     MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
540     if (codec_name) {
541         AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
542         st->codec->codec_id = codec->id;
543         return codec;
544     } else
545         return avcodec_find_decoder(st->codec->codec_id);
546 }
547
548 /* Add all the streams from the given input file to the global
549  * list of input streams. */
550 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
551 {
552     int i;
553     char *next, *codec_tag = NULL;
554
555     for (i = 0; i < ic->nb_streams; i++) {
556         AVStream *st = ic->streams[i];
557         AVCodecContext *dec = st->codec;
558         InputStream *ist = av_mallocz(sizeof(*ist));
559         char *framerate = NULL;
560
561         if (!ist)
562             exit(1);
563
564         input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
565         input_streams[nb_input_streams - 1] = ist;
566
567         ist->st = st;
568         ist->file_index = nb_input_files;
569         ist->discard = 1;
570         st->discard  = AVDISCARD_ALL;
571         ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, ic, st, choose_decoder(o, ic, st));
572
573         ist->ts_scale = 1.0;
574         MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
575
576         MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
577         if (codec_tag) {
578             uint32_t tag = strtol(codec_tag, &next, 0);
579             if (*next)
580                 tag = AV_RL32(codec_tag);
581             st->codec->codec_tag = tag;
582         }
583
584         ist->dec = choose_decoder(o, ic, st);
585
586         ist->reinit_filters = -1;
587         MATCH_PER_STREAM_OPT(reinit_filters, i, ist->reinit_filters, ic, st);
588
589         switch (dec->codec_type) {
590         case AVMEDIA_TYPE_VIDEO:
591             if(!ist->dec)
592                 ist->dec = avcodec_find_decoder(dec->codec_id);
593             if (dec->lowres) {
594                 dec->flags |= CODEC_FLAG_EMU_EDGE;
595             }
596
597             ist->resample_height  = dec->height;
598             ist->resample_width   = dec->width;
599             ist->resample_pix_fmt = dec->pix_fmt;
600
601             MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
602             if (framerate && av_parse_video_rate(&ist->framerate,
603                                                  framerate) < 0) {
604                 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
605                        framerate);
606                 exit(1);
607             }
608
609             ist->top_field_first = -1;
610             MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);
611
612             break;
613         case AVMEDIA_TYPE_AUDIO:
614             guess_input_channel_layout(ist);
615
616             ist->resample_sample_fmt     = dec->sample_fmt;
617             ist->resample_sample_rate    = dec->sample_rate;
618             ist->resample_channels       = dec->channels;
619             ist->resample_channel_layout = dec->channel_layout;
620
621             break;
622         case AVMEDIA_TYPE_DATA:
623         case AVMEDIA_TYPE_SUBTITLE:
624             if(!ist->dec)
625                 ist->dec = avcodec_find_decoder(dec->codec_id);
626             MATCH_PER_STREAM_OPT(fix_sub_duration, i, ist->fix_sub_duration, ic, st);
627             break;
628         case AVMEDIA_TYPE_ATTACHMENT:
629         case AVMEDIA_TYPE_UNKNOWN:
630             break;
631         default:
632             abort();
633         }
634     }
635 }
636
637 static void assert_file_overwrite(const char *filename)
638 {
639     if ((!file_overwrite || no_file_overwrite) &&
640         (strchr(filename, ':') == NULL || filename[1] == ':' ||
641          av_strstart(filename, "file:", NULL))) {
642         if (avio_check(filename, 0) == 0) {
643             if (stdin_interaction && (!no_file_overwrite || file_overwrite)) {
644                 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
645                 fflush(stderr);
646                 term_exit();
647                 signal(SIGINT, SIG_DFL);
648                 if (!read_yesno()) {
649                     av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
650                     exit(1);
651                 }
652                 term_init();
653             }
654             else {
655                 av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
656                 exit(1);
657             }
658         }
659     }
660 }
661
662 static void dump_attachment(AVStream *st, const char *filename)
663 {
664     int ret;
665     AVIOContext *out = NULL;
666     AVDictionaryEntry *e;
667
668     if (!st->codec->extradata_size) {
669         av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
670                nb_input_files - 1, st->index);
671         return;
672     }
673     if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
674         filename = e->value;
675     if (!*filename) {
676         av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
677                "in stream #%d:%d.\n", nb_input_files - 1, st->index);
678         exit(1);
679     }
680
681     assert_file_overwrite(filename);
682
683     if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
684         av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
685                filename);
686         exit(1);
687     }
688
689     avio_write(out, st->codec->extradata, st->codec->extradata_size);
690     avio_flush(out);
691     avio_close(out);
692 }
693
694 static int opt_input_file(void *optctx, const char *opt, const char *filename)
695 {
696     OptionsContext *o = optctx;
697     AVFormatContext *ic;
698     AVInputFormat *file_iformat = NULL;
699     int err, i, ret;
700     int64_t timestamp;
701     uint8_t buf[128];
702     AVDictionary **opts;
703     int orig_nb_streams;                     // number of streams before avformat_find_stream_info
704     char *   video_codec_name = NULL;
705     char *   audio_codec_name = NULL;
706     char *subtitle_codec_name = NULL;
707
708     if (o->format) {
709         if (!(file_iformat = av_find_input_format(o->format))) {
710             av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
711             exit(1);
712         }
713     }
714
715     if (!strcmp(filename, "-"))
716         filename = "pipe:";
717
718     stdin_interaction &= strncmp(filename, "pipe:", 5) &&
719                          strcmp(filename, "/dev/stdin");
720
721     /* get default parameters from command line */
722     ic = avformat_alloc_context();
723     if (!ic) {
724         print_error(filename, AVERROR(ENOMEM));
725         exit(1);
726     }
727     if (o->nb_audio_sample_rate) {
728         snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
729         av_dict_set(&format_opts, "sample_rate", buf, 0);
730     }
731     if (o->nb_audio_channels) {
732         /* because we set audio_channels based on both the "ac" and
733          * "channel_layout" options, we need to check that the specified
734          * demuxer actually has the "channels" option before setting it */
735         if (file_iformat && file_iformat->priv_class &&
736             av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
737                         AV_OPT_SEARCH_FAKE_OBJ)) {
738             snprintf(buf, sizeof(buf), "%d",
739                      o->audio_channels[o->nb_audio_channels - 1].u.i);
740             av_dict_set(&format_opts, "channels", buf, 0);
741         }
742     }
743     if (o->nb_frame_rates) {
744         /* set the format-level framerate option;
745          * this is important for video grabbers, e.g. x11 */
746         if (file_iformat && file_iformat->priv_class &&
747             av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
748                         AV_OPT_SEARCH_FAKE_OBJ)) {
749             av_dict_set(&format_opts, "framerate",
750                         o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
751         }
752     }
753     if (o->nb_frame_sizes) {
754         av_dict_set(&format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
755     }
756     if (o->nb_frame_pix_fmts)
757         av_dict_set(&format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
758
759     MATCH_PER_TYPE_OPT(codec_names, str,    video_codec_name, ic, "v");
760     MATCH_PER_TYPE_OPT(codec_names, str,    audio_codec_name, ic, "a");
761     MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, ic, "s");
762
763     ic->video_codec_id   = video_codec_name ?
764         find_codec_or_die(video_codec_name   , AVMEDIA_TYPE_VIDEO   , 0)->id : AV_CODEC_ID_NONE;
765     ic->audio_codec_id   = audio_codec_name ?
766         find_codec_or_die(audio_codec_name   , AVMEDIA_TYPE_AUDIO   , 0)->id : AV_CODEC_ID_NONE;
767     ic->subtitle_codec_id= subtitle_codec_name ?
768         find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : AV_CODEC_ID_NONE;
769     ic->flags |= AVFMT_FLAG_NONBLOCK;
770     ic->interrupt_callback = int_cb;
771
772     /* open the input file with generic avformat function */
773     err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
774     if (err < 0) {
775         print_error(filename, err);
776         exit(1);
777     }
778     assert_avoptions(format_opts);
779
780     /* apply forced codec ids */
781     for (i = 0; i < ic->nb_streams; i++)
782         choose_decoder(o, ic, ic->streams[i]);
783
784     /* Set AVCodecContext options for avformat_find_stream_info */
785     opts = setup_find_stream_info_opts(ic, codec_opts);
786     orig_nb_streams = ic->nb_streams;
787
788     /* If not enough info to get the stream parameters, we decode the
789        first frames to get it. (used in mpeg case for example) */
790     ret = avformat_find_stream_info(ic, opts);
791     if (ret < 0) {
792         av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
793         avformat_close_input(&ic);
794         exit(1);
795     }
796
797     timestamp = o->start_time;
798     /* add the stream start time */
799     if (ic->start_time != AV_NOPTS_VALUE)
800         timestamp += ic->start_time;
801
802     /* if seeking requested, we execute it */
803     if (o->start_time != 0) {
804         ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
805         if (ret < 0) {
806             av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
807                    filename, (double)timestamp / AV_TIME_BASE);
808         }
809     }
810
811     /* update the current parameters so that they match the one of the input stream */
812     add_input_streams(o, ic);
813
814     /* dump the file content */
815     av_dump_format(ic, nb_input_files, filename, 0);
816
817     input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
818     if (!(input_files[nb_input_files - 1] = av_mallocz(sizeof(*input_files[0]))))
819         exit(1);
820
821     input_files[nb_input_files - 1]->ctx        = ic;
822     input_files[nb_input_files - 1]->ist_index  = nb_input_streams - ic->nb_streams;
823     input_files[nb_input_files - 1]->ts_offset  = o->input_ts_offset - (copy_ts ? 0 : timestamp);
824     input_files[nb_input_files - 1]->nb_streams = ic->nb_streams;
825     input_files[nb_input_files - 1]->rate_emu   = o->rate_emu;
826
827     for (i = 0; i < o->nb_dump_attachment; i++) {
828         int j;
829
830         for (j = 0; j < ic->nb_streams; j++) {
831             AVStream *st = ic->streams[j];
832
833             if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
834                 dump_attachment(st, o->dump_attachment[i].u.str);
835         }
836     }
837
838     for (i = 0; i < orig_nb_streams; i++)
839         av_dict_free(&opts[i]);
840     av_freep(&opts);
841
842     reset_options(o, 1);
843     return 0;
844 }
845
846 static uint8_t *get_line(AVIOContext *s)
847 {
848     AVIOContext *line;
849     uint8_t *buf;
850     char c;
851
852     if (avio_open_dyn_buf(&line) < 0) {
853         av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
854         exit(1);
855     }
856
857     while ((c = avio_r8(s)) && c != '\n')
858         avio_w8(line, c);
859     avio_w8(line, 0);
860     avio_close_dyn_buf(line, &buf);
861
862     return buf;
863 }
864
865 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
866 {
867     int i, ret = 1;
868     char filename[1000];
869     const char *base[3] = { getenv("AVCONV_DATADIR"),
870                             getenv("HOME"),
871                             AVCONV_DATADIR,
872                             };
873
874     for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
875         if (!base[i])
876             continue;
877         if (codec_name) {
878             snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
879                      i != 1 ? "" : "/.avconv", codec_name, preset_name);
880             ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
881         }
882         if (ret) {
883             snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
884                      i != 1 ? "" : "/.avconv", preset_name);
885             ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
886         }
887     }
888     return ret;
889 }
890
891 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
892 {
893     char *codec_name = NULL;
894
895     MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
896     if (!codec_name) {
897         ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
898                                                   NULL, ost->st->codec->codec_type);
899         ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
900     } else if (!strcmp(codec_name, "copy"))
901         ost->stream_copy = 1;
902     else {
903         ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
904         ost->st->codec->codec_id = ost->enc->id;
905     }
906 }
907
908 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
909 {
910     OutputStream *ost;
911     AVStream *st = avformat_new_stream(oc, NULL);
912     int idx      = oc->nb_streams - 1, ret = 0;
913     char *bsf = NULL, *next, *codec_tag = NULL;
914     AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
915     double qscale = -1;
916
917     if (!st) {
918         av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
919         exit(1);
920     }
921
922     if (oc->nb_streams - 1 < o->nb_streamid_map)
923         st->id = o->streamid_map[oc->nb_streams - 1];
924
925     output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
926                                 nb_output_streams + 1);
927     if (!(ost = av_mallocz(sizeof(*ost))))
928         exit(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, "dither_method", 0, &ost->swr_dither_method);
1013     av_opt_get_double(swr_opts, "dither_scale" , 0, &ost->swr_dither_scale);
1014
1015     ost->source_index = source_index;
1016     if (source_index >= 0) {
1017         ost->sync_ist = input_streams[source_index];
1018         input_streams[source_index]->discard = 0;
1019         input_streams[source_index]->st->discard = AVDISCARD_NONE;
1020     }
1021
1022     return ost;
1023 }
1024
1025 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1026 {
1027     int i;
1028     const char *p = str;
1029     for (i = 0;; i++) {
1030         dest[i] = atoi(p);
1031         if (i == 63)
1032             break;
1033         p = strchr(p, ',');
1034         if (!p) {
1035             av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1036             exit(1);
1037         }
1038         p++;
1039     }
1040 }
1041
1042 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1043 {
1044     AVStream *st;
1045     OutputStream *ost;
1046     AVCodecContext *video_enc;
1047     char *frame_rate = NULL;
1048
1049     ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1050     st  = ost->st;
1051     video_enc = st->codec;
1052
1053     MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1054     if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1055         av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1056         exit(1);
1057     }
1058
1059     if (!ost->stream_copy) {
1060         const char *p = NULL;
1061         char *frame_size = NULL;
1062         char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
1063         char *intra_matrix = NULL, *inter_matrix = NULL;
1064         const char *filters = "null";
1065         int do_pass = 0;
1066         int i;
1067
1068         MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1069         if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1070             av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1071             exit(1);
1072         }
1073
1074         MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1075         if (frame_aspect_ratio) {
1076             AVRational q;
1077             if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1078                 q.num <= 0 || q.den <= 0) {
1079                 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1080                 exit(1);
1081             }
1082             ost->frame_aspect_ratio = av_q2d(q);
1083         }
1084
1085         video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1086         MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1087         if (frame_pix_fmt && *frame_pix_fmt == '+') {
1088             ost->keep_pix_fmt = 1;
1089             if (!*++frame_pix_fmt)
1090                 frame_pix_fmt = NULL;
1091         }
1092         if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1093             av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1094             exit(1);
1095         }
1096         st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1097
1098         if (intra_only)
1099             video_enc->gop_size = 0;
1100         MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1101         if (intra_matrix) {
1102             if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1103                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1104                 exit(1);
1105             }
1106             parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1107         }
1108         MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1109         if (inter_matrix) {
1110             if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1111                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1112                 exit(1);
1113             }
1114             parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1115         }
1116
1117         MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1118         for (i = 0; p; i++) {
1119             int start, end, q;
1120             int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1121             if (e != 3) {
1122                 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1123                 exit(1);
1124             }
1125             /* FIXME realloc failure */
1126             video_enc->rc_override =
1127                 av_realloc(video_enc->rc_override,
1128                            sizeof(RcOverride) * (i + 1));
1129             video_enc->rc_override[i].start_frame = start;
1130             video_enc->rc_override[i].end_frame   = end;
1131             if (q > 0) {
1132                 video_enc->rc_override[i].qscale         = q;
1133                 video_enc->rc_override[i].quality_factor = 1.0;
1134             }
1135             else {
1136                 video_enc->rc_override[i].qscale         = 0;
1137                 video_enc->rc_override[i].quality_factor = -q/100.0;
1138             }
1139             p = strchr(p, '/');
1140             if (p) p++;
1141         }
1142         video_enc->rc_override_count = i;
1143         if (!video_enc->rc_initial_buffer_occupancy)
1144             video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size * 3 / 4;
1145         video_enc->intra_dc_precision = intra_dc_precision - 8;
1146
1147         if (do_psnr)
1148             video_enc->flags|= CODEC_FLAG_PSNR;
1149
1150         /* two pass mode */
1151         MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1152         if (do_pass) {
1153             if (do_pass & 1) {
1154                 video_enc->flags |= CODEC_FLAG_PASS1;
1155             }
1156             if (do_pass & 2) {
1157                 video_enc->flags |= CODEC_FLAG_PASS2;
1158             }
1159         }
1160
1161         MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1162         if (ost->logfile_prefix &&
1163             !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1164             exit(1);
1165
1166         MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1167         if (ost->forced_keyframes)
1168             ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1169
1170         MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1171
1172         ost->top_field_first = -1;
1173         MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1174
1175         MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
1176         ost->avfilter = av_strdup(filters);
1177     } else {
1178         MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1179     }
1180
1181     return ost;
1182 }
1183
1184 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1185 {
1186     int n;
1187     AVStream *st;
1188     OutputStream *ost;
1189     AVCodecContext *audio_enc;
1190
1191     ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1192     st  = ost->st;
1193
1194     audio_enc = st->codec;
1195     audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1196
1197     if (!ost->stream_copy) {
1198         char *sample_fmt = NULL;
1199         const char *filters = "anull";
1200
1201         MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1202
1203         MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1204         if (sample_fmt &&
1205             (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1206             av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1207             exit(1);
1208         }
1209
1210         MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1211
1212         MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
1213
1214         av_assert1(filters);
1215         ost->avfilter = av_strdup(filters);
1216
1217         /* check for channel mapping for this audio stream */
1218         for (n = 0; n < o->nb_audio_channel_maps; n++) {
1219             AudioChannelMap *map = &o->audio_channel_maps[n];
1220             InputStream *ist = input_streams[ost->source_index];
1221             if ((map->channel_idx == -1 || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) &&
1222                 (map->ofile_idx   == -1 || ost->file_index == map->ofile_idx) &&
1223                 (map->ostream_idx == -1 || ost->st->index  == map->ostream_idx)) {
1224                 if (ost->audio_channels_mapped < FF_ARRAY_ELEMS(ost->audio_channels_map))
1225                     ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1226                 else
1227                     av_log(NULL, AV_LOG_FATAL, "Max channel mapping for output %d.%d reached\n",
1228                            ost->file_index, ost->st->index);
1229             }
1230         }
1231     }
1232
1233     return ost;
1234 }
1235
1236 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1237 {
1238     OutputStream *ost;
1239
1240     ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1241     if (!ost->stream_copy) {
1242         av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1243         exit(1);
1244     }
1245
1246     return ost;
1247 }
1248
1249 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1250 {
1251     OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1252     ost->stream_copy = 1;
1253     return ost;
1254 }
1255
1256 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1257 {
1258     AVStream *st;
1259     OutputStream *ost;
1260     AVCodecContext *subtitle_enc;
1261
1262     ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1263     st  = ost->st;
1264     subtitle_enc = st->codec;
1265
1266     subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1267
1268     MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1269
1270     if (!ost->stream_copy) {
1271         char *frame_size = NULL;
1272
1273         MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1274         if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1275             av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1276             exit(1);
1277         }
1278     }
1279
1280     return ost;
1281 }
1282
1283 /* arg format is "output-stream-index:streamid-value". */
1284 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1285 {
1286     OptionsContext *o = optctx;
1287     int idx;
1288     char *p;
1289     char idx_str[16];
1290
1291     av_strlcpy(idx_str, arg, sizeof(idx_str));
1292     p = strchr(idx_str, ':');
1293     if (!p) {
1294         av_log(NULL, AV_LOG_FATAL,
1295                "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1296                arg, opt);
1297         exit(1);
1298     }
1299     *p++ = '\0';
1300     idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1301     o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1302     o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1303     return 0;
1304 }
1305
1306 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1307 {
1308     AVFormatContext *is = ifile->ctx;
1309     AVFormatContext *os = ofile->ctx;
1310     AVChapter **tmp;
1311     int i;
1312
1313     tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1314     if (!tmp)
1315         return AVERROR(ENOMEM);
1316     os->chapters = tmp;
1317
1318     for (i = 0; i < is->nb_chapters; i++) {
1319         AVChapter *in_ch = is->chapters[i], *out_ch;
1320         int64_t ts_off   = av_rescale_q(ofile->start_time - ifile->ts_offset,
1321                                        AV_TIME_BASE_Q, in_ch->time_base);
1322         int64_t rt       = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1323                            av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1324
1325
1326         if (in_ch->end < ts_off)
1327             continue;
1328         if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1329             break;
1330
1331         out_ch = av_mallocz(sizeof(AVChapter));
1332         if (!out_ch)
1333             return AVERROR(ENOMEM);
1334
1335         out_ch->id        = in_ch->id;
1336         out_ch->time_base = in_ch->time_base;
1337         out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
1338         out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
1339
1340         if (copy_metadata)
1341             av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1342
1343         os->chapters[os->nb_chapters++] = out_ch;
1344     }
1345     return 0;
1346 }
1347
1348 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
1349 {
1350     int i, err;
1351     AVFormatContext *ic = avformat_alloc_context();
1352
1353     ic->interrupt_callback = int_cb;
1354     err = avformat_open_input(&ic, filename, NULL, NULL);
1355     if (err < 0)
1356         return err;
1357     /* copy stream format */
1358     for(i=0;i<ic->nb_streams;i++) {
1359         AVStream *st;
1360         OutputStream *ost;
1361         AVCodec *codec;
1362         AVCodecContext *avctx;
1363
1364         codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
1365         ost   = new_output_stream(o, s, codec->type, -1);
1366         st    = ost->st;
1367         avctx = st->codec;
1368         ost->enc = codec;
1369
1370         // FIXME: a more elegant solution is needed
1371         memcpy(st, ic->streams[i], sizeof(AVStream));
1372         st->cur_dts = 0;
1373         st->info = av_malloc(sizeof(*st->info));
1374         memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
1375         st->codec= avctx;
1376         avcodec_copy_context(st->codec, ic->streams[i]->codec);
1377
1378         if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
1379             choose_sample_fmt(st, codec);
1380         else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
1381             choose_pixel_fmt(st, codec, st->codec->pix_fmt);
1382     }
1383
1384     /* ffserver seeking with date=... needs a date reference */
1385     err = parse_option(o, "metadata", "creation_time=now", options);
1386
1387     avformat_close_input(&ic);
1388     return err;
1389 }
1390
1391 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1392                                AVFormatContext *oc)
1393 {
1394     OutputStream *ost;
1395
1396     switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1397                                   ofilter->out_tmp->pad_idx)) {
1398     case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
1399     case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
1400     default:
1401         av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1402                "currently.\n");
1403         exit(1);
1404     }
1405
1406     ost->source_index = -1;
1407     ost->filter       = ofilter;
1408
1409     ofilter->ost      = ost;
1410
1411     if (ost->stream_copy) {
1412         av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1413                "which is fed from a complex filtergraph. Filtering and streamcopy "
1414                "cannot be used together.\n", ost->file_index, ost->index);
1415         exit(1);
1416     }
1417
1418     if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
1419         av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
1420         exit(1);
1421     }
1422     avfilter_inout_free(&ofilter->out_tmp);
1423 }
1424
1425 static int configure_complex_filters(void)
1426 {
1427     int i, ret = 0;
1428
1429     for (i = 0; i < nb_filtergraphs; i++)
1430         if (!filtergraphs[i]->graph &&
1431             (ret = configure_filtergraph(filtergraphs[i])) < 0)
1432             return ret;
1433     return 0;
1434 }
1435
1436 void opt_output_file(void *optctx, const char *filename)
1437 {
1438     OptionsContext *o = optctx;
1439     AVFormatContext *oc;
1440     int i, j, err;
1441     AVOutputFormat *file_oformat;
1442     OutputStream *ost;
1443     InputStream  *ist;
1444
1445     if (configure_complex_filters() < 0) {
1446         av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
1447         exit(1);
1448     }
1449
1450     if (!strcmp(filename, "-"))
1451         filename = "pipe:";
1452
1453     err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
1454     if (!oc) {
1455         print_error(filename, err);
1456         exit(1);
1457     }
1458     file_oformat= oc->oformat;
1459     oc->interrupt_callback = int_cb;
1460
1461     /* create streams for all unlabeled output pads */
1462     for (i = 0; i < nb_filtergraphs; i++) {
1463         FilterGraph *fg = filtergraphs[i];
1464         for (j = 0; j < fg->nb_outputs; j++) {
1465             OutputFilter *ofilter = fg->outputs[j];
1466
1467             if (!ofilter->out_tmp || ofilter->out_tmp->name)
1468                 continue;
1469
1470             switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1471                                           ofilter->out_tmp->pad_idx)) {
1472             case AVMEDIA_TYPE_VIDEO:    o->video_disable    = 1; break;
1473             case AVMEDIA_TYPE_AUDIO:    o->audio_disable    = 1; break;
1474             case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1475             }
1476             init_output_filter(ofilter, o, oc);
1477         }
1478     }
1479
1480     if (!strcmp(file_oformat->name, "ffm") &&
1481         av_strstart(filename, "http:", NULL)) {
1482         int j;
1483         /* special case for files sent to ffserver: we get the stream
1484            parameters from ffserver */
1485         int err = read_ffserver_streams(o, oc, filename);
1486         if (err < 0) {
1487             print_error(filename, err);
1488             exit(1);
1489         }
1490         for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
1491             ost = output_streams[j];
1492             for (i = 0; i < nb_input_streams; i++) {
1493                 ist = input_streams[i];
1494                 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
1495                     ost->sync_ist= ist;
1496                     ost->source_index= i;
1497                     if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
1498                     if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
1499                     ist->discard = 0;
1500                     ist->st->discard = AVDISCARD_NONE;
1501                     break;
1502                 }
1503             }
1504             if(!ost->sync_ist){
1505                 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));
1506                 exit(1);
1507             }
1508         }
1509     } else if (!o->nb_stream_maps) {
1510         char *subtitle_codec_name = NULL;
1511         /* pick the "best" stream of each type */
1512
1513         /* video: highest resolution */
1514         if (!o->video_disable && oc->oformat->video_codec != AV_CODEC_ID_NONE) {
1515             int area = 0, idx = -1;
1516             int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
1517             for (i = 0; i < nb_input_streams; i++) {
1518                 int new_area;
1519                 ist = input_streams[i];
1520                 new_area = ist->st->codec->width * ist->st->codec->height;
1521                 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1522                     new_area = 1;
1523                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1524                     new_area > area) {
1525                     if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1526                         continue;
1527                     area = new_area;
1528                     idx = i;
1529                 }
1530             }
1531             if (idx >= 0)
1532                 new_video_stream(o, oc, idx);
1533         }
1534
1535         /* audio: most channels */
1536         if (!o->audio_disable && oc->oformat->audio_codec != AV_CODEC_ID_NONE) {
1537             int channels = 0, idx = -1;
1538             for (i = 0; i < nb_input_streams; i++) {
1539                 ist = input_streams[i];
1540                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1541                     ist->st->codec->channels > channels) {
1542                     channels = ist->st->codec->channels;
1543                     idx = i;
1544                 }
1545             }
1546             if (idx >= 0)
1547                 new_audio_stream(o, oc, idx);
1548         }
1549
1550         /* subtitles: pick first */
1551         MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
1552         if (!o->subtitle_disable && (oc->oformat->subtitle_codec != AV_CODEC_ID_NONE || subtitle_codec_name)) {
1553             for (i = 0; i < nb_input_streams; i++)
1554                 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1555                     new_subtitle_stream(o, oc, i);
1556                     break;
1557                 }
1558         }
1559         /* do something with data? */
1560     } else {
1561         for (i = 0; i < o->nb_stream_maps; i++) {
1562             StreamMap *map = &o->stream_maps[i];
1563             int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
1564
1565             if (map->disabled)
1566                 continue;
1567
1568             if (map->linklabel) {
1569                 FilterGraph *fg;
1570                 OutputFilter *ofilter = NULL;
1571                 int j, k;
1572
1573                 for (j = 0; j < nb_filtergraphs; j++) {
1574                     fg = filtergraphs[j];
1575                     for (k = 0; k < fg->nb_outputs; k++) {
1576                         AVFilterInOut *out = fg->outputs[k]->out_tmp;
1577                         if (out && !strcmp(out->name, map->linklabel)) {
1578                             ofilter = fg->outputs[k];
1579                             goto loop_end;
1580                         }
1581                     }
1582                 }
1583 loop_end:
1584                 if (!ofilter) {
1585                     av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1586                            "in any defined filter graph.\n", map->linklabel);
1587                     exit(1);
1588                 }
1589                 init_output_filter(ofilter, o, oc);
1590             } else {
1591                 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
1592                 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
1593                     continue;
1594                 if(o->   audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1595                     continue;
1596                 if(o->   video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
1597                     continue;
1598                 if(o->    data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
1599                     continue;
1600
1601                 switch (ist->st->codec->codec_type) {
1602                 case AVMEDIA_TYPE_VIDEO:      ost = new_video_stream     (o, oc, src_idx); break;
1603                 case AVMEDIA_TYPE_AUDIO:      ost = new_audio_stream     (o, oc, src_idx); break;
1604                 case AVMEDIA_TYPE_SUBTITLE:   ost = new_subtitle_stream  (o, oc, src_idx); break;
1605                 case AVMEDIA_TYPE_DATA:       ost = new_data_stream      (o, oc, src_idx); break;
1606                 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
1607                 default:
1608                     av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
1609                            map->file_index, map->stream_index);
1610                     exit(1);
1611                 }
1612             }
1613         }
1614     }
1615
1616
1617     for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
1618         AVDictionaryEntry *e;
1619         ost = output_streams[i];
1620
1621         if (   ost->stream_copy
1622             && (e = av_dict_get(codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
1623             && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
1624             if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
1625                 exit(1);
1626     }
1627
1628     /* handle attached files */
1629     for (i = 0; i < o->nb_attachments; i++) {
1630         AVIOContext *pb;
1631         uint8_t *attachment;
1632         const char *p;
1633         int64_t len;
1634
1635         if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
1636             av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
1637                    o->attachments[i]);
1638             exit(1);
1639         }
1640         if ((len = avio_size(pb)) <= 0) {
1641             av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
1642                    o->attachments[i]);
1643             exit(1);
1644         }
1645         if (!(attachment = av_malloc(len))) {
1646             av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
1647                    o->attachments[i]);
1648             exit(1);
1649         }
1650         avio_read(pb, attachment, len);
1651
1652         ost = new_attachment_stream(o, oc, -1);
1653         ost->stream_copy               = 0;
1654         ost->attachment_filename       = o->attachments[i];
1655         ost->st->codec->extradata      = attachment;
1656         ost->st->codec->extradata_size = len;
1657
1658         p = strrchr(o->attachments[i], '/');
1659         av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
1660         avio_close(pb);
1661     }
1662
1663     output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
1664     if (!(output_files[nb_output_files - 1] = av_mallocz(sizeof(*output_files[0]))))
1665         exit(1);
1666
1667     output_files[nb_output_files - 1]->ctx            = oc;
1668     output_files[nb_output_files - 1]->ost_index      = nb_output_streams - oc->nb_streams;
1669     output_files[nb_output_files - 1]->recording_time = o->recording_time;
1670     if (o->recording_time != INT64_MAX)
1671         oc->duration = o->recording_time;
1672     output_files[nb_output_files - 1]->start_time     = o->start_time;
1673     output_files[nb_output_files - 1]->limit_filesize = o->limit_filesize;
1674     output_files[nb_output_files - 1]->shortest       = o->shortest;
1675     av_dict_copy(&output_files[nb_output_files - 1]->opts, format_opts, 0);
1676
1677     /* check filename in case of an image number is expected */
1678     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
1679         if (!av_filename_number_test(oc->filename)) {
1680             print_error(oc->filename, AVERROR(EINVAL));
1681             exit(1);
1682         }
1683     }
1684
1685     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
1686         /* test if it already exists to avoid losing precious files */
1687         assert_file_overwrite(filename);
1688
1689         /* open the file */
1690         if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
1691                               &oc->interrupt_callback,
1692                               &output_files[nb_output_files - 1]->opts)) < 0) {
1693             print_error(filename, err);
1694             exit(1);
1695         }
1696     }
1697
1698     if (o->mux_preload) {
1699         uint8_t buf[64];
1700         snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
1701         av_dict_set(&output_files[nb_output_files - 1]->opts, "preload", buf, 0);
1702     }
1703     oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
1704
1705     /* copy metadata */
1706     for (i = 0; i < o->nb_metadata_map; i++) {
1707         char *p;
1708         int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
1709
1710         if (in_file_index >= nb_input_files) {
1711             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
1712             exit(1);
1713         }
1714         copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
1715                       in_file_index >= 0 ?
1716                       input_files[in_file_index]->ctx : NULL, o);
1717     }
1718
1719     /* copy chapters */
1720     if (o->chapters_input_file >= nb_input_files) {
1721         if (o->chapters_input_file == INT_MAX) {
1722             /* copy chapters from the first input file that has them*/
1723             o->chapters_input_file = -1;
1724             for (i = 0; i < nb_input_files; i++)
1725                 if (input_files[i]->ctx->nb_chapters) {
1726                     o->chapters_input_file = i;
1727                     break;
1728                 }
1729         } else {
1730             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
1731                    o->chapters_input_file);
1732             exit(1);
1733         }
1734     }
1735     if (o->chapters_input_file >= 0)
1736         copy_chapters(input_files[o->chapters_input_file], output_files[nb_output_files - 1],
1737                       !o->metadata_chapters_manual);
1738
1739     /* copy global metadata by default */
1740     if (!o->metadata_global_manual && nb_input_files){
1741         av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
1742                      AV_DICT_DONT_OVERWRITE);
1743         if(o->recording_time != INT64_MAX)
1744             av_dict_set(&oc->metadata, "duration", NULL, 0);
1745         av_dict_set(&oc->metadata, "creation_time", NULL, 0);
1746     }
1747     if (!o->metadata_streams_manual)
1748         for (i = output_files[nb_output_files - 1]->ost_index; i < nb_output_streams; i++) {
1749             InputStream *ist;
1750             if (output_streams[i]->source_index < 0)         /* this is true e.g. for attached files */
1751                 continue;
1752             ist = input_streams[output_streams[i]->source_index];
1753             av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
1754         }
1755
1756     /* process manually set metadata */
1757     for (i = 0; i < o->nb_metadata; i++) {
1758         AVDictionary **m;
1759         char type, *val;
1760         const char *stream_spec;
1761         int index = 0, j, ret = 0;
1762
1763         val = strchr(o->metadata[i].u.str, '=');
1764         if (!val) {
1765             av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
1766                    o->metadata[i].u.str);
1767             exit(1);
1768         }
1769         *val++ = 0;
1770
1771         parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
1772         if (type == 's') {
1773             for (j = 0; j < oc->nb_streams; j++) {
1774                 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
1775                     av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
1776                 } else if (ret < 0)
1777                     exit(1);
1778             }
1779         }
1780         else {
1781             switch (type) {
1782             case 'g':
1783                 m = &oc->metadata;
1784                 break;
1785             case 'c':
1786                 if (index < 0 || index >= oc->nb_chapters) {
1787                     av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
1788                     exit(1);
1789                 }
1790                 m = &oc->chapters[index]->metadata;
1791                 break;
1792             default:
1793                 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
1794                 exit(1);
1795             }
1796             av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
1797         }
1798     }
1799
1800     reset_options(o, 0);
1801 }
1802
1803 static int opt_target(void *optctx, const char *opt, const char *arg)
1804 {
1805     OptionsContext *o = optctx;
1806     enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
1807     static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
1808
1809     if (!strncmp(arg, "pal-", 4)) {
1810         norm = PAL;
1811         arg += 4;
1812     } else if (!strncmp(arg, "ntsc-", 5)) {
1813         norm = NTSC;
1814         arg += 5;
1815     } else if (!strncmp(arg, "film-", 5)) {
1816         norm = FILM;
1817         arg += 5;
1818     } else {
1819         /* Try to determine PAL/NTSC by peeking in the input files */
1820         if (nb_input_files) {
1821             int i, j, fr;
1822             for (j = 0; j < nb_input_files; j++) {
1823                 for (i = 0; i < input_files[j]->nb_streams; i++) {
1824                     AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
1825                     if (c->codec_type != AVMEDIA_TYPE_VIDEO)
1826                         continue;
1827                     fr = c->time_base.den * 1000 / c->time_base.num;
1828                     if (fr == 25000) {
1829                         norm = PAL;
1830                         break;
1831                     } else if ((fr == 29970) || (fr == 23976)) {
1832                         norm = NTSC;
1833                         break;
1834                     }
1835                 }
1836                 if (norm != UNKNOWN)
1837                     break;
1838             }
1839         }
1840         if (norm != UNKNOWN)
1841             av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
1842     }
1843
1844     if (norm == UNKNOWN) {
1845         av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
1846         av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
1847         av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
1848         exit(1);
1849     }
1850
1851     if (!strcmp(arg, "vcd")) {
1852         opt_video_codec(o, "c:v", "mpeg1video");
1853         opt_audio_codec(o, "c:a", "mp2");
1854         parse_option(o, "f", "vcd", options);
1855
1856         parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
1857         parse_option(o, "r", frame_rates[norm], options);
1858         opt_default(NULL, "g", norm == PAL ? "15" : "18");
1859
1860         opt_default(NULL, "b:v", "1150000");
1861         opt_default(NULL, "maxrate", "1150000");
1862         opt_default(NULL, "minrate", "1150000");
1863         opt_default(NULL, "bufsize", "327680"); // 40*1024*8;
1864
1865         opt_default(NULL, "b:a", "224000");
1866         parse_option(o, "ar", "44100", options);
1867         parse_option(o, "ac", "2", options);
1868
1869         opt_default(NULL, "packetsize", "2324");
1870         opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
1871
1872         /* We have to offset the PTS, so that it is consistent with the SCR.
1873            SCR starts at 36000, but the first two packs contain only padding
1874            and the first pack from the other stream, respectively, may also have
1875            been written before.
1876            So the real data starts at SCR 36000+3*1200. */
1877         o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
1878     } else if (!strcmp(arg, "svcd")) {
1879
1880         opt_video_codec(o, "c:v", "mpeg2video");
1881         opt_audio_codec(o, "c:a", "mp2");
1882         parse_option(o, "f", "svcd", options);
1883
1884         parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
1885         parse_option(o, "r", frame_rates[norm], options);
1886         parse_option(o, "pix_fmt", "yuv420p", options);
1887         opt_default(NULL, "g", norm == PAL ? "15" : "18");
1888
1889         opt_default(NULL, "b:v", "2040000");
1890         opt_default(NULL, "maxrate", "2516000");
1891         opt_default(NULL, "minrate", "0"); // 1145000;
1892         opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
1893         opt_default(NULL, "scan_offset", "1");
1894
1895         opt_default(NULL, "b:a", "224000");
1896         parse_option(o, "ar", "44100", options);
1897
1898         opt_default(NULL, "packetsize", "2324");
1899
1900     } else if (!strcmp(arg, "dvd")) {
1901
1902         opt_video_codec(o, "c:v", "mpeg2video");
1903         opt_audio_codec(o, "c:a", "ac3");
1904         parse_option(o, "f", "dvd", options);
1905
1906         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1907         parse_option(o, "r", frame_rates[norm], options);
1908         parse_option(o, "pix_fmt", "yuv420p", options);
1909         opt_default(NULL, "g", norm == PAL ? "15" : "18");
1910
1911         opt_default(NULL, "b:v", "6000000");
1912         opt_default(NULL, "maxrate", "9000000");
1913         opt_default(NULL, "minrate", "0"); // 1500000;
1914         opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
1915
1916         opt_default(NULL, "packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
1917         opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
1918
1919         opt_default(NULL, "b:a", "448000");
1920         parse_option(o, "ar", "48000", options);
1921
1922     } else if (!strncmp(arg, "dv", 2)) {
1923
1924         parse_option(o, "f", "dv", options);
1925
1926         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1927         parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
1928                           norm == PAL ? "yuv420p" : "yuv411p", options);
1929         parse_option(o, "r", frame_rates[norm], options);
1930
1931         parse_option(o, "ar", "48000", options);
1932         parse_option(o, "ac", "2", options);
1933
1934     } else {
1935         av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
1936         return AVERROR(EINVAL);
1937     }
1938     return 0;
1939 }
1940
1941 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
1942 {
1943     av_free (vstats_filename);
1944     vstats_filename = av_strdup (arg);
1945     return 0;
1946 }
1947
1948 static int opt_vstats(void *optctx, const char *opt, const char *arg)
1949 {
1950     char filename[40];
1951     time_t today2 = time(NULL);
1952     struct tm *today = localtime(&today2);
1953
1954     snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
1955              today->tm_sec);
1956     return opt_vstats_file(NULL, opt, filename);
1957 }
1958
1959 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
1960 {
1961     OptionsContext *o = optctx;
1962     return parse_option(o, "frames:v", arg, options);
1963 }
1964
1965 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
1966 {
1967     OptionsContext *o = optctx;
1968     return parse_option(o, "frames:a", arg, options);
1969 }
1970
1971 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
1972 {
1973     OptionsContext *o = optctx;
1974     return parse_option(o, "frames:d", arg, options);
1975 }
1976
1977 static int opt_preset(void *optctx, const char *opt, const char *arg)
1978 {
1979     OptionsContext *o = optctx;
1980     FILE *f=NULL;
1981     char filename[1000], line[1000], tmp_line[1000];
1982     const char *codec_name = NULL;
1983
1984     tmp_line[0] = *opt;
1985     tmp_line[1] = 0;
1986     MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
1987
1988     if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
1989         if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
1990             av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
1991         }else
1992             av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
1993         exit(1);
1994 }
1995
1996     while (fgets(line, sizeof(line), f)) {
1997         char *key = tmp_line, *value, *endptr;
1998
1999         if (strcspn(line, "#\n\r") == 0)
2000             continue;
2001         strcpy(tmp_line, line);
2002         if (!av_strtok(key,   "=",    &value) ||
2003             !av_strtok(value, "\r\n", &endptr)) {
2004             av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2005             exit(1);
2006         }
2007         av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2008
2009         if      (!strcmp(key, "acodec")) opt_audio_codec   (o, key, value);
2010         else if (!strcmp(key, "vcodec")) opt_video_codec   (o, key, value);
2011         else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2012         else if (!strcmp(key, "dcodec")) opt_data_codec    (o, key, value);
2013         else if (opt_default(NULL, key, value) < 0) {
2014             av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2015                    filename, line, key, value);
2016             exit(1);
2017         }
2018     }
2019
2020     fclose(f);
2021
2022     return 0;
2023 }
2024
2025 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2026 {
2027     OptionsContext *o = optctx;
2028     char *s = av_asprintf("%s:%c", opt + 1, *opt);
2029     int ret = parse_option(o, s, arg, options);
2030     av_free(s);
2031     return ret;
2032 }
2033
2034 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2035 {
2036     OptionsContext *o = optctx;
2037     if(!strcmp(opt, "b")){
2038         av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2039         return parse_option(o, "b:v", arg, options);
2040     }
2041     return opt_default(optctx, opt, arg);
2042 }
2043
2044 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2045 {
2046     OptionsContext *o = optctx;
2047     char *s;
2048     int ret;
2049     if(!strcmp(opt, "qscale")){
2050         av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2051         return parse_option(o, "q:v", arg, options);
2052     }
2053     s = av_asprintf("q%s", opt + 6);
2054     ret = parse_option(o, s, arg, options);
2055     av_free(s);
2056     return ret;
2057 }
2058
2059 static int opt_profile(void *optctx, const char *opt, const char *arg)
2060 {
2061     OptionsContext *o = optctx;
2062     if(!strcmp(opt, "profile")){
2063         av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2064         return parse_option(o, "profile:v", arg, options);
2065     }
2066     return opt_default(optctx, opt, arg);
2067
2068 }
2069
2070 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2071 {
2072     OptionsContext *o = optctx;
2073     return parse_option(o, "filter:v", arg, options);
2074 }
2075
2076 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2077 {
2078     OptionsContext *o = optctx;
2079     return parse_option(o, "filter:a", arg, options);
2080 }
2081
2082 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2083 {
2084     if      (!av_strcasecmp(arg, "cfr"))         video_sync_method = VSYNC_CFR;
2085     else if (!av_strcasecmp(arg, "vfr"))         video_sync_method = VSYNC_VFR;
2086     else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2087     else if (!av_strcasecmp(arg, "drop"))        video_sync_method = VSYNC_DROP;
2088
2089     if (video_sync_method == VSYNC_AUTO)
2090         video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
2091     return 0;
2092 }
2093
2094 static int opt_deinterlace(void *optctx, const char *opt, const char *arg)
2095 {
2096     av_log(NULL, AV_LOG_WARNING, "-%s is deprecated, use -filter:v yadif instead\n", opt);
2097     do_deinterlace = 1;
2098     return 0;
2099 }
2100
2101 static int opt_timecode(void *optctx, const char *opt, const char *arg)
2102 {
2103     OptionsContext *o = optctx;
2104     char *tcr = av_asprintf("timecode=%s", arg);
2105     int ret = parse_option(o, "metadata:g", tcr, options);
2106     if (ret >= 0)
2107         ret = opt_default(optctx, "gop_timecode", arg);
2108     av_free(tcr);
2109     return ret;
2110 }
2111
2112 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2113 {
2114     OptionsContext *o = optctx;
2115     char layout_str[32];
2116     char *stream_str;
2117     char *ac_str;
2118     int ret, channels, ac_str_size;
2119     uint64_t layout;
2120
2121     layout = av_get_channel_layout(arg);
2122     if (!layout) {
2123         av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2124         return AVERROR(EINVAL);
2125     }
2126     snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2127     ret = opt_default(NULL, opt, layout_str);
2128     if (ret < 0)
2129         return ret;
2130
2131     /* set 'ac' option based on channel layout */
2132     channels = av_get_channel_layout_nb_channels(layout);
2133     snprintf(layout_str, sizeof(layout_str), "%d", channels);
2134     stream_str = strchr(opt, ':');
2135     ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2136     ac_str = av_mallocz(ac_str_size);
2137     if (!ac_str)
2138         return AVERROR(ENOMEM);
2139     av_strlcpy(ac_str, "ac", 3);
2140     if (stream_str)
2141         av_strlcat(ac_str, stream_str, ac_str_size);
2142     ret = parse_option(o, ac_str, layout_str, options);
2143     av_free(ac_str);
2144
2145     return ret;
2146 }
2147
2148 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2149 {
2150     OptionsContext *o = optctx;
2151     return parse_option(o, "q:a", arg, options);
2152 }
2153
2154 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2155 {
2156     filtergraphs = grow_array(filtergraphs, sizeof(*filtergraphs),
2157                               &nb_filtergraphs, nb_filtergraphs + 1);
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(0, 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 };