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