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