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