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