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