Merge commit '3d624420086ed3cd0c74f4510f0285968e21c117'
[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 - 1;
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, *frame_aspect_ratio = 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     MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1184     if (frame_aspect_ratio) {
1185         AVRational q;
1186         if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1187             q.num <= 0 || q.den <= 0) {
1188             av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1189             exit(1);
1190         }
1191         ost->frame_aspect_ratio = q;
1192     }
1193
1194     if (!ost->stream_copy) {
1195         const char *p = NULL;
1196         char *frame_size = NULL;
1197         char *frame_pix_fmt = NULL;
1198         char *intra_matrix = NULL, *inter_matrix = NULL;
1199         int do_pass = 0;
1200         int i;
1201
1202         MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1203         if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1204             av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1205             exit(1);
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 (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
1577         o->stop_time = INT64_MAX;
1578         av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
1579     }
1580
1581     if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
1582         if (o->stop_time <= o->start_time) {
1583             av_log(NULL, AV_LOG_WARNING, "-to value smaller than -ss; ignoring -to.\n");
1584             o->stop_time = INT64_MAX;
1585         } else {
1586             o->recording_time = o->stop_time - o->start_time;
1587         }
1588     }
1589
1590     GROW_ARRAY(output_files, nb_output_files);
1591     of = av_mallocz(sizeof(*of));
1592     if (!of)
1593         exit(1);
1594     output_files[nb_output_files - 1] = of;
1595
1596     of->ost_index      = nb_output_streams;
1597     of->recording_time = o->recording_time;
1598     of->start_time     = o->start_time;
1599     of->limit_filesize = o->limit_filesize;
1600     of->shortest       = o->shortest;
1601     av_dict_copy(&of->opts, o->g->format_opts, 0);
1602
1603     if (!strcmp(filename, "-"))
1604         filename = "pipe:";
1605
1606     err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
1607     if (!oc) {
1608         print_error(filename, err);
1609         exit(1);
1610     }
1611
1612     of->ctx = oc;
1613     if (o->recording_time != INT64_MAX)
1614         oc->duration = o->recording_time;
1615
1616     file_oformat= oc->oformat;
1617     oc->interrupt_callback = int_cb;
1618
1619     /* create streams for all unlabeled output pads */
1620     for (i = 0; i < nb_filtergraphs; i++) {
1621         FilterGraph *fg = filtergraphs[i];
1622         for (j = 0; j < fg->nb_outputs; j++) {
1623             OutputFilter *ofilter = fg->outputs[j];
1624
1625             if (!ofilter->out_tmp || ofilter->out_tmp->name)
1626                 continue;
1627
1628             switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1629                                           ofilter->out_tmp->pad_idx)) {
1630             case AVMEDIA_TYPE_VIDEO:    o->video_disable    = 1; break;
1631             case AVMEDIA_TYPE_AUDIO:    o->audio_disable    = 1; break;
1632             case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1633             }
1634             init_output_filter(ofilter, o, oc);
1635         }
1636     }
1637
1638     if (!strcmp(file_oformat->name, "ffm") &&
1639         av_strstart(filename, "http:", NULL)) {
1640         int j;
1641         /* special case for files sent to ffserver: we get the stream
1642            parameters from ffserver */
1643         int err = read_ffserver_streams(o, oc, filename);
1644         if (err < 0) {
1645             print_error(filename, err);
1646             exit(1);
1647         }
1648         for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
1649             ost = output_streams[j];
1650             for (i = 0; i < nb_input_streams; i++) {
1651                 ist = input_streams[i];
1652                 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
1653                     ost->sync_ist= ist;
1654                     ost->source_index= i;
1655                     if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
1656                     if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
1657                     ist->discard = 0;
1658                     ist->st->discard = AVDISCARD_NONE;
1659                     break;
1660                 }
1661             }
1662             if(!ost->sync_ist){
1663                 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));
1664                 exit(1);
1665             }
1666         }
1667     } else if (!o->nb_stream_maps) {
1668         char *subtitle_codec_name = NULL;
1669         /* pick the "best" stream of each type */
1670
1671         /* video: highest resolution */
1672         if (!o->video_disable && oc->oformat->video_codec != AV_CODEC_ID_NONE) {
1673             int area = 0, idx = -1;
1674             int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
1675             for (i = 0; i < nb_input_streams; i++) {
1676                 int new_area;
1677                 ist = input_streams[i];
1678                 new_area = ist->st->codec->width * ist->st->codec->height;
1679                 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1680                     new_area = 1;
1681                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1682                     new_area > area) {
1683                     if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1684                         continue;
1685                     area = new_area;
1686                     idx = i;
1687                 }
1688             }
1689             if (idx >= 0)
1690                 new_video_stream(o, oc, idx);
1691         }
1692
1693         /* audio: most channels */
1694         if (!o->audio_disable && oc->oformat->audio_codec != AV_CODEC_ID_NONE) {
1695             int channels = 0, idx = -1;
1696             for (i = 0; i < nb_input_streams; i++) {
1697                 ist = input_streams[i];
1698                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1699                     ist->st->codec->channels > channels) {
1700                     channels = ist->st->codec->channels;
1701                     idx = i;
1702                 }
1703             }
1704             if (idx >= 0)
1705                 new_audio_stream(o, oc, idx);
1706         }
1707
1708         /* subtitles: pick first */
1709         MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
1710         if (!o->subtitle_disable && (oc->oformat->subtitle_codec != AV_CODEC_ID_NONE || subtitle_codec_name)) {
1711             for (i = 0; i < nb_input_streams; i++)
1712                 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1713                     new_subtitle_stream(o, oc, i);
1714                     break;
1715                 }
1716         }
1717         /* do something with data? */
1718     } else {
1719         for (i = 0; i < o->nb_stream_maps; i++) {
1720             StreamMap *map = &o->stream_maps[i];
1721             int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
1722
1723             if (map->disabled)
1724                 continue;
1725
1726             if (map->linklabel) {
1727                 FilterGraph *fg;
1728                 OutputFilter *ofilter = NULL;
1729                 int j, k;
1730
1731                 for (j = 0; j < nb_filtergraphs; j++) {
1732                     fg = filtergraphs[j];
1733                     for (k = 0; k < fg->nb_outputs; k++) {
1734                         AVFilterInOut *out = fg->outputs[k]->out_tmp;
1735                         if (out && !strcmp(out->name, map->linklabel)) {
1736                             ofilter = fg->outputs[k];
1737                             goto loop_end;
1738                         }
1739                     }
1740                 }
1741 loop_end:
1742                 if (!ofilter) {
1743                     av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1744                            "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
1745                     exit(1);
1746                 }
1747                 init_output_filter(ofilter, o, oc);
1748             } else {
1749                 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
1750                 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
1751                     continue;
1752                 if(o->   audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1753                     continue;
1754                 if(o->   video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
1755                     continue;
1756                 if(o->    data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
1757                     continue;
1758
1759                 switch (ist->st->codec->codec_type) {
1760                 case AVMEDIA_TYPE_VIDEO:      ost = new_video_stream     (o, oc, src_idx); break;
1761                 case AVMEDIA_TYPE_AUDIO:      ost = new_audio_stream     (o, oc, src_idx); break;
1762                 case AVMEDIA_TYPE_SUBTITLE:   ost = new_subtitle_stream  (o, oc, src_idx); break;
1763                 case AVMEDIA_TYPE_DATA:       ost = new_data_stream      (o, oc, src_idx); break;
1764                 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
1765                 default:
1766                     av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
1767                            map->file_index, map->stream_index);
1768                     exit(1);
1769                 }
1770             }
1771         }
1772     }
1773
1774     /* handle attached files */
1775     for (i = 0; i < o->nb_attachments; i++) {
1776         AVIOContext *pb;
1777         uint8_t *attachment;
1778         const char *p;
1779         int64_t len;
1780
1781         if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
1782             av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
1783                    o->attachments[i]);
1784             exit(1);
1785         }
1786         if ((len = avio_size(pb)) <= 0) {
1787             av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
1788                    o->attachments[i]);
1789             exit(1);
1790         }
1791         if (!(attachment = av_malloc(len))) {
1792             av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
1793                    o->attachments[i]);
1794             exit(1);
1795         }
1796         avio_read(pb, attachment, len);
1797
1798         ost = new_attachment_stream(o, oc, -1);
1799         ost->stream_copy               = 0;
1800         ost->attachment_filename       = o->attachments[i];
1801         ost->finished                  = 1;
1802         ost->st->codec->extradata      = attachment;
1803         ost->st->codec->extradata_size = len;
1804
1805         p = strrchr(o->attachments[i], '/');
1806         av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
1807         avio_close(pb);
1808     }
1809
1810     for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
1811         AVDictionaryEntry *e;
1812         ost = output_streams[i];
1813
1814         if ((ost->stream_copy || ost->attachment_filename)
1815             && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
1816             && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
1817             if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
1818                 exit(1);
1819     }
1820
1821     /* check if all codec options have been used */
1822     unused_opts = strip_specifiers(o->g->codec_opts);
1823     for (i = of->ost_index; i < nb_output_streams; i++) {
1824         e = NULL;
1825         while ((e = av_dict_get(output_streams[i]->opts, "", e,
1826                                 AV_DICT_IGNORE_SUFFIX)))
1827             av_dict_set(&unused_opts, e->key, NULL, 0);
1828     }
1829
1830     e = NULL;
1831     while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
1832         const AVClass *class = avcodec_get_class();
1833         const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
1834                                              AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1835         if (!option)
1836             continue;
1837         if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
1838             av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
1839                    "output file #%d (%s) is not an encoding option.\n", e->key,
1840                    option->help ? option->help : "", nb_output_files - 1,
1841                    filename);
1842             exit(1);
1843         }
1844
1845         av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
1846                "output file #%d (%s) has not been used for any stream. The most "
1847                "likely reason is either wrong type (e.g. a video option with "
1848                "no video streams) or that it is a private option of some encoder "
1849                "which was not actually used for any stream.\n", e->key,
1850                option->help ? option->help : "", nb_output_files - 1, filename);
1851     }
1852     av_dict_free(&unused_opts);
1853
1854     /* check filename in case of an image number is expected */
1855     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
1856         if (!av_filename_number_test(oc->filename)) {
1857             print_error(oc->filename, AVERROR(EINVAL));
1858             exit(1);
1859         }
1860     }
1861
1862     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
1863         /* test if it already exists to avoid losing precious files */
1864         assert_file_overwrite(filename);
1865
1866         /* open the file */
1867         if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
1868                               &oc->interrupt_callback,
1869                               &of->opts)) < 0) {
1870             print_error(filename, err);
1871             exit(1);
1872         }
1873     } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
1874         assert_file_overwrite(filename);
1875
1876     if (o->mux_preload) {
1877         uint8_t buf[64];
1878         snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
1879         av_dict_set(&of->opts, "preload", buf, 0);
1880     }
1881     oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
1882
1883     /* copy metadata */
1884     for (i = 0; i < o->nb_metadata_map; i++) {
1885         char *p;
1886         int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
1887
1888         if (in_file_index >= nb_input_files) {
1889             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
1890             exit(1);
1891         }
1892         copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
1893                       in_file_index >= 0 ?
1894                       input_files[in_file_index]->ctx : NULL, o);
1895     }
1896
1897     /* copy chapters */
1898     if (o->chapters_input_file >= nb_input_files) {
1899         if (o->chapters_input_file == INT_MAX) {
1900             /* copy chapters from the first input file that has them*/
1901             o->chapters_input_file = -1;
1902             for (i = 0; i < nb_input_files; i++)
1903                 if (input_files[i]->ctx->nb_chapters) {
1904                     o->chapters_input_file = i;
1905                     break;
1906                 }
1907         } else {
1908             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
1909                    o->chapters_input_file);
1910             exit(1);
1911         }
1912     }
1913     if (o->chapters_input_file >= 0)
1914         copy_chapters(input_files[o->chapters_input_file], of,
1915                       !o->metadata_chapters_manual);
1916
1917     /* copy global metadata by default */
1918     if (!o->metadata_global_manual && nb_input_files){
1919         av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
1920                      AV_DICT_DONT_OVERWRITE);
1921         if(o->recording_time != INT64_MAX)
1922             av_dict_set(&oc->metadata, "duration", NULL, 0);
1923         av_dict_set(&oc->metadata, "creation_time", NULL, 0);
1924     }
1925     if (!o->metadata_streams_manual)
1926         for (i = of->ost_index; i < nb_output_streams; i++) {
1927             InputStream *ist;
1928             if (output_streams[i]->source_index < 0)         /* this is true e.g. for attached files */
1929                 continue;
1930             ist = input_streams[output_streams[i]->source_index];
1931             av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
1932         }
1933
1934     /* process manually set metadata */
1935     for (i = 0; i < o->nb_metadata; i++) {
1936         AVDictionary **m;
1937         char type, *val;
1938         const char *stream_spec;
1939         int index = 0, j, ret = 0;
1940
1941         val = strchr(o->metadata[i].u.str, '=');
1942         if (!val) {
1943             av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
1944                    o->metadata[i].u.str);
1945             exit(1);
1946         }
1947         *val++ = 0;
1948
1949         parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
1950         if (type == 's') {
1951             for (j = 0; j < oc->nb_streams; j++) {
1952                 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
1953                     av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
1954                 } else if (ret < 0)
1955                     exit(1);
1956             }
1957         }
1958         else {
1959             switch (type) {
1960             case 'g':
1961                 m = &oc->metadata;
1962                 break;
1963             case 'c':
1964                 if (index < 0 || index >= oc->nb_chapters) {
1965                     av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
1966                     exit(1);
1967                 }
1968                 m = &oc->chapters[index]->metadata;
1969                 break;
1970             default:
1971                 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
1972                 exit(1);
1973             }
1974             av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
1975         }
1976     }
1977
1978     return 0;
1979 }
1980
1981 static int opt_target(void *optctx, const char *opt, const char *arg)
1982 {
1983     OptionsContext *o = optctx;
1984     enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
1985     static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
1986
1987     if (!strncmp(arg, "pal-", 4)) {
1988         norm = PAL;
1989         arg += 4;
1990     } else if (!strncmp(arg, "ntsc-", 5)) {
1991         norm = NTSC;
1992         arg += 5;
1993     } else if (!strncmp(arg, "film-", 5)) {
1994         norm = FILM;
1995         arg += 5;
1996     } else {
1997         /* Try to determine PAL/NTSC by peeking in the input files */
1998         if (nb_input_files) {
1999             int i, j, fr;
2000             for (j = 0; j < nb_input_files; j++) {
2001                 for (i = 0; i < input_files[j]->nb_streams; i++) {
2002                     AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
2003                     if (c->codec_type != AVMEDIA_TYPE_VIDEO)
2004                         continue;
2005                     fr = c->time_base.den * 1000 / c->time_base.num;
2006                     if (fr == 25000) {
2007                         norm = PAL;
2008                         break;
2009                     } else if ((fr == 29970) || (fr == 23976)) {
2010                         norm = NTSC;
2011                         break;
2012                     }
2013                 }
2014                 if (norm != UNKNOWN)
2015                     break;
2016             }
2017         }
2018         if (norm != UNKNOWN)
2019             av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2020     }
2021
2022     if (norm == UNKNOWN) {
2023         av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2024         av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2025         av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2026         exit(1);
2027     }
2028
2029     if (!strcmp(arg, "vcd")) {
2030         opt_video_codec(o, "c:v", "mpeg1video");
2031         opt_audio_codec(o, "c:a", "mp2");
2032         parse_option(o, "f", "vcd", options);
2033         av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2034
2035         parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2036         parse_option(o, "r", frame_rates[norm], options);
2037         av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", 0);
2038
2039         av_dict_set(&o->g->codec_opts, "b:v", "1150000", 0);
2040         av_dict_set(&o->g->codec_opts, "maxrate", "1150000", 0);
2041         av_dict_set(&o->g->codec_opts, "minrate", "1150000", 0);
2042         av_dict_set(&o->g->codec_opts, "bufsize", "327680", 0); // 40*1024*8;
2043
2044         av_dict_set(&o->g->codec_opts, "b:a", "224000", 0);
2045         parse_option(o, "ar", "44100", options);
2046         parse_option(o, "ac", "2", options);
2047
2048         av_dict_set(&o->g->format_opts, "packetsize", "2324", 0);
2049         av_dict_set(&o->g->format_opts, "muxrate", "1411200", 0); // 2352 * 75 * 8;
2050
2051         /* We have to offset the PTS, so that it is consistent with the SCR.
2052            SCR starts at 36000, but the first two packs contain only padding
2053            and the first pack from the other stream, respectively, may also have
2054            been written before.
2055            So the real data starts at SCR 36000+3*1200. */
2056         o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2057     } else if (!strcmp(arg, "svcd")) {
2058
2059         opt_video_codec(o, "c:v", "mpeg2video");
2060         opt_audio_codec(o, "c:a", "mp2");
2061         parse_option(o, "f", "svcd", options);
2062
2063         parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2064         parse_option(o, "r", frame_rates[norm], options);
2065         parse_option(o, "pix_fmt", "yuv420p", options);
2066         av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", 0);
2067
2068         av_dict_set(&o->g->codec_opts, "b:v", "2040000", 0);
2069         av_dict_set(&o->g->codec_opts, "maxrate", "2516000", 0);
2070         av_dict_set(&o->g->codec_opts, "minrate", "0", 0); // 1145000;
2071         av_dict_set(&o->g->codec_opts, "bufsize", "1835008", 0); // 224*1024*8;
2072         av_dict_set(&o->g->codec_opts, "scan_offset", "1", 0);
2073
2074         av_dict_set(&o->g->codec_opts, "b:a", "224000", 0);
2075         parse_option(o, "ar", "44100", options);
2076
2077         av_dict_set(&o->g->format_opts, "packetsize", "2324", 0);
2078
2079     } else if (!strcmp(arg, "dvd")) {
2080
2081         opt_video_codec(o, "c:v", "mpeg2video");
2082         opt_audio_codec(o, "c:a", "ac3");
2083         parse_option(o, "f", "dvd", options);
2084
2085         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2086         parse_option(o, "r", frame_rates[norm], options);
2087         parse_option(o, "pix_fmt", "yuv420p", options);
2088         av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", 0);
2089
2090         av_dict_set(&o->g->codec_opts, "b:v", "6000000", 0);
2091         av_dict_set(&o->g->codec_opts, "maxrate", "9000000", 0);
2092         av_dict_set(&o->g->codec_opts, "minrate", "0", 0); // 1500000;
2093         av_dict_set(&o->g->codec_opts, "bufsize", "1835008", 0); // 224*1024*8;
2094
2095         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.
2096         av_dict_set(&o->g->format_opts, "muxrate", "10080000", 0); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2097
2098         av_dict_set(&o->g->codec_opts, "b:a", "448000", 0);
2099         parse_option(o, "ar", "48000", options);
2100
2101     } else if (!strncmp(arg, "dv", 2)) {
2102
2103         parse_option(o, "f", "dv", options);
2104
2105         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2106         parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2107                           norm == PAL ? "yuv420p" : "yuv411p", options);
2108         parse_option(o, "r", frame_rates[norm], options);
2109
2110         parse_option(o, "ar", "48000", options);
2111         parse_option(o, "ac", "2", options);
2112
2113     } else {
2114         av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2115         return AVERROR(EINVAL);
2116     }
2117     return 0;
2118 }
2119
2120 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2121 {
2122     av_free (vstats_filename);
2123     vstats_filename = av_strdup (arg);
2124     return 0;
2125 }
2126
2127 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2128 {
2129     char filename[40];
2130     time_t today2 = time(NULL);
2131     struct tm *today = localtime(&today2);
2132
2133     snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2134              today->tm_sec);
2135     return opt_vstats_file(NULL, opt, filename);
2136 }
2137
2138 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2139 {
2140     OptionsContext *o = optctx;
2141     return parse_option(o, "frames:v", arg, options);
2142 }
2143
2144 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2145 {
2146     OptionsContext *o = optctx;
2147     return parse_option(o, "frames:a", arg, options);
2148 }
2149
2150 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2151 {
2152     OptionsContext *o = optctx;
2153     return parse_option(o, "frames:d", arg, options);
2154 }
2155
2156 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2157 {
2158     int ret;
2159     AVDictionary *cbak = codec_opts;
2160     AVDictionary *fbak = format_opts;
2161     codec_opts = NULL;
2162     format_opts = NULL;
2163
2164     ret = opt_default(NULL, opt, arg);
2165
2166     av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2167     av_dict_copy(&o->g->format_opts, format_opts, 0);
2168     av_dict_free(&codec_opts);
2169     av_dict_free(&format_opts);
2170     codec_opts = cbak;
2171     format_opts = fbak;
2172
2173     return ret;
2174 }
2175
2176 static int opt_preset(void *optctx, const char *opt, const char *arg)
2177 {
2178     OptionsContext *o = optctx;
2179     FILE *f=NULL;
2180     char filename[1000], line[1000], tmp_line[1000];
2181     const char *codec_name = NULL;
2182
2183     tmp_line[0] = *opt;
2184     tmp_line[1] = 0;
2185     MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2186
2187     if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2188         if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2189             av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2190         }else
2191             av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2192         exit(1);
2193     }
2194
2195     while (fgets(line, sizeof(line), f)) {
2196         char *key = tmp_line, *value, *endptr;
2197
2198         if (strcspn(line, "#\n\r") == 0)
2199             continue;
2200         av_strlcpy(tmp_line, line, sizeof(tmp_line));
2201         if (!av_strtok(key,   "=",    &value) ||
2202             !av_strtok(value, "\r\n", &endptr)) {
2203             av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2204             exit(1);
2205         }
2206         av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2207
2208         if      (!strcmp(key, "acodec")) opt_audio_codec   (o, key, value);
2209         else if (!strcmp(key, "vcodec")) opt_video_codec   (o, key, value);
2210         else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2211         else if (!strcmp(key, "dcodec")) opt_data_codec    (o, key, value);
2212         else if (opt_default_new(o, key, value) < 0) {
2213             av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2214                    filename, line, key, value);
2215             exit(1);
2216         }
2217     }
2218
2219     fclose(f);
2220
2221     return 0;
2222 }
2223
2224 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2225 {
2226     OptionsContext *o = optctx;
2227     char *s = av_asprintf("%s:%c", opt + 1, *opt);
2228     int ret = parse_option(o, s, arg, options);
2229     av_free(s);
2230     return ret;
2231 }
2232
2233 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2234 {
2235     OptionsContext *o = optctx;
2236     if(!strcmp(opt, "b")){
2237         av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2238         av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2239         return 0;
2240     }
2241     av_dict_set(&o->g->codec_opts, opt, arg, 0);
2242     return 0;
2243 }
2244
2245 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2246 {
2247     OptionsContext *o = optctx;
2248     char *s;
2249     int ret;
2250     if(!strcmp(opt, "qscale")){
2251         av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2252         return parse_option(o, "q:v", arg, options);
2253     }
2254     s = av_asprintf("q%s", opt + 6);
2255     ret = parse_option(o, s, arg, options);
2256     av_free(s);
2257     return ret;
2258 }
2259
2260 static int opt_profile(void *optctx, const char *opt, const char *arg)
2261 {
2262     OptionsContext *o = optctx;
2263     if(!strcmp(opt, "profile")){
2264         av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2265         av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
2266         return 0;
2267     }
2268     av_dict_set(&o->g->codec_opts, opt, arg, 0);
2269     return 0;
2270 }
2271
2272 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2273 {
2274     OptionsContext *o = optctx;
2275     return parse_option(o, "filter:v", arg, options);
2276 }
2277
2278 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2279 {
2280     OptionsContext *o = optctx;
2281     return parse_option(o, "filter:a", arg, options);
2282 }
2283
2284 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2285 {
2286     if      (!av_strcasecmp(arg, "cfr"))         video_sync_method = VSYNC_CFR;
2287     else if (!av_strcasecmp(arg, "vfr"))         video_sync_method = VSYNC_VFR;
2288     else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2289     else if (!av_strcasecmp(arg, "drop"))        video_sync_method = VSYNC_DROP;
2290
2291     if (video_sync_method == VSYNC_AUTO)
2292         video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
2293     return 0;
2294 }
2295
2296 static int opt_timecode(void *optctx, const char *opt, const char *arg)
2297 {
2298     OptionsContext *o = optctx;
2299     char *tcr = av_asprintf("timecode=%s", arg);
2300     int ret = parse_option(o, "metadata:g", tcr, options);
2301     if (ret >= 0)
2302         ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
2303     av_free(tcr);
2304     return 0;
2305 }
2306
2307 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2308 {
2309     OptionsContext *o = optctx;
2310     char layout_str[32];
2311     char *stream_str;
2312     char *ac_str;
2313     int ret, channels, ac_str_size;
2314     uint64_t layout;
2315
2316     layout = av_get_channel_layout(arg);
2317     if (!layout) {
2318         av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2319         return AVERROR(EINVAL);
2320     }
2321     snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2322     ret = opt_default_new(o, opt, layout_str);
2323     if (ret < 0)
2324         return ret;
2325
2326     /* set 'ac' option based on channel layout */
2327     channels = av_get_channel_layout_nb_channels(layout);
2328     snprintf(layout_str, sizeof(layout_str), "%d", channels);
2329     stream_str = strchr(opt, ':');
2330     ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2331     ac_str = av_mallocz(ac_str_size);
2332     if (!ac_str)
2333         return AVERROR(ENOMEM);
2334     av_strlcpy(ac_str, "ac", 3);
2335     if (stream_str)
2336         av_strlcat(ac_str, stream_str, ac_str_size);
2337     ret = parse_option(o, ac_str, layout_str, options);
2338     av_free(ac_str);
2339
2340     return ret;
2341 }
2342
2343 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2344 {
2345     OptionsContext *o = optctx;
2346     return parse_option(o, "q:a", arg, options);
2347 }
2348
2349 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2350 {
2351     GROW_ARRAY(filtergraphs, nb_filtergraphs);
2352     if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2353         return AVERROR(ENOMEM);
2354     filtergraphs[nb_filtergraphs - 1]->index      = nb_filtergraphs - 1;
2355     filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
2356     if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
2357         return AVERROR(ENOMEM);
2358     return 0;
2359 }
2360
2361 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
2362 {
2363     uint8_t *graph_desc = read_file(arg);
2364     if (!graph_desc)
2365         return AVERROR(EINVAL);
2366
2367     GROW_ARRAY(filtergraphs, nb_filtergraphs);
2368     if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2369         return AVERROR(ENOMEM);
2370     filtergraphs[nb_filtergraphs - 1]->index      = nb_filtergraphs - 1;
2371     filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
2372     return 0;
2373 }
2374
2375 void show_help_default(const char *opt, const char *arg)
2376 {
2377     /* per-file options have at least one of those set */
2378     const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2379     int show_advanced = 0, show_avoptions = 0;
2380
2381     if (opt && *opt) {
2382         if (!strcmp(opt, "long"))
2383             show_advanced = 1;
2384         else if (!strcmp(opt, "full"))
2385             show_advanced = show_avoptions = 1;
2386         else
2387             av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2388     }
2389
2390     show_usage();
2391
2392     printf("Getting help:\n"
2393            "    -h      -- print basic options\n"
2394            "    -h long -- print more options\n"
2395            "    -h full -- print all options (including all format and codec specific options, very long)\n"
2396            "    See man %s for detailed description of the options.\n"
2397            "\n", program_name);
2398
2399     show_help_options(options, "Print help / information / capabilities:",
2400                       OPT_EXIT, 0, 0);
2401
2402     show_help_options(options, "Global options (affect whole program "
2403                       "instead of just one file:",
2404                       0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2405     if (show_advanced)
2406         show_help_options(options, "Advanced global options:", OPT_EXPERT,
2407                           per_file | OPT_EXIT, 0);
2408
2409     show_help_options(options, "Per-file main options:", 0,
2410                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
2411                       OPT_EXIT, per_file);
2412     if (show_advanced)
2413         show_help_options(options, "Advanced per-file options:",
2414                           OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2415
2416     show_help_options(options, "Video options:",
2417                       OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
2418     if (show_advanced)
2419         show_help_options(options, "Advanced Video options:",
2420                           OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2421
2422     show_help_options(options, "Audio options:",
2423                       OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2424     if (show_advanced)
2425         show_help_options(options, "Advanced Audio options:",
2426                           OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2427     show_help_options(options, "Subtitle options:",
2428                       OPT_SUBTITLE, 0, 0);
2429     printf("\n");
2430
2431     if (show_avoptions) {
2432         int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2433         show_help_children(avcodec_get_class(), flags);
2434         show_help_children(avformat_get_class(), flags);
2435         show_help_children(sws_get_class(), flags);
2436         show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
2437         show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM);
2438     }
2439 }
2440
2441 void show_usage(void)
2442 {
2443     av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
2444     av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2445     av_log(NULL, AV_LOG_INFO, "\n");
2446 }
2447
2448 enum OptGroup {
2449     GROUP_OUTFILE,
2450     GROUP_INFILE,
2451 };
2452
2453 static const OptionGroupDef groups[] = {
2454     [GROUP_OUTFILE] = { "output file",  NULL, OPT_OUTPUT },
2455     [GROUP_INFILE]  = { "input file",   "i",  OPT_INPUT },
2456 };
2457
2458 static int open_files(OptionGroupList *l, const char *inout,
2459                       int (*open_file)(OptionsContext*, const char*))
2460 {
2461     int i, ret;
2462
2463     for (i = 0; i < l->nb_groups; i++) {
2464         OptionGroup *g = &l->groups[i];
2465         OptionsContext o;
2466
2467         init_options(&o, !strcmp(inout, "input"));
2468         o.g = g;
2469
2470         ret = parse_optgroup(&o, g);
2471         if (ret < 0) {
2472             av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
2473                    "%s.\n", inout, g->arg);
2474             return ret;
2475         }
2476
2477         av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
2478         ret = open_file(&o, g->arg);
2479         uninit_options(&o, !strcmp(inout, "input"));
2480         if (ret < 0) {
2481             av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
2482                    inout, g->arg);
2483             return ret;
2484         }
2485         av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
2486     }
2487
2488     return 0;
2489 }
2490
2491 int ffmpeg_parse_options(int argc, char **argv)
2492 {
2493     OptionParseContext octx;
2494     uint8_t error[128];
2495     int ret;
2496
2497     memset(&octx, 0, sizeof(octx));
2498
2499     /* split the commandline into an internal representation */
2500     ret = split_commandline(&octx, argc, argv, options, groups,
2501                             FF_ARRAY_ELEMS(groups));
2502     if (ret < 0) {
2503         av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
2504         goto fail;
2505     }
2506
2507     /* apply global options */
2508     ret = parse_optgroup(NULL, &octx.global_opts);
2509     if (ret < 0) {
2510         av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
2511         goto fail;
2512     }
2513
2514     /* open input files */
2515     ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
2516     if (ret < 0) {
2517         av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
2518         goto fail;
2519     }
2520
2521     /* open output files */
2522     ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
2523     if (ret < 0) {
2524         av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
2525         goto fail;
2526     }
2527
2528 fail:
2529     uninit_parse_context(&octx);
2530     if (ret < 0) {
2531         av_strerror(ret, error, sizeof(error));
2532         av_log(NULL, AV_LOG_FATAL, "%s\n", error);
2533     }
2534     return ret;
2535 }
2536
2537 static int opt_progress(void *optctx, const char *opt, const char *arg)
2538 {
2539     AVIOContext *avio = NULL;
2540     int ret;
2541
2542     if (!strcmp(arg, "-"))
2543         arg = "pipe:";
2544     ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
2545     if (ret < 0) {
2546         av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
2547                arg, av_err2str(ret));
2548         return ret;
2549     }
2550     progress_avio = avio;
2551     return 0;
2552 }
2553
2554 #define OFFSET(x) offsetof(OptionsContext, x)
2555 const OptionDef options[] = {
2556     /* main options */
2557 #include "cmdutils_common_opts.h"
2558     { "f",              HAS_ARG | OPT_STRING | OPT_OFFSET |
2559                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(format) },
2560         "force format", "fmt" },
2561     { "y",              OPT_BOOL,                                    {              &file_overwrite },
2562         "overwrite output files" },
2563     { "n",              OPT_BOOL,                                    {              &no_file_overwrite },
2564         "do not overwrite output files" },
2565     { "c",              HAS_ARG | OPT_STRING | OPT_SPEC |
2566                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(codec_names) },
2567         "codec name", "codec" },
2568     { "codec",          HAS_ARG | OPT_STRING | OPT_SPEC |
2569                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(codec_names) },
2570         "codec name", "codec" },
2571     { "pre",            HAS_ARG | OPT_STRING | OPT_SPEC |
2572                         OPT_OUTPUT,                                  { .off       = OFFSET(presets) },
2573         "preset name", "preset" },
2574     { "map",            HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2575                         OPT_OUTPUT,                                  { .func_arg = opt_map },
2576         "set input stream mapping",
2577         "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
2578     { "map_channel",    HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
2579         "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
2580     { "map_metadata",   HAS_ARG | OPT_STRING | OPT_SPEC |
2581                         OPT_OUTPUT,                                  { .off       = OFFSET(metadata_map) },
2582         "set metadata information of outfile from infile",
2583         "outfile[,metadata]:infile[,metadata]" },
2584     { "map_chapters",   HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
2585                         OPT_OUTPUT,                                  { .off = OFFSET(chapters_input_file) },
2586         "set chapters mapping", "input_file_index" },
2587     { "t",              HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
2588         "record or transcode \"duration\" seconds of audio/video",
2589         "duration" },
2590     { "to",             HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_OUTPUT,  { .off = OFFSET(stop_time) },
2591         "record or transcode stop time", "time_stop" },
2592     { "fs",             HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
2593         "set the limit file size in bytes", "limit_size" },
2594     { "ss",             HAS_ARG | OPT_TIME | OPT_OFFSET |
2595                         OPT_INPUT | OPT_OUTPUT,                      { .off = OFFSET(start_time) },
2596         "set the start time offset", "time_off" },
2597     { "itsoffset",      HAS_ARG | OPT_TIME | OPT_OFFSET |
2598                         OPT_EXPERT | OPT_INPUT,                      { .off = OFFSET(input_ts_offset) },
2599         "set the input ts offset", "time_off" },
2600     { "itsscale",       HAS_ARG | OPT_DOUBLE | OPT_SPEC |
2601                         OPT_EXPERT | OPT_INPUT,                      { .off = OFFSET(ts_scale) },
2602         "set the input ts scale", "scale" },
2603     { "timestamp",      HAS_ARG | OPT_PERFILE,                       { .func_arg = opt_recording_timestamp },
2604         "set the recording timestamp ('now' to set the current time)", "time" },
2605     { "metadata",       HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
2606         "add metadata", "string=string" },
2607     { "dframes",        HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2608                         OPT_OUTPUT,                                  { .func_arg = opt_data_frames },
2609         "set the number of data frames to record", "number" },
2610     { "benchmark",      OPT_BOOL | OPT_EXPERT,                       { &do_benchmark },
2611         "add timings for benchmarking" },
2612     { "benchmark_all",  OPT_BOOL | OPT_EXPERT,                       { &do_benchmark_all },
2613       "add timings for each task" },
2614     { "progress",       HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_progress },
2615       "write program-readable progress information", "url" },
2616     { "stdin",          OPT_BOOL | OPT_EXPERT,                       { &stdin_interaction },
2617       "enable or disable interaction on standard input" },
2618     { "timelimit",      HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_timelimit },
2619         "set max runtime in seconds", "limit" },
2620     { "dump",           OPT_BOOL | OPT_EXPERT,                       { &do_pkt_dump },
2621         "dump each input packet" },
2622     { "hex",            OPT_BOOL | OPT_EXPERT,                       { &do_hex_dump },
2623         "when dumping packets, also dump the payload" },
2624     { "re",             OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2625                         OPT_INPUT,                                   { .off = OFFSET(rate_emu) },
2626         "read input at native frame rate", "" },
2627     { "target",         HAS_ARG | OPT_PERFILE | OPT_OUTPUT,          { .func_arg = opt_target },
2628         "specify target file type (\"vcd\", \"svcd\", \"dvd\","
2629         " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2630     { "vsync",          HAS_ARG | OPT_EXPERT,                        { opt_vsync },
2631         "video sync method", "" },
2632     { "async",          HAS_ARG | OPT_INT | OPT_EXPERT,              { &audio_sync_method },
2633         "audio sync method", "" },
2634     { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,          { &audio_drift_threshold },
2635         "audio drift threshold", "threshold" },
2636     { "copyts",         OPT_BOOL | OPT_EXPERT,                       { &copy_ts },
2637         "copy timestamps" },
2638     { "copytb",         HAS_ARG | OPT_INT | OPT_EXPERT,              { &copy_tb },
2639         "copy input stream time base when stream copying", "mode" },
2640     { "shortest",       OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2641                         OPT_OUTPUT,                                  { .off = OFFSET(shortest) },
2642         "finish encoding within shortest input" },
2643     { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,       { &dts_delta_threshold },
2644         "timestamp discontinuity delta threshold", "threshold" },
2645     { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,       { &dts_error_threshold },
2646         "timestamp error delta threshold", "threshold" },
2647     { "xerror",         OPT_BOOL | OPT_EXPERT,                       { &exit_on_error },
2648         "exit on error", "error" },
2649     { "copyinkf",       OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2650                         OPT_OUTPUT,                                  { .off = OFFSET(copy_initial_nonkeyframes) },
2651         "copy initial non-keyframes" },
2652     { "copypriorss",    OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT,   { .off = OFFSET(copy_prior_start) },
2653         "copy or discard frames before start time" },
2654     { "frames",         OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
2655         "set the number of frames to record", "number" },
2656     { "tag",            OPT_STRING | HAS_ARG | OPT_SPEC |
2657                         OPT_EXPERT | OPT_OUTPUT,                     { .off = OFFSET(codec_tags) },
2658         "force codec tag/fourcc", "fourcc/tag" },
2659     { "q",              HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
2660                         OPT_SPEC | OPT_OUTPUT,                       { .off = OFFSET(qscale) },
2661         "use fixed quality scale (VBR)", "q" },
2662     { "qscale",         HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2663                         OPT_OUTPUT,                                  { .func_arg = opt_qscale },
2664         "use fixed quality scale (VBR)", "q" },
2665     { "profile",        HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
2666         "set profile", "profile" },
2667     { "filter",         HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
2668         "set stream filtergraph", "filter_graph" },
2669     { "filter_script",  HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
2670         "read stream filtergraph description from a file", "filename" },
2671     { "reinit_filter",  HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT,    { .off = OFFSET(reinit_filters) },
2672         "reinit filtergraph on input parameter changes", "" },
2673     { "filter_complex", HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_filter_complex },
2674         "create a complex filtergraph", "graph_description" },
2675     { "lavfi",          HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_filter_complex },
2676         "create a complex filtergraph", "graph_description" },
2677     { "filter_complex_script", HAS_ARG | OPT_EXPERT,                 { .func_arg = opt_filter_complex_script },
2678         "read complex filtergraph description from a file", "filename" },
2679     { "stats",          OPT_BOOL,                                    { &print_stats },
2680         "print progress report during encoding", },
2681     { "attach",         HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2682                         OPT_OUTPUT,                                  { .func_arg = opt_attach },
2683         "add an attachment to the output file", "filename" },
2684     { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
2685                          OPT_EXPERT | OPT_INPUT,                     { .off = OFFSET(dump_attachment) },
2686         "extract an attachment into a file", "filename" },
2687     { "debug_ts",       OPT_BOOL | OPT_EXPERT,                       { &debug_ts },
2688         "print timestamp debugging info" },
2689
2690     /* video options */
2691     { "vframes",      OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_video_frames },
2692         "set the number of video frames to record", "number" },
2693     { "r",            OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC |
2694                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_rates) },
2695         "set frame rate (Hz value, fraction or abbreviation)", "rate" },
2696     { "s",            OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC |
2697                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_sizes) },
2698         "set frame size (WxH or abbreviation)", "size" },
2699     { "aspect",       OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC |
2700                       OPT_OUTPUT,                                                { .off = OFFSET(frame_aspect_ratios) },
2701         "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
2702     { "pix_fmt",      OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
2703                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_pix_fmts) },
2704         "set pixel format", "format" },
2705     { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG,                      { &frame_bits_per_raw_sample },
2706         "set the number of bits per raw sample", "number" },
2707     { "intra",        OPT_VIDEO | OPT_BOOL | OPT_EXPERT,                         { &intra_only },
2708         "deprecated use -g 1" },
2709     { "vn",           OPT_VIDEO | OPT_BOOL  | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) },
2710         "disable video" },
2711     { "vdt",          OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT ,               { &video_discard },
2712         "discard threshold", "n" },
2713     { "rc_override",  OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
2714                       OPT_OUTPUT,                                                { .off = OFFSET(rc_overrides) },
2715         "rate control override for specific intervals", "override" },
2716     { "vcodec",       OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_INPUT |
2717                       OPT_OUTPUT,                                                { .func_arg = opt_video_codec },
2718         "force video codec ('copy' to copy stream)", "codec" },
2719     { "sameq",        OPT_VIDEO | OPT_EXPERT ,                                   { .func_arg = opt_sameq },
2720         "Removed" },
2721     { "same_quant",   OPT_VIDEO | OPT_EXPERT ,                                   { .func_arg = opt_sameq },
2722         "Removed" },
2723     { "timecode",     OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT,            { .func_arg = opt_timecode },
2724         "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
2725     { "pass",         OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT,     { .off = OFFSET(pass) },
2726         "select the pass number (1 to 3)", "n" },
2727     { "passlogfile",  OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
2728                       OPT_OUTPUT,                                                { .off = OFFSET(passlogfiles) },
2729         "select two pass log file name prefix", "prefix" },
2730     { "deinterlace",  OPT_VIDEO | OPT_BOOL | OPT_EXPERT,                         { &do_deinterlace },
2731         "this option is deprecated, use the yadif filter instead" },
2732     { "psnr",         OPT_VIDEO | OPT_BOOL | OPT_EXPERT,                         { &do_psnr },
2733         "calculate PSNR of compressed frames" },
2734     { "vstats",       OPT_VIDEO | OPT_EXPERT ,                                   { &opt_vstats },
2735         "dump video coding statistics to file" },
2736     { "vstats_file",  OPT_VIDEO | HAS_ARG | OPT_EXPERT ,                         { opt_vstats_file },
2737         "dump video coding statistics to file", "file" },
2738     { "vf",           OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_video_filters },
2739         "set video filters", "filter_graph" },
2740     { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
2741                       OPT_OUTPUT,                                                { .off = OFFSET(intra_matrices) },
2742         "specify intra matrix coeffs", "matrix" },
2743     { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
2744                       OPT_OUTPUT,                                                { .off = OFFSET(inter_matrices) },
2745         "specify inter matrix coeffs", "matrix" },
2746     { "top",          OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_INT| OPT_SPEC |
2747                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(top_field_first) },
2748         "top=1/bottom=0/auto=-1 field first", "" },
2749     { "dc",           OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT ,               { &intra_dc_precision },
2750         "intra_dc_precision", "precision" },
2751     { "vtag",         OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_PERFILE |
2752                       OPT_OUTPUT,                                                { .func_arg = opt_old2new },
2753         "force video tag/fourcc", "fourcc/tag" },
2754     { "qphist",       OPT_VIDEO | OPT_BOOL | OPT_EXPERT ,                        { &qp_hist },
2755         "show QP histogram" },
2756     { "force_fps",    OPT_VIDEO | OPT_BOOL | OPT_EXPERT  | OPT_SPEC |
2757                       OPT_OUTPUT,                                                { .off = OFFSET(force_fps) },
2758         "force the selected framerate, disable the best supported framerate selection" },
2759     { "streamid",     OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2760                       OPT_OUTPUT,                                                { .func_arg = opt_streamid },
2761         "set the value of an outfile streamid", "streamIndex:value" },
2762     { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2763                           OPT_SPEC | OPT_OUTPUT,                                 { .off = OFFSET(forced_key_frames) },
2764         "force key frames at specified timestamps", "timestamps" },
2765     { "b",            OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT,            { .func_arg = opt_bitrate },
2766         "video bitrate (please use -b:v)", "bitrate" },
2767
2768     /* audio options */
2769     { "aframes",        OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_frames },
2770         "set the number of audio frames to record", "number" },
2771     { "aq",             OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_qscale },
2772         "set audio quality (codec-specific)", "quality", },
2773     { "ar",             OPT_AUDIO | HAS_ARG  | OPT_INT | OPT_SPEC |
2774                         OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(audio_sample_rate) },
2775         "set audio sampling rate (in Hz)", "rate" },
2776     { "ac",             OPT_AUDIO | HAS_ARG  | OPT_INT | OPT_SPEC |
2777                         OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(audio_channels) },
2778         "set number of audio channels", "channels" },
2779     { "an",             OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) },
2780         "disable audio" },
2781     { "acodec",         OPT_AUDIO | HAS_ARG  | OPT_PERFILE |
2782                         OPT_INPUT | OPT_OUTPUT,                                    { .func_arg = opt_audio_codec },
2783         "force audio codec ('copy' to copy stream)", "codec" },
2784     { "atag",           OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_PERFILE |
2785                         OPT_OUTPUT,                                                { .func_arg = opt_old2new },
2786         "force audio tag/fourcc", "fourcc/tag" },
2787     { "vol",            OPT_AUDIO | HAS_ARG  | OPT_INT,                            { &audio_volume },
2788         "change audio volume (256=normal)" , "volume" },
2789     { "sample_fmt",     OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_SPEC |
2790                         OPT_STRING | OPT_INPUT | OPT_OUTPUT,                       { .off = OFFSET(sample_fmts) },
2791         "set sample format", "format" },
2792     { "channel_layout", OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_PERFILE |
2793                         OPT_INPUT | OPT_OUTPUT,                                    { .func_arg = opt_channel_layout },
2794         "set channel layout", "layout" },
2795     { "af",             OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_filters },
2796         "set audio filters", "filter_graph" },
2797     { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
2798       "set the maximum number of channels to try to guess the channel layout" },
2799
2800     /* subtitle options */
2801     { "sn",     OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
2802         "disable subtitle" },
2803     { "scodec", OPT_SUBTITLE | HAS_ARG  | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
2804         "force subtitle codec ('copy' to copy stream)", "codec" },
2805     { "stag",   OPT_SUBTITLE | HAS_ARG  | OPT_EXPERT  | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
2806         , "force subtitle tag/fourcc", "fourcc/tag" },
2807     { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
2808         "fix subtitles duration" },
2809     { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
2810         "set canvas size (WxH or abbreviation)", "size" },
2811
2812     /* grab options */
2813     { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
2814         "deprecated, use -channel", "channel" },
2815     { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
2816         "deprecated, use -standard", "standard" },
2817     { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
2818
2819     /* muxer options */
2820     { "muxdelay",   OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
2821         "set the maximum demux-decode delay", "seconds" },
2822     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
2823         "set the initial demux-decode delay", "seconds" },
2824
2825     { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
2826         "A comma-separated list of bitstream filters", "bitstream_filters" },
2827     { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
2828         "deprecated", "audio bitstream_filters" },
2829     { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
2830         "deprecated", "video bitstream_filters" },
2831
2832     { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT,    { .func_arg = opt_preset },
2833         "set the audio options to the indicated preset", "preset" },
2834     { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT,    { .func_arg = opt_preset },
2835         "set the video options to the indicated preset", "preset" },
2836     { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
2837         "set the subtitle options to the indicated preset", "preset" },
2838     { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT,                { .func_arg = opt_preset },
2839         "set options from indicated preset file", "filename" },
2840     /* data codec support */
2841     { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
2842         "force data codec ('copy' to copy stream)", "codec" },
2843     { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },
2844         "disable data" },
2845
2846     { NULL, },
2847 };