Merge remote-tracking branch 'qatar/master'
[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     ost->last_mux_dts = AV_NOPTS_VALUE;
1093
1094     return ost;
1095 }
1096
1097 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1098 {
1099     int i;
1100     const char *p = str;
1101     for (i = 0;; i++) {
1102         dest[i] = atoi(p);
1103         if (i == 63)
1104             break;
1105         p = strchr(p, ',');
1106         if (!p) {
1107             av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1108             exit(1);
1109         }
1110         p++;
1111     }
1112 }
1113
1114 /* read file contents into a string */
1115 static uint8_t *read_file(const char *filename)
1116 {
1117     AVIOContext *pb      = NULL;
1118     AVIOContext *dyn_buf = NULL;
1119     int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1120     uint8_t buf[1024], *str;
1121
1122     if (ret < 0) {
1123         av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1124         return NULL;
1125     }
1126
1127     ret = avio_open_dyn_buf(&dyn_buf);
1128     if (ret < 0) {
1129         avio_closep(&pb);
1130         return NULL;
1131     }
1132     while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1133         avio_write(dyn_buf, buf, ret);
1134     avio_w8(dyn_buf, 0);
1135     avio_closep(&pb);
1136
1137     ret = avio_close_dyn_buf(dyn_buf, &str);
1138     if (ret < 0)
1139         return NULL;
1140     return str;
1141 }
1142
1143 static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
1144                              OutputStream *ost)
1145 {
1146     AVStream *st = ost->st;
1147     char *filter = NULL, *filter_script = NULL;
1148
1149     MATCH_PER_STREAM_OPT(filter_scripts, str, filter_script, oc, st);
1150     MATCH_PER_STREAM_OPT(filters, str, filter, oc, st);
1151
1152     if (filter_script && filter) {
1153         av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1154                "output stream #%d:%d.\n", nb_output_files, st->index);
1155         exit(1);
1156     }
1157
1158     if (filter_script)
1159         return read_file(filter_script);
1160     else if (filter)
1161         return av_strdup(filter);
1162
1163     return av_strdup(st->codec->codec_type == AVMEDIA_TYPE_VIDEO ?
1164                      "null" : "anull");
1165 }
1166
1167 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1168 {
1169     AVStream *st;
1170     OutputStream *ost;
1171     AVCodecContext *video_enc;
1172     char *frame_rate = NULL, *frame_aspect_ratio = NULL;
1173
1174     ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1175     st  = ost->st;
1176     video_enc = st->codec;
1177
1178     MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1179     if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1180         av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1181         exit(1);
1182     }
1183
1184     MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1185     if (frame_aspect_ratio) {
1186         AVRational q;
1187         if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1188             q.num <= 0 || q.den <= 0) {
1189             av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1190             exit(1);
1191         }
1192         ost->frame_aspect_ratio = q;
1193     }
1194
1195     if (!ost->stream_copy) {
1196         const char *p = NULL;
1197         char *frame_size = NULL;
1198         char *frame_pix_fmt = NULL;
1199         char *intra_matrix = NULL, *inter_matrix = NULL;
1200         int do_pass = 0;
1201         int i;
1202
1203         MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1204         if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1205             av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1206             exit(1);
1207         }
1208
1209         video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1210         MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1211         if (frame_pix_fmt && *frame_pix_fmt == '+') {
1212             ost->keep_pix_fmt = 1;
1213             if (!*++frame_pix_fmt)
1214                 frame_pix_fmt = NULL;
1215         }
1216         if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1217             av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1218             exit(1);
1219         }
1220         st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1221
1222         if (intra_only)
1223             video_enc->gop_size = 0;
1224         MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1225         if (intra_matrix) {
1226             if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1227                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1228                 exit(1);
1229             }
1230             parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1231         }
1232         MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1233         if (inter_matrix) {
1234             if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1235                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1236                 exit(1);
1237             }
1238             parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1239         }
1240
1241         MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1242         for (i = 0; p; i++) {
1243             int start, end, q;
1244             int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1245             if (e != 3) {
1246                 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1247                 exit(1);
1248             }
1249             /* FIXME realloc failure */
1250             video_enc->rc_override =
1251                 av_realloc(video_enc->rc_override,
1252                            sizeof(RcOverride) * (i + 1));
1253             video_enc->rc_override[i].start_frame = start;
1254             video_enc->rc_override[i].end_frame   = end;
1255             if (q > 0) {
1256                 video_enc->rc_override[i].qscale         = q;
1257                 video_enc->rc_override[i].quality_factor = 1.0;
1258             }
1259             else {
1260                 video_enc->rc_override[i].qscale         = 0;
1261                 video_enc->rc_override[i].quality_factor = -q/100.0;
1262             }
1263             p = strchr(p, '/');
1264             if (p) p++;
1265         }
1266         video_enc->rc_override_count = i;
1267         video_enc->intra_dc_precision = intra_dc_precision - 8;
1268
1269         if (do_psnr)
1270             video_enc->flags|= CODEC_FLAG_PSNR;
1271
1272         /* two pass mode */
1273         MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1274         if (do_pass) {
1275             if (do_pass & 1) {
1276                 video_enc->flags |= CODEC_FLAG_PASS1;
1277                 av_dict_set(&ost->opts, "flags", "+pass1", AV_DICT_APPEND);
1278             }
1279             if (do_pass & 2) {
1280                 video_enc->flags |= CODEC_FLAG_PASS2;
1281                 av_dict_set(&ost->opts, "flags", "+pass2", AV_DICT_APPEND);
1282             }
1283         }
1284
1285         MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1286         if (ost->logfile_prefix &&
1287             !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1288             exit(1);
1289
1290         MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1291         if (ost->forced_keyframes)
1292             ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1293
1294         MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1295
1296         ost->top_field_first = -1;
1297         MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1298
1299
1300         ost->avfilter = get_ost_filters(o, oc, ost);
1301         if (!ost->avfilter)
1302             exit(1);
1303     } else {
1304         MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1305     }
1306
1307     return ost;
1308 }
1309
1310 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1311 {
1312     int n;
1313     AVStream *st;
1314     OutputStream *ost;
1315     AVCodecContext *audio_enc;
1316
1317     ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1318     st  = ost->st;
1319
1320     audio_enc = st->codec;
1321     audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1322
1323     if (!ost->stream_copy) {
1324         char *sample_fmt = NULL;
1325
1326         MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1327
1328         MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1329         if (sample_fmt &&
1330             (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1331             av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1332             exit(1);
1333         }
1334
1335         MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1336
1337         ost->avfilter = get_ost_filters(o, oc, ost);
1338         if (!ost->avfilter)
1339             exit(1);
1340
1341         /* check for channel mapping for this audio stream */
1342         for (n = 0; n < o->nb_audio_channel_maps; n++) {
1343             AudioChannelMap *map = &o->audio_channel_maps[n];
1344             InputStream *ist = input_streams[ost->source_index];
1345             if ((map->channel_idx == -1 || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) &&
1346                 (map->ofile_idx   == -1 || ost->file_index == map->ofile_idx) &&
1347                 (map->ostream_idx == -1 || ost->st->index  == map->ostream_idx)) {
1348                 if (ost->audio_channels_mapped < FF_ARRAY_ELEMS(ost->audio_channels_map))
1349                     ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1350                 else
1351                     av_log(NULL, AV_LOG_FATAL, "Max channel mapping for output %d.%d reached\n",
1352                            ost->file_index, ost->st->index);
1353             }
1354         }
1355     }
1356
1357     return ost;
1358 }
1359
1360 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1361 {
1362     OutputStream *ost;
1363
1364     ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1365     if (!ost->stream_copy) {
1366         av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1367         exit(1);
1368     }
1369
1370     return ost;
1371 }
1372
1373 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1374 {
1375     OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1376     ost->stream_copy = 1;
1377     ost->finished    = 1;
1378     return ost;
1379 }
1380
1381 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1382 {
1383     AVStream *st;
1384     OutputStream *ost;
1385     AVCodecContext *subtitle_enc;
1386
1387     ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1388     st  = ost->st;
1389     subtitle_enc = st->codec;
1390
1391     subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1392
1393     MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1394
1395     if (!ost->stream_copy) {
1396         char *frame_size = NULL;
1397
1398         MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1399         if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1400             av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1401             exit(1);
1402         }
1403     }
1404
1405     return ost;
1406 }
1407
1408 /* arg format is "output-stream-index:streamid-value". */
1409 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1410 {
1411     OptionsContext *o = optctx;
1412     int idx;
1413     char *p;
1414     char idx_str[16];
1415
1416     av_strlcpy(idx_str, arg, sizeof(idx_str));
1417     p = strchr(idx_str, ':');
1418     if (!p) {
1419         av_log(NULL, AV_LOG_FATAL,
1420                "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1421                arg, opt);
1422         exit(1);
1423     }
1424     *p++ = '\0';
1425     idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1426     o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1427     o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1428     return 0;
1429 }
1430
1431 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1432 {
1433     AVFormatContext *is = ifile->ctx;
1434     AVFormatContext *os = ofile->ctx;
1435     AVChapter **tmp;
1436     int i;
1437
1438     tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1439     if (!tmp)
1440         return AVERROR(ENOMEM);
1441     os->chapters = tmp;
1442
1443     for (i = 0; i < is->nb_chapters; i++) {
1444         AVChapter *in_ch = is->chapters[i], *out_ch;
1445         int64_t ts_off   = av_rescale_q(ofile->start_time - ifile->ts_offset,
1446                                        AV_TIME_BASE_Q, in_ch->time_base);
1447         int64_t rt       = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1448                            av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1449
1450
1451         if (in_ch->end < ts_off)
1452             continue;
1453         if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1454             break;
1455
1456         out_ch = av_mallocz(sizeof(AVChapter));
1457         if (!out_ch)
1458             return AVERROR(ENOMEM);
1459
1460         out_ch->id        = in_ch->id;
1461         out_ch->time_base = in_ch->time_base;
1462         out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
1463         out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
1464
1465         if (copy_metadata)
1466             av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1467
1468         os->chapters[os->nb_chapters++] = out_ch;
1469     }
1470     return 0;
1471 }
1472
1473 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
1474 {
1475     int i, err;
1476     AVFormatContext *ic = avformat_alloc_context();
1477
1478     ic->interrupt_callback = int_cb;
1479     err = avformat_open_input(&ic, filename, NULL, NULL);
1480     if (err < 0)
1481         return err;
1482     /* copy stream format */
1483     for(i=0;i<ic->nb_streams;i++) {
1484         AVStream *st;
1485         OutputStream *ost;
1486         AVCodec *codec;
1487         AVCodecContext *avctx;
1488
1489         codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
1490         ost   = new_output_stream(o, s, codec->type, -1);
1491         st    = ost->st;
1492         avctx = st->codec;
1493         ost->enc = codec;
1494
1495         // FIXME: a more elegant solution is needed
1496         memcpy(st, ic->streams[i], sizeof(AVStream));
1497         st->cur_dts = 0;
1498         st->info = av_malloc(sizeof(*st->info));
1499         memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
1500         st->codec= avctx;
1501         avcodec_copy_context(st->codec, ic->streams[i]->codec);
1502
1503         if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
1504             choose_sample_fmt(st, codec);
1505         else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
1506             choose_pixel_fmt(st, codec, st->codec->pix_fmt);
1507     }
1508
1509     /* ffserver seeking with date=... needs a date reference */
1510     err = parse_option(o, "metadata", "creation_time=now", options);
1511
1512     avformat_close_input(&ic);
1513     return err;
1514 }
1515
1516 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1517                                AVFormatContext *oc)
1518 {
1519     OutputStream *ost;
1520
1521     switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1522                                   ofilter->out_tmp->pad_idx)) {
1523     case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
1524     case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
1525     default:
1526         av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1527                "currently.\n");
1528         exit(1);
1529     }
1530
1531     ost->source_index = -1;
1532     ost->filter       = ofilter;
1533
1534     ofilter->ost      = ost;
1535
1536     if (ost->stream_copy) {
1537         av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1538                "which is fed from a complex filtergraph. Filtering and streamcopy "
1539                "cannot be used together.\n", ost->file_index, ost->index);
1540         exit(1);
1541     }
1542
1543     if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
1544         av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
1545         exit(1);
1546     }
1547     avfilter_inout_free(&ofilter->out_tmp);
1548 }
1549
1550 static int configure_complex_filters(void)
1551 {
1552     int i, ret = 0;
1553
1554     for (i = 0; i < nb_filtergraphs; i++)
1555         if (!filtergraphs[i]->graph &&
1556             (ret = configure_filtergraph(filtergraphs[i])) < 0)
1557             return ret;
1558     return 0;
1559 }
1560
1561 static int open_output_file(OptionsContext *o, const char *filename)
1562 {
1563     AVFormatContext *oc;
1564     int i, j, err;
1565     AVOutputFormat *file_oformat;
1566     OutputFile *of;
1567     OutputStream *ost;
1568     InputStream  *ist;
1569     AVDictionary *unused_opts = NULL;
1570     AVDictionaryEntry *e = NULL;
1571
1572     if (configure_complex_filters() < 0) {
1573         av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
1574         exit(1);
1575     }
1576
1577     if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
1578         o->stop_time = INT64_MAX;
1579         av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
1580     }
1581
1582     if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
1583         if (o->stop_time <= o->start_time) {
1584             av_log(NULL, AV_LOG_WARNING, "-to value smaller than -ss; ignoring -to.\n");
1585             o->stop_time = INT64_MAX;
1586         } else {
1587             o->recording_time = o->stop_time - o->start_time;
1588         }
1589     }
1590
1591     GROW_ARRAY(output_files, nb_output_files);
1592     of = av_mallocz(sizeof(*of));
1593     if (!of)
1594         exit(1);
1595     output_files[nb_output_files - 1] = of;
1596
1597     of->ost_index      = nb_output_streams;
1598     of->recording_time = o->recording_time;
1599     of->start_time     = o->start_time;
1600     of->limit_filesize = o->limit_filesize;
1601     of->shortest       = o->shortest;
1602     av_dict_copy(&of->opts, o->g->format_opts, 0);
1603
1604     if (!strcmp(filename, "-"))
1605         filename = "pipe:";
1606
1607     err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
1608     if (!oc) {
1609         print_error(filename, err);
1610         exit(1);
1611     }
1612
1613     of->ctx = oc;
1614     if (o->recording_time != INT64_MAX)
1615         oc->duration = o->recording_time;
1616
1617     file_oformat= oc->oformat;
1618     oc->interrupt_callback = int_cb;
1619
1620     /* create streams for all unlabeled output pads */
1621     for (i = 0; i < nb_filtergraphs; i++) {
1622         FilterGraph *fg = filtergraphs[i];
1623         for (j = 0; j < fg->nb_outputs; j++) {
1624             OutputFilter *ofilter = fg->outputs[j];
1625
1626             if (!ofilter->out_tmp || ofilter->out_tmp->name)
1627                 continue;
1628
1629             switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1630                                           ofilter->out_tmp->pad_idx)) {
1631             case AVMEDIA_TYPE_VIDEO:    o->video_disable    = 1; break;
1632             case AVMEDIA_TYPE_AUDIO:    o->audio_disable    = 1; break;
1633             case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1634             }
1635             init_output_filter(ofilter, o, oc);
1636         }
1637     }
1638
1639     if (!strcmp(file_oformat->name, "ffm") &&
1640         av_strstart(filename, "http:", NULL)) {
1641         int j;
1642         /* special case for files sent to ffserver: we get the stream
1643            parameters from ffserver */
1644         int err = read_ffserver_streams(o, oc, filename);
1645         if (err < 0) {
1646             print_error(filename, err);
1647             exit(1);
1648         }
1649         for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
1650             ost = output_streams[j];
1651             for (i = 0; i < nb_input_streams; i++) {
1652                 ist = input_streams[i];
1653                 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
1654                     ost->sync_ist= ist;
1655                     ost->source_index= i;
1656                     if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
1657                     if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
1658                     ist->discard = 0;
1659                     ist->st->discard = AVDISCARD_NONE;
1660                     break;
1661                 }
1662             }
1663             if(!ost->sync_ist){
1664                 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));
1665                 exit(1);
1666             }
1667         }
1668     } else if (!o->nb_stream_maps) {
1669         char *subtitle_codec_name = NULL;
1670         /* pick the "best" stream of each type */
1671
1672         /* video: highest resolution */
1673         if (!o->video_disable && oc->oformat->video_codec != AV_CODEC_ID_NONE) {
1674             int area = 0, idx = -1;
1675             int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
1676             for (i = 0; i < nb_input_streams; i++) {
1677                 int new_area;
1678                 ist = input_streams[i];
1679                 new_area = ist->st->codec->width * ist->st->codec->height;
1680                 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1681                     new_area = 1;
1682                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1683                     new_area > area) {
1684                     if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1685                         continue;
1686                     area = new_area;
1687                     idx = i;
1688                 }
1689             }
1690             if (idx >= 0)
1691                 new_video_stream(o, oc, idx);
1692         }
1693
1694         /* audio: most channels */
1695         if (!o->audio_disable && oc->oformat->audio_codec != AV_CODEC_ID_NONE) {
1696             int channels = 0, idx = -1;
1697             for (i = 0; i < nb_input_streams; i++) {
1698                 ist = input_streams[i];
1699                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1700                     ist->st->codec->channels > channels) {
1701                     channels = ist->st->codec->channels;
1702                     idx = i;
1703                 }
1704             }
1705             if (idx >= 0)
1706                 new_audio_stream(o, oc, idx);
1707         }
1708
1709         /* subtitles: pick first */
1710         MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
1711         if (!o->subtitle_disable && (oc->oformat->subtitle_codec != AV_CODEC_ID_NONE || subtitle_codec_name)) {
1712             for (i = 0; i < nb_input_streams; i++)
1713                 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1714                     new_subtitle_stream(o, oc, i);
1715                     break;
1716                 }
1717         }
1718         /* do something with data? */
1719     } else {
1720         for (i = 0; i < o->nb_stream_maps; i++) {
1721             StreamMap *map = &o->stream_maps[i];
1722             int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
1723
1724             if (map->disabled)
1725                 continue;
1726
1727             if (map->linklabel) {
1728                 FilterGraph *fg;
1729                 OutputFilter *ofilter = NULL;
1730                 int j, k;
1731
1732                 for (j = 0; j < nb_filtergraphs; j++) {
1733                     fg = filtergraphs[j];
1734                     for (k = 0; k < fg->nb_outputs; k++) {
1735                         AVFilterInOut *out = fg->outputs[k]->out_tmp;
1736                         if (out && !strcmp(out->name, map->linklabel)) {
1737                             ofilter = fg->outputs[k];
1738                             goto loop_end;
1739                         }
1740                     }
1741                 }
1742 loop_end:
1743                 if (!ofilter) {
1744                     av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1745                            "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
1746                     exit(1);
1747                 }
1748                 init_output_filter(ofilter, o, oc);
1749             } else {
1750                 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
1751                 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
1752                     continue;
1753                 if(o->   audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1754                     continue;
1755                 if(o->   video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
1756                     continue;
1757                 if(o->    data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
1758                     continue;
1759
1760                 switch (ist->st->codec->codec_type) {
1761                 case AVMEDIA_TYPE_VIDEO:      ost = new_video_stream     (o, oc, src_idx); break;
1762                 case AVMEDIA_TYPE_AUDIO:      ost = new_audio_stream     (o, oc, src_idx); break;
1763                 case AVMEDIA_TYPE_SUBTITLE:   ost = new_subtitle_stream  (o, oc, src_idx); break;
1764                 case AVMEDIA_TYPE_DATA:       ost = new_data_stream      (o, oc, src_idx); break;
1765                 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
1766                 default:
1767                     av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
1768                            map->file_index, map->stream_index);
1769                     exit(1);
1770                 }
1771             }
1772         }
1773     }
1774
1775     /* handle attached files */
1776     for (i = 0; i < o->nb_attachments; i++) {
1777         AVIOContext *pb;
1778         uint8_t *attachment;
1779         const char *p;
1780         int64_t len;
1781
1782         if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
1783             av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
1784                    o->attachments[i]);
1785             exit(1);
1786         }
1787         if ((len = avio_size(pb)) <= 0) {
1788             av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
1789                    o->attachments[i]);
1790             exit(1);
1791         }
1792         if (!(attachment = av_malloc(len))) {
1793             av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
1794                    o->attachments[i]);
1795             exit(1);
1796         }
1797         avio_read(pb, attachment, len);
1798
1799         ost = new_attachment_stream(o, oc, -1);
1800         ost->stream_copy               = 0;
1801         ost->attachment_filename       = o->attachments[i];
1802         ost->finished                  = 1;
1803         ost->st->codec->extradata      = attachment;
1804         ost->st->codec->extradata_size = len;
1805
1806         p = strrchr(o->attachments[i], '/');
1807         av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
1808         avio_close(pb);
1809     }
1810
1811     for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
1812         AVDictionaryEntry *e;
1813         ost = output_streams[i];
1814
1815         if ((ost->stream_copy || ost->attachment_filename)
1816             && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
1817             && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
1818             if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
1819                 exit(1);
1820     }
1821
1822     /* check if all codec options have been used */
1823     unused_opts = strip_specifiers(o->g->codec_opts);
1824     for (i = of->ost_index; i < nb_output_streams; i++) {
1825         e = NULL;
1826         while ((e = av_dict_get(output_streams[i]->opts, "", e,
1827                                 AV_DICT_IGNORE_SUFFIX)))
1828             av_dict_set(&unused_opts, e->key, NULL, 0);
1829     }
1830
1831     e = NULL;
1832     while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
1833         const AVClass *class = avcodec_get_class();
1834         const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
1835                                              AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1836         if (!option)
1837             continue;
1838         if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
1839             av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
1840                    "output file #%d (%s) is not an encoding option.\n", e->key,
1841                    option->help ? option->help : "", nb_output_files - 1,
1842                    filename);
1843             exit(1);
1844         }
1845
1846         av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
1847                "output file #%d (%s) has not been used for any stream. The most "
1848                "likely reason is either wrong type (e.g. a video option with "
1849                "no video streams) or that it is a private option of some encoder "
1850                "which was not actually used for any stream.\n", e->key,
1851                option->help ? option->help : "", nb_output_files - 1, filename);
1852     }
1853     av_dict_free(&unused_opts);
1854
1855     /* check filename in case of an image number is expected */
1856     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
1857         if (!av_filename_number_test(oc->filename)) {
1858             print_error(oc->filename, AVERROR(EINVAL));
1859             exit(1);
1860         }
1861     }
1862
1863     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
1864         /* test if it already exists to avoid losing precious files */
1865         assert_file_overwrite(filename);
1866
1867         /* open the file */
1868         if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
1869                               &oc->interrupt_callback,
1870                               &of->opts)) < 0) {
1871             print_error(filename, err);
1872             exit(1);
1873         }
1874     } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
1875         assert_file_overwrite(filename);
1876
1877     if (o->mux_preload) {
1878         uint8_t buf[64];
1879         snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
1880         av_dict_set(&of->opts, "preload", buf, 0);
1881     }
1882     oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
1883
1884     /* copy metadata */
1885     for (i = 0; i < o->nb_metadata_map; i++) {
1886         char *p;
1887         int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
1888
1889         if (in_file_index >= nb_input_files) {
1890             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
1891             exit(1);
1892         }
1893         copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
1894                       in_file_index >= 0 ?
1895                       input_files[in_file_index]->ctx : NULL, o);
1896     }
1897
1898     /* copy chapters */
1899     if (o->chapters_input_file >= nb_input_files) {
1900         if (o->chapters_input_file == INT_MAX) {
1901             /* copy chapters from the first input file that has them*/
1902             o->chapters_input_file = -1;
1903             for (i = 0; i < nb_input_files; i++)
1904                 if (input_files[i]->ctx->nb_chapters) {
1905                     o->chapters_input_file = i;
1906                     break;
1907                 }
1908         } else {
1909             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
1910                    o->chapters_input_file);
1911             exit(1);
1912         }
1913     }
1914     if (o->chapters_input_file >= 0)
1915         copy_chapters(input_files[o->chapters_input_file], of,
1916                       !o->metadata_chapters_manual);
1917
1918     /* copy global metadata by default */
1919     if (!o->metadata_global_manual && nb_input_files){
1920         av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
1921                      AV_DICT_DONT_OVERWRITE);
1922         if(o->recording_time != INT64_MAX)
1923             av_dict_set(&oc->metadata, "duration", NULL, 0);
1924         av_dict_set(&oc->metadata, "creation_time", NULL, 0);
1925     }
1926     if (!o->metadata_streams_manual)
1927         for (i = of->ost_index; i < nb_output_streams; i++) {
1928             InputStream *ist;
1929             if (output_streams[i]->source_index < 0)         /* this is true e.g. for attached files */
1930                 continue;
1931             ist = input_streams[output_streams[i]->source_index];
1932             av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
1933         }
1934
1935     /* process manually set metadata */
1936     for (i = 0; i < o->nb_metadata; i++) {
1937         AVDictionary **m;
1938         char type, *val;
1939         const char *stream_spec;
1940         int index = 0, j, ret = 0;
1941
1942         val = strchr(o->metadata[i].u.str, '=');
1943         if (!val) {
1944             av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
1945                    o->metadata[i].u.str);
1946             exit(1);
1947         }
1948         *val++ = 0;
1949
1950         parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
1951         if (type == 's') {
1952             for (j = 0; j < oc->nb_streams; j++) {
1953                 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
1954                     av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
1955                 } else if (ret < 0)
1956                     exit(1);
1957             }
1958         }
1959         else {
1960             switch (type) {
1961             case 'g':
1962                 m = &oc->metadata;
1963                 break;
1964             case 'c':
1965                 if (index < 0 || index >= oc->nb_chapters) {
1966                     av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
1967                     exit(1);
1968                 }
1969                 m = &oc->chapters[index]->metadata;
1970                 break;
1971             default:
1972                 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
1973                 exit(1);
1974             }
1975             av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
1976         }
1977     }
1978
1979     return 0;
1980 }
1981
1982 static int opt_target(void *optctx, const char *opt, const char *arg)
1983 {
1984     OptionsContext *o = optctx;
1985     enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
1986     static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
1987
1988     if (!strncmp(arg, "pal-", 4)) {
1989         norm = PAL;
1990         arg += 4;
1991     } else if (!strncmp(arg, "ntsc-", 5)) {
1992         norm = NTSC;
1993         arg += 5;
1994     } else if (!strncmp(arg, "film-", 5)) {
1995         norm = FILM;
1996         arg += 5;
1997     } else {
1998         /* Try to determine PAL/NTSC by peeking in the input files */
1999         if (nb_input_files) {
2000             int i, j, fr;
2001             for (j = 0; j < nb_input_files; j++) {
2002                 for (i = 0; i < input_files[j]->nb_streams; i++) {
2003                     AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
2004                     if (c->codec_type != AVMEDIA_TYPE_VIDEO)
2005                         continue;
2006                     fr = c->time_base.den * 1000 / c->time_base.num;
2007                     if (fr == 25000) {
2008                         norm = PAL;
2009                         break;
2010                     } else if ((fr == 29970) || (fr == 23976)) {
2011                         norm = NTSC;
2012                         break;
2013                     }
2014                 }
2015                 if (norm != UNKNOWN)
2016                     break;
2017             }
2018         }
2019         if (norm != UNKNOWN)
2020             av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2021     }
2022
2023     if (norm == UNKNOWN) {
2024         av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2025         av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2026         av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2027         exit(1);
2028     }
2029
2030     if (!strcmp(arg, "vcd")) {
2031         opt_video_codec(o, "c:v", "mpeg1video");
2032         opt_audio_codec(o, "c:a", "mp2");
2033         parse_option(o, "f", "vcd", options);
2034         av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2035
2036         parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2037         parse_option(o, "r", frame_rates[norm], options);
2038         av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", 0);
2039
2040         av_dict_set(&o->g->codec_opts, "b:v", "1150000", 0);
2041         av_dict_set(&o->g->codec_opts, "maxrate", "1150000", 0);
2042         av_dict_set(&o->g->codec_opts, "minrate", "1150000", 0);
2043         av_dict_set(&o->g->codec_opts, "bufsize", "327680", 0); // 40*1024*8;
2044
2045         av_dict_set(&o->g->codec_opts, "b:a", "224000", 0);
2046         parse_option(o, "ar", "44100", options);
2047         parse_option(o, "ac", "2", options);
2048
2049         av_dict_set(&o->g->format_opts, "packetsize", "2324", 0);
2050         av_dict_set(&o->g->format_opts, "muxrate", "1411200", 0); // 2352 * 75 * 8;
2051
2052         /* We have to offset the PTS, so that it is consistent with the SCR.
2053            SCR starts at 36000, but the first two packs contain only padding
2054            and the first pack from the other stream, respectively, may also have
2055            been written before.
2056            So the real data starts at SCR 36000+3*1200. */
2057         o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2058     } else if (!strcmp(arg, "svcd")) {
2059
2060         opt_video_codec(o, "c:v", "mpeg2video");
2061         opt_audio_codec(o, "c:a", "mp2");
2062         parse_option(o, "f", "svcd", options);
2063
2064         parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2065         parse_option(o, "r", frame_rates[norm], options);
2066         parse_option(o, "pix_fmt", "yuv420p", options);
2067         av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", 0);
2068
2069         av_dict_set(&o->g->codec_opts, "b:v", "2040000", 0);
2070         av_dict_set(&o->g->codec_opts, "maxrate", "2516000", 0);
2071         av_dict_set(&o->g->codec_opts, "minrate", "0", 0); // 1145000;
2072         av_dict_set(&o->g->codec_opts, "bufsize", "1835008", 0); // 224*1024*8;
2073         av_dict_set(&o->g->codec_opts, "scan_offset", "1", 0);
2074
2075         av_dict_set(&o->g->codec_opts, "b:a", "224000", 0);
2076         parse_option(o, "ar", "44100", options);
2077
2078         av_dict_set(&o->g->format_opts, "packetsize", "2324", 0);
2079
2080     } else if (!strcmp(arg, "dvd")) {
2081
2082         opt_video_codec(o, "c:v", "mpeg2video");
2083         opt_audio_codec(o, "c:a", "ac3");
2084         parse_option(o, "f", "dvd", options);
2085
2086         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2087         parse_option(o, "r", frame_rates[norm], options);
2088         parse_option(o, "pix_fmt", "yuv420p", options);
2089         av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", 0);
2090
2091         av_dict_set(&o->g->codec_opts, "b:v", "6000000", 0);
2092         av_dict_set(&o->g->codec_opts, "maxrate", "9000000", 0);
2093         av_dict_set(&o->g->codec_opts, "minrate", "0", 0); // 1500000;
2094         av_dict_set(&o->g->codec_opts, "bufsize", "1835008", 0); // 224*1024*8;
2095
2096         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.
2097         av_dict_set(&o->g->format_opts, "muxrate", "10080000", 0); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2098
2099         av_dict_set(&o->g->codec_opts, "b:a", "448000", 0);
2100         parse_option(o, "ar", "48000", options);
2101
2102     } else if (!strncmp(arg, "dv", 2)) {
2103
2104         parse_option(o, "f", "dv", options);
2105
2106         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2107         parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2108                           norm == PAL ? "yuv420p" : "yuv411p", options);
2109         parse_option(o, "r", frame_rates[norm], options);
2110
2111         parse_option(o, "ar", "48000", options);
2112         parse_option(o, "ac", "2", options);
2113
2114     } else {
2115         av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2116         return AVERROR(EINVAL);
2117     }
2118     return 0;
2119 }
2120
2121 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2122 {
2123     av_free (vstats_filename);
2124     vstats_filename = av_strdup (arg);
2125     return 0;
2126 }
2127
2128 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2129 {
2130     char filename[40];
2131     time_t today2 = time(NULL);
2132     struct tm *today = localtime(&today2);
2133
2134     snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2135              today->tm_sec);
2136     return opt_vstats_file(NULL, opt, filename);
2137 }
2138
2139 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2140 {
2141     OptionsContext *o = optctx;
2142     return parse_option(o, "frames:v", arg, options);
2143 }
2144
2145 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2146 {
2147     OptionsContext *o = optctx;
2148     return parse_option(o, "frames:a", arg, options);
2149 }
2150
2151 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2152 {
2153     OptionsContext *o = optctx;
2154     return parse_option(o, "frames:d", arg, options);
2155 }
2156
2157 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2158 {
2159     int ret;
2160     AVDictionary *cbak = codec_opts;
2161     AVDictionary *fbak = format_opts;
2162     codec_opts = NULL;
2163     format_opts = NULL;
2164
2165     ret = opt_default(NULL, opt, arg);
2166
2167     av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2168     av_dict_copy(&o->g->format_opts, format_opts, 0);
2169     av_dict_free(&codec_opts);
2170     av_dict_free(&format_opts);
2171     codec_opts = cbak;
2172     format_opts = fbak;
2173
2174     return ret;
2175 }
2176
2177 static int opt_preset(void *optctx, const char *opt, const char *arg)
2178 {
2179     OptionsContext *o = optctx;
2180     FILE *f=NULL;
2181     char filename[1000], line[1000], tmp_line[1000];
2182     const char *codec_name = NULL;
2183
2184     tmp_line[0] = *opt;
2185     tmp_line[1] = 0;
2186     MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2187
2188     if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2189         if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2190             av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2191         }else
2192             av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2193         exit(1);
2194     }
2195
2196     while (fgets(line, sizeof(line), f)) {
2197         char *key = tmp_line, *value, *endptr;
2198
2199         if (strcspn(line, "#\n\r") == 0)
2200             continue;
2201         av_strlcpy(tmp_line, line, sizeof(tmp_line));
2202         if (!av_strtok(key,   "=",    &value) ||
2203             !av_strtok(value, "\r\n", &endptr)) {
2204             av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2205             exit(1);
2206         }
2207         av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2208
2209         if      (!strcmp(key, "acodec")) opt_audio_codec   (o, key, value);
2210         else if (!strcmp(key, "vcodec")) opt_video_codec   (o, key, value);
2211         else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2212         else if (!strcmp(key, "dcodec")) opt_data_codec    (o, key, value);
2213         else if (opt_default_new(o, key, value) < 0) {
2214             av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2215                    filename, line, key, value);
2216             exit(1);
2217         }
2218     }
2219
2220     fclose(f);
2221
2222     return 0;
2223 }
2224
2225 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2226 {
2227     OptionsContext *o = optctx;
2228     char *s = av_asprintf("%s:%c", opt + 1, *opt);
2229     int ret = parse_option(o, s, arg, options);
2230     av_free(s);
2231     return ret;
2232 }
2233
2234 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2235 {
2236     OptionsContext *o = optctx;
2237     if(!strcmp(opt, "b")){
2238         av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2239         av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2240         return 0;
2241     }
2242     av_dict_set(&o->g->codec_opts, opt, arg, 0);
2243     return 0;
2244 }
2245
2246 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2247 {
2248     OptionsContext *o = optctx;
2249     char *s;
2250     int ret;
2251     if(!strcmp(opt, "qscale")){
2252         av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2253         return parse_option(o, "q:v", arg, options);
2254     }
2255     s = av_asprintf("q%s", opt + 6);
2256     ret = parse_option(o, s, arg, options);
2257     av_free(s);
2258     return ret;
2259 }
2260
2261 static int opt_profile(void *optctx, const char *opt, const char *arg)
2262 {
2263     OptionsContext *o = optctx;
2264     if(!strcmp(opt, "profile")){
2265         av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2266         av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
2267         return 0;
2268     }
2269     av_dict_set(&o->g->codec_opts, opt, arg, 0);
2270     return 0;
2271 }
2272
2273 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2274 {
2275     OptionsContext *o = optctx;
2276     return parse_option(o, "filter:v", arg, options);
2277 }
2278
2279 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2280 {
2281     OptionsContext *o = optctx;
2282     return parse_option(o, "filter:a", arg, options);
2283 }
2284
2285 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2286 {
2287     if      (!av_strcasecmp(arg, "cfr"))         video_sync_method = VSYNC_CFR;
2288     else if (!av_strcasecmp(arg, "vfr"))         video_sync_method = VSYNC_VFR;
2289     else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2290     else if (!av_strcasecmp(arg, "drop"))        video_sync_method = VSYNC_DROP;
2291
2292     if (video_sync_method == VSYNC_AUTO)
2293         video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
2294     return 0;
2295 }
2296
2297 static int opt_timecode(void *optctx, const char *opt, const char *arg)
2298 {
2299     OptionsContext *o = optctx;
2300     char *tcr = av_asprintf("timecode=%s", arg);
2301     int ret = parse_option(o, "metadata:g", tcr, options);
2302     if (ret >= 0)
2303         ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
2304     av_free(tcr);
2305     return 0;
2306 }
2307
2308 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2309 {
2310     OptionsContext *o = optctx;
2311     char layout_str[32];
2312     char *stream_str;
2313     char *ac_str;
2314     int ret, channels, ac_str_size;
2315     uint64_t layout;
2316
2317     layout = av_get_channel_layout(arg);
2318     if (!layout) {
2319         av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2320         return AVERROR(EINVAL);
2321     }
2322     snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2323     ret = opt_default_new(o, opt, layout_str);
2324     if (ret < 0)
2325         return ret;
2326
2327     /* set 'ac' option based on channel layout */
2328     channels = av_get_channel_layout_nb_channels(layout);
2329     snprintf(layout_str, sizeof(layout_str), "%d", channels);
2330     stream_str = strchr(opt, ':');
2331     ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2332     ac_str = av_mallocz(ac_str_size);
2333     if (!ac_str)
2334         return AVERROR(ENOMEM);
2335     av_strlcpy(ac_str, "ac", 3);
2336     if (stream_str)
2337         av_strlcat(ac_str, stream_str, ac_str_size);
2338     ret = parse_option(o, ac_str, layout_str, options);
2339     av_free(ac_str);
2340
2341     return ret;
2342 }
2343
2344 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2345 {
2346     OptionsContext *o = optctx;
2347     return parse_option(o, "q:a", arg, options);
2348 }
2349
2350 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2351 {
2352     GROW_ARRAY(filtergraphs, nb_filtergraphs);
2353     if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2354         return AVERROR(ENOMEM);
2355     filtergraphs[nb_filtergraphs - 1]->index      = nb_filtergraphs - 1;
2356     filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
2357     if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
2358         return AVERROR(ENOMEM);
2359     return 0;
2360 }
2361
2362 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
2363 {
2364     uint8_t *graph_desc = read_file(arg);
2365     if (!graph_desc)
2366         return AVERROR(EINVAL);
2367
2368     GROW_ARRAY(filtergraphs, nb_filtergraphs);
2369     if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2370         return AVERROR(ENOMEM);
2371     filtergraphs[nb_filtergraphs - 1]->index      = nb_filtergraphs - 1;
2372     filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
2373     return 0;
2374 }
2375
2376 void show_help_default(const char *opt, const char *arg)
2377 {
2378     /* per-file options have at least one of those set */
2379     const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2380     int show_advanced = 0, show_avoptions = 0;
2381
2382     if (opt && *opt) {
2383         if (!strcmp(opt, "long"))
2384             show_advanced = 1;
2385         else if (!strcmp(opt, "full"))
2386             show_advanced = show_avoptions = 1;
2387         else
2388             av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2389     }
2390
2391     show_usage();
2392
2393     printf("Getting help:\n"
2394            "    -h      -- print basic options\n"
2395            "    -h long -- print more options\n"
2396            "    -h full -- print all options (including all format and codec specific options, very long)\n"
2397            "    See man %s for detailed description of the options.\n"
2398            "\n", program_name);
2399
2400     show_help_options(options, "Print help / information / capabilities:",
2401                       OPT_EXIT, 0, 0);
2402
2403     show_help_options(options, "Global options (affect whole program "
2404                       "instead of just one file:",
2405                       0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2406     if (show_advanced)
2407         show_help_options(options, "Advanced global options:", OPT_EXPERT,
2408                           per_file | OPT_EXIT, 0);
2409
2410     show_help_options(options, "Per-file main options:", 0,
2411                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
2412                       OPT_EXIT, per_file);
2413     if (show_advanced)
2414         show_help_options(options, "Advanced per-file options:",
2415                           OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2416
2417     show_help_options(options, "Video options:",
2418                       OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
2419     if (show_advanced)
2420         show_help_options(options, "Advanced Video options:",
2421                           OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2422
2423     show_help_options(options, "Audio options:",
2424                       OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2425     if (show_advanced)
2426         show_help_options(options, "Advanced Audio options:",
2427                           OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2428     show_help_options(options, "Subtitle options:",
2429                       OPT_SUBTITLE, 0, 0);
2430     printf("\n");
2431
2432     if (show_avoptions) {
2433         int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2434         show_help_children(avcodec_get_class(), flags);
2435         show_help_children(avformat_get_class(), flags);
2436         show_help_children(sws_get_class(), flags);
2437         show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
2438         show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM);
2439     }
2440 }
2441
2442 void show_usage(void)
2443 {
2444     av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
2445     av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2446     av_log(NULL, AV_LOG_INFO, "\n");
2447 }
2448
2449 enum OptGroup {
2450     GROUP_OUTFILE,
2451     GROUP_INFILE,
2452 };
2453
2454 static const OptionGroupDef groups[] = {
2455     [GROUP_OUTFILE] = { "output file",  NULL, OPT_OUTPUT },
2456     [GROUP_INFILE]  = { "input file",   "i",  OPT_INPUT },
2457 };
2458
2459 static int open_files(OptionGroupList *l, const char *inout,
2460                       int (*open_file)(OptionsContext*, const char*))
2461 {
2462     int i, ret;
2463
2464     for (i = 0; i < l->nb_groups; i++) {
2465         OptionGroup *g = &l->groups[i];
2466         OptionsContext o;
2467
2468         init_options(&o, !strcmp(inout, "input"));
2469         o.g = g;
2470
2471         ret = parse_optgroup(&o, g);
2472         if (ret < 0) {
2473             av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
2474                    "%s.\n", inout, g->arg);
2475             return ret;
2476         }
2477
2478         av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
2479         ret = open_file(&o, g->arg);
2480         uninit_options(&o, !strcmp(inout, "input"));
2481         if (ret < 0) {
2482             av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
2483                    inout, g->arg);
2484             return ret;
2485         }
2486         av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
2487     }
2488
2489     return 0;
2490 }
2491
2492 int ffmpeg_parse_options(int argc, char **argv)
2493 {
2494     OptionParseContext octx;
2495     uint8_t error[128];
2496     int ret;
2497
2498     memset(&octx, 0, sizeof(octx));
2499
2500     /* split the commandline into an internal representation */
2501     ret = split_commandline(&octx, argc, argv, options, groups,
2502                             FF_ARRAY_ELEMS(groups));
2503     if (ret < 0) {
2504         av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
2505         goto fail;
2506     }
2507
2508     /* apply global options */
2509     ret = parse_optgroup(NULL, &octx.global_opts);
2510     if (ret < 0) {
2511         av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
2512         goto fail;
2513     }
2514
2515     /* open input files */
2516     ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
2517     if (ret < 0) {
2518         av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
2519         goto fail;
2520     }
2521
2522     /* open output files */
2523     ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
2524     if (ret < 0) {
2525         av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
2526         goto fail;
2527     }
2528
2529 fail:
2530     uninit_parse_context(&octx);
2531     if (ret < 0) {
2532         av_strerror(ret, error, sizeof(error));
2533         av_log(NULL, AV_LOG_FATAL, "%s\n", error);
2534     }
2535     return ret;
2536 }
2537
2538 static int opt_progress(void *optctx, const char *opt, const char *arg)
2539 {
2540     AVIOContext *avio = NULL;
2541     int ret;
2542
2543     if (!strcmp(arg, "-"))
2544         arg = "pipe:";
2545     ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
2546     if (ret < 0) {
2547         av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
2548                arg, av_err2str(ret));
2549         return ret;
2550     }
2551     progress_avio = avio;
2552     return 0;
2553 }
2554
2555 #define OFFSET(x) offsetof(OptionsContext, x)
2556 const OptionDef options[] = {
2557     /* main options */
2558 #include "cmdutils_common_opts.h"
2559     { "f",              HAS_ARG | OPT_STRING | OPT_OFFSET |
2560                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(format) },
2561         "force format", "fmt" },
2562     { "y",              OPT_BOOL,                                    {              &file_overwrite },
2563         "overwrite output files" },
2564     { "n",              OPT_BOOL,                                    {              &no_file_overwrite },
2565         "do not overwrite output files" },
2566     { "c",              HAS_ARG | OPT_STRING | OPT_SPEC |
2567                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(codec_names) },
2568         "codec name", "codec" },
2569     { "codec",          HAS_ARG | OPT_STRING | OPT_SPEC |
2570                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(codec_names) },
2571         "codec name", "codec" },
2572     { "pre",            HAS_ARG | OPT_STRING | OPT_SPEC |
2573                         OPT_OUTPUT,                                  { .off       = OFFSET(presets) },
2574         "preset name", "preset" },
2575     { "map",            HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2576                         OPT_OUTPUT,                                  { .func_arg = opt_map },
2577         "set input stream mapping",
2578         "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
2579     { "map_channel",    HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
2580         "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
2581     { "map_metadata",   HAS_ARG | OPT_STRING | OPT_SPEC |
2582                         OPT_OUTPUT,                                  { .off       = OFFSET(metadata_map) },
2583         "set metadata information of outfile from infile",
2584         "outfile[,metadata]:infile[,metadata]" },
2585     { "map_chapters",   HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
2586                         OPT_OUTPUT,                                  { .off = OFFSET(chapters_input_file) },
2587         "set chapters mapping", "input_file_index" },
2588     { "t",              HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
2589         "record or transcode \"duration\" seconds of audio/video",
2590         "duration" },
2591     { "to",             HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_OUTPUT,  { .off = OFFSET(stop_time) },
2592         "record or transcode stop time", "time_stop" },
2593     { "fs",             HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
2594         "set the limit file size in bytes", "limit_size" },
2595     { "ss",             HAS_ARG | OPT_TIME | OPT_OFFSET |
2596                         OPT_INPUT | OPT_OUTPUT,                      { .off = OFFSET(start_time) },
2597         "set the start time offset", "time_off" },
2598     { "itsoffset",      HAS_ARG | OPT_TIME | OPT_OFFSET |
2599                         OPT_EXPERT | OPT_INPUT,                      { .off = OFFSET(input_ts_offset) },
2600         "set the input ts offset", "time_off" },
2601     { "itsscale",       HAS_ARG | OPT_DOUBLE | OPT_SPEC |
2602                         OPT_EXPERT | OPT_INPUT,                      { .off = OFFSET(ts_scale) },
2603         "set the input ts scale", "scale" },
2604     { "timestamp",      HAS_ARG | OPT_PERFILE,                       { .func_arg = opt_recording_timestamp },
2605         "set the recording timestamp ('now' to set the current time)", "time" },
2606     { "metadata",       HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
2607         "add metadata", "string=string" },
2608     { "dframes",        HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2609                         OPT_OUTPUT,                                  { .func_arg = opt_data_frames },
2610         "set the number of data frames to record", "number" },
2611     { "benchmark",      OPT_BOOL | OPT_EXPERT,                       { &do_benchmark },
2612         "add timings for benchmarking" },
2613     { "benchmark_all",  OPT_BOOL | OPT_EXPERT,                       { &do_benchmark_all },
2614       "add timings for each task" },
2615     { "progress",       HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_progress },
2616       "write program-readable progress information", "url" },
2617     { "stdin",          OPT_BOOL | OPT_EXPERT,                       { &stdin_interaction },
2618       "enable or disable interaction on standard input" },
2619     { "timelimit",      HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_timelimit },
2620         "set max runtime in seconds", "limit" },
2621     { "dump",           OPT_BOOL | OPT_EXPERT,                       { &do_pkt_dump },
2622         "dump each input packet" },
2623     { "hex",            OPT_BOOL | OPT_EXPERT,                       { &do_hex_dump },
2624         "when dumping packets, also dump the payload" },
2625     { "re",             OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2626                         OPT_INPUT,                                   { .off = OFFSET(rate_emu) },
2627         "read input at native frame rate", "" },
2628     { "target",         HAS_ARG | OPT_PERFILE | OPT_OUTPUT,          { .func_arg = opt_target },
2629         "specify target file type (\"vcd\", \"svcd\", \"dvd\","
2630         " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2631     { "vsync",          HAS_ARG | OPT_EXPERT,                        { opt_vsync },
2632         "video sync method", "" },
2633     { "async",          HAS_ARG | OPT_INT | OPT_EXPERT,              { &audio_sync_method },
2634         "audio sync method", "" },
2635     { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,          { &audio_drift_threshold },
2636         "audio drift threshold", "threshold" },
2637     { "copyts",         OPT_BOOL | OPT_EXPERT,                       { &copy_ts },
2638         "copy timestamps" },
2639     { "copytb",         HAS_ARG | OPT_INT | OPT_EXPERT,              { &copy_tb },
2640         "copy input stream time base when stream copying", "mode" },
2641     { "shortest",       OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2642                         OPT_OUTPUT,                                  { .off = OFFSET(shortest) },
2643         "finish encoding within shortest input" },
2644     { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,       { &dts_delta_threshold },
2645         "timestamp discontinuity delta threshold", "threshold" },
2646     { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,       { &dts_error_threshold },
2647         "timestamp error delta threshold", "threshold" },
2648     { "xerror",         OPT_BOOL | OPT_EXPERT,                       { &exit_on_error },
2649         "exit on error", "error" },
2650     { "copyinkf",       OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2651                         OPT_OUTPUT,                                  { .off = OFFSET(copy_initial_nonkeyframes) },
2652         "copy initial non-keyframes" },
2653     { "copypriorss",    OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT,   { .off = OFFSET(copy_prior_start) },
2654         "copy or discard frames before start time" },
2655     { "frames",         OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
2656         "set the number of frames to record", "number" },
2657     { "tag",            OPT_STRING | HAS_ARG | OPT_SPEC |
2658                         OPT_EXPERT | OPT_OUTPUT,                     { .off = OFFSET(codec_tags) },
2659         "force codec tag/fourcc", "fourcc/tag" },
2660     { "q",              HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
2661                         OPT_SPEC | OPT_OUTPUT,                       { .off = OFFSET(qscale) },
2662         "use fixed quality scale (VBR)", "q" },
2663     { "qscale",         HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2664                         OPT_OUTPUT,                                  { .func_arg = opt_qscale },
2665         "use fixed quality scale (VBR)", "q" },
2666     { "profile",        HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
2667         "set profile", "profile" },
2668     { "filter",         HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
2669         "set stream filtergraph", "filter_graph" },
2670     { "filter_script",  HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
2671         "read stream filtergraph description from a file", "filename" },
2672     { "reinit_filter",  HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT,    { .off = OFFSET(reinit_filters) },
2673         "reinit filtergraph on input parameter changes", "" },
2674     { "filter_complex", HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_filter_complex },
2675         "create a complex filtergraph", "graph_description" },
2676     { "lavfi",          HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_filter_complex },
2677         "create a complex filtergraph", "graph_description" },
2678     { "filter_complex_script", HAS_ARG | OPT_EXPERT,                 { .func_arg = opt_filter_complex_script },
2679         "read complex filtergraph description from a file", "filename" },
2680     { "stats",          OPT_BOOL,                                    { &print_stats },
2681         "print progress report during encoding", },
2682     { "attach",         HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2683                         OPT_OUTPUT,                                  { .func_arg = opt_attach },
2684         "add an attachment to the output file", "filename" },
2685     { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
2686                          OPT_EXPERT | OPT_INPUT,                     { .off = OFFSET(dump_attachment) },
2687         "extract an attachment into a file", "filename" },
2688     { "debug_ts",       OPT_BOOL | OPT_EXPERT,                       { &debug_ts },
2689         "print timestamp debugging info" },
2690
2691     /* video options */
2692     { "vframes",      OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_video_frames },
2693         "set the number of video frames to record", "number" },
2694     { "r",            OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC |
2695                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_rates) },
2696         "set frame rate (Hz value, fraction or abbreviation)", "rate" },
2697     { "s",            OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC |
2698                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_sizes) },
2699         "set frame size (WxH or abbreviation)", "size" },
2700     { "aspect",       OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC |
2701                       OPT_OUTPUT,                                                { .off = OFFSET(frame_aspect_ratios) },
2702         "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
2703     { "pix_fmt",      OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
2704                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_pix_fmts) },
2705         "set pixel format", "format" },
2706     { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG,                      { &frame_bits_per_raw_sample },
2707         "set the number of bits per raw sample", "number" },
2708     { "intra",        OPT_VIDEO | OPT_BOOL | OPT_EXPERT,                         { &intra_only },
2709         "deprecated use -g 1" },
2710     { "vn",           OPT_VIDEO | OPT_BOOL  | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) },
2711         "disable video" },
2712     { "vdt",          OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT ,               { &video_discard },
2713         "discard threshold", "n" },
2714     { "rc_override",  OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
2715                       OPT_OUTPUT,                                                { .off = OFFSET(rc_overrides) },
2716         "rate control override for specific intervals", "override" },
2717     { "vcodec",       OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_INPUT |
2718                       OPT_OUTPUT,                                                { .func_arg = opt_video_codec },
2719         "force video codec ('copy' to copy stream)", "codec" },
2720     { "sameq",        OPT_VIDEO | OPT_EXPERT ,                                   { .func_arg = opt_sameq },
2721         "Removed" },
2722     { "same_quant",   OPT_VIDEO | OPT_EXPERT ,                                   { .func_arg = opt_sameq },
2723         "Removed" },
2724     { "timecode",     OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT,            { .func_arg = opt_timecode },
2725         "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
2726     { "pass",         OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT,     { .off = OFFSET(pass) },
2727         "select the pass number (1 to 3)", "n" },
2728     { "passlogfile",  OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
2729                       OPT_OUTPUT,                                                { .off = OFFSET(passlogfiles) },
2730         "select two pass log file name prefix", "prefix" },
2731     { "deinterlace",  OPT_VIDEO | OPT_BOOL | OPT_EXPERT,                         { &do_deinterlace },
2732         "this option is deprecated, use the yadif filter instead" },
2733     { "psnr",         OPT_VIDEO | OPT_BOOL | OPT_EXPERT,                         { &do_psnr },
2734         "calculate PSNR of compressed frames" },
2735     { "vstats",       OPT_VIDEO | OPT_EXPERT ,                                   { &opt_vstats },
2736         "dump video coding statistics to file" },
2737     { "vstats_file",  OPT_VIDEO | HAS_ARG | OPT_EXPERT ,                         { opt_vstats_file },
2738         "dump video coding statistics to file", "file" },
2739     { "vf",           OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_video_filters },
2740         "set video filters", "filter_graph" },
2741     { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
2742                       OPT_OUTPUT,                                                { .off = OFFSET(intra_matrices) },
2743         "specify intra matrix coeffs", "matrix" },
2744     { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
2745                       OPT_OUTPUT,                                                { .off = OFFSET(inter_matrices) },
2746         "specify inter matrix coeffs", "matrix" },
2747     { "top",          OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_INT| OPT_SPEC |
2748                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(top_field_first) },
2749         "top=1/bottom=0/auto=-1 field first", "" },
2750     { "dc",           OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT ,               { &intra_dc_precision },
2751         "intra_dc_precision", "precision" },
2752     { "vtag",         OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_PERFILE |
2753                       OPT_OUTPUT,                                                { .func_arg = opt_old2new },
2754         "force video tag/fourcc", "fourcc/tag" },
2755     { "qphist",       OPT_VIDEO | OPT_BOOL | OPT_EXPERT ,                        { &qp_hist },
2756         "show QP histogram" },
2757     { "force_fps",    OPT_VIDEO | OPT_BOOL | OPT_EXPERT  | OPT_SPEC |
2758                       OPT_OUTPUT,                                                { .off = OFFSET(force_fps) },
2759         "force the selected framerate, disable the best supported framerate selection" },
2760     { "streamid",     OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2761                       OPT_OUTPUT,                                                { .func_arg = opt_streamid },
2762         "set the value of an outfile streamid", "streamIndex:value" },
2763     { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2764                           OPT_SPEC | OPT_OUTPUT,                                 { .off = OFFSET(forced_key_frames) },
2765         "force key frames at specified timestamps", "timestamps" },
2766     { "b",            OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT,            { .func_arg = opt_bitrate },
2767         "video bitrate (please use -b:v)", "bitrate" },
2768
2769     /* audio options */
2770     { "aframes",        OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_frames },
2771         "set the number of audio frames to record", "number" },
2772     { "aq",             OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_qscale },
2773         "set audio quality (codec-specific)", "quality", },
2774     { "ar",             OPT_AUDIO | HAS_ARG  | OPT_INT | OPT_SPEC |
2775                         OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(audio_sample_rate) },
2776         "set audio sampling rate (in Hz)", "rate" },
2777     { "ac",             OPT_AUDIO | HAS_ARG  | OPT_INT | OPT_SPEC |
2778                         OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(audio_channels) },
2779         "set number of audio channels", "channels" },
2780     { "an",             OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) },
2781         "disable audio" },
2782     { "acodec",         OPT_AUDIO | HAS_ARG  | OPT_PERFILE |
2783                         OPT_INPUT | OPT_OUTPUT,                                    { .func_arg = opt_audio_codec },
2784         "force audio codec ('copy' to copy stream)", "codec" },
2785     { "atag",           OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_PERFILE |
2786                         OPT_OUTPUT,                                                { .func_arg = opt_old2new },
2787         "force audio tag/fourcc", "fourcc/tag" },
2788     { "vol",            OPT_AUDIO | HAS_ARG  | OPT_INT,                            { &audio_volume },
2789         "change audio volume (256=normal)" , "volume" },
2790     { "sample_fmt",     OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_SPEC |
2791                         OPT_STRING | OPT_INPUT | OPT_OUTPUT,                       { .off = OFFSET(sample_fmts) },
2792         "set sample format", "format" },
2793     { "channel_layout", OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_PERFILE |
2794                         OPT_INPUT | OPT_OUTPUT,                                    { .func_arg = opt_channel_layout },
2795         "set channel layout", "layout" },
2796     { "af",             OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_filters },
2797         "set audio filters", "filter_graph" },
2798     { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
2799       "set the maximum number of channels to try to guess the channel layout" },
2800
2801     /* subtitle options */
2802     { "sn",     OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
2803         "disable subtitle" },
2804     { "scodec", OPT_SUBTITLE | HAS_ARG  | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
2805         "force subtitle codec ('copy' to copy stream)", "codec" },
2806     { "stag",   OPT_SUBTITLE | HAS_ARG  | OPT_EXPERT  | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
2807         , "force subtitle tag/fourcc", "fourcc/tag" },
2808     { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
2809         "fix subtitles duration" },
2810     { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
2811         "set canvas size (WxH or abbreviation)", "size" },
2812
2813     /* grab options */
2814     { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
2815         "deprecated, use -channel", "channel" },
2816     { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
2817         "deprecated, use -standard", "standard" },
2818     { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
2819
2820     /* muxer options */
2821     { "muxdelay",   OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
2822         "set the maximum demux-decode delay", "seconds" },
2823     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
2824         "set the initial demux-decode delay", "seconds" },
2825
2826     { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
2827         "A comma-separated list of bitstream filters", "bitstream_filters" },
2828     { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
2829         "deprecated", "audio bitstream_filters" },
2830     { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
2831         "deprecated", "video bitstream_filters" },
2832
2833     { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT,    { .func_arg = opt_preset },
2834         "set the audio options to the indicated preset", "preset" },
2835     { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT,    { .func_arg = opt_preset },
2836         "set the video options to the indicated preset", "preset" },
2837     { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
2838         "set the subtitle options to the indicated preset", "preset" },
2839     { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT,                { .func_arg = opt_preset },
2840         "set options from indicated preset file", "filename" },
2841     /* data codec support */
2842     { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
2843         "force data codec ('copy' to copy stream)", "codec" },
2844     { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },
2845         "disable data" },
2846
2847     { NULL, },
2848 };