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