Merge commit 'be101bc1e357c50fcb740bc4870b3bacc93a5727'
[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
1849     if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
1850         o->stop_time = INT64_MAX;
1851         av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
1852     }
1853
1854     if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
1855         int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
1856         if (o->stop_time <= start_time) {
1857             av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
1858             exit_program(1);
1859         } else {
1860             o->recording_time = o->stop_time - start_time;
1861         }
1862     }
1863
1864     GROW_ARRAY(output_files, nb_output_files);
1865     of = av_mallocz(sizeof(*of));
1866     if (!of)
1867         exit_program(1);
1868     output_files[nb_output_files - 1] = of;
1869
1870     of->ost_index      = nb_output_streams;
1871     of->recording_time = o->recording_time;
1872     of->start_time     = o->start_time;
1873     of->limit_filesize = o->limit_filesize;
1874     of->shortest       = o->shortest;
1875     av_dict_copy(&of->opts, o->g->format_opts, 0);
1876
1877     if (!strcmp(filename, "-"))
1878         filename = "pipe:";
1879
1880     err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
1881     if (!oc) {
1882         print_error(filename, err);
1883         exit_program(1);
1884     }
1885
1886     of->ctx = oc;
1887     if (o->recording_time != INT64_MAX)
1888         oc->duration = o->recording_time;
1889
1890     file_oformat= oc->oformat;
1891     oc->interrupt_callback = int_cb;
1892
1893     /* create streams for all unlabeled output pads */
1894     for (i = 0; i < nb_filtergraphs; i++) {
1895         FilterGraph *fg = filtergraphs[i];
1896         for (j = 0; j < fg->nb_outputs; j++) {
1897             OutputFilter *ofilter = fg->outputs[j];
1898
1899             if (!ofilter->out_tmp || ofilter->out_tmp->name)
1900                 continue;
1901
1902             switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1903                                           ofilter->out_tmp->pad_idx)) {
1904             case AVMEDIA_TYPE_VIDEO:    o->video_disable    = 1; break;
1905             case AVMEDIA_TYPE_AUDIO:    o->audio_disable    = 1; break;
1906             case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1907             }
1908             init_output_filter(ofilter, o, oc);
1909         }
1910     }
1911
1912     /* ffserver seeking with date=... needs a date reference */
1913     if (!strcmp(file_oformat->name, "ffm") &&
1914         av_strstart(filename, "http:", NULL)) {
1915         int err = parse_option(o, "metadata", "creation_time=now", options);
1916         if (err < 0) {
1917             print_error(filename, err);
1918             exit_program(1);
1919         }
1920     }
1921
1922     if (!strcmp(file_oformat->name, "ffm") && !override_ffserver &&
1923         av_strstart(filename, "http:", NULL)) {
1924         int j;
1925         /* special case for files sent to ffserver: we get the stream
1926            parameters from ffserver */
1927         int err = read_ffserver_streams(o, oc, filename);
1928         if (err < 0) {
1929             print_error(filename, err);
1930             exit_program(1);
1931         }
1932         for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
1933             ost = output_streams[j];
1934             for (i = 0; i < nb_input_streams; i++) {
1935                 ist = input_streams[i];
1936                 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
1937                     ost->sync_ist= ist;
1938                     ost->source_index= i;
1939                     if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
1940                     if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
1941                     ist->discard = 0;
1942                     ist->st->discard = ist->user_set_discard;
1943                     break;
1944                 }
1945             }
1946             if(!ost->sync_ist){
1947                 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));
1948                 exit_program(1);
1949             }
1950         }
1951     } else if (!o->nb_stream_maps) {
1952         char *subtitle_codec_name = NULL;
1953         /* pick the "best" stream of each type */
1954
1955         /* video: highest resolution */
1956         if (!o->video_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_VIDEO) != AV_CODEC_ID_NONE) {
1957             int area = 0, idx = -1;
1958             int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
1959             for (i = 0; i < nb_input_streams; i++) {
1960                 int new_area;
1961                 ist = input_streams[i];
1962                 new_area = ist->st->codec->width * ist->st->codec->height + 100000000*!!ist->st->codec_info_nb_frames;
1963                 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1964                     new_area = 1;
1965                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1966                     new_area > area) {
1967                     if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1968                         continue;
1969                     area = new_area;
1970                     idx = i;
1971                 }
1972             }
1973             if (idx >= 0)
1974                 new_video_stream(o, oc, idx);
1975         }
1976
1977         /* audio: most channels */
1978         if (!o->audio_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_AUDIO) != AV_CODEC_ID_NONE) {
1979             int channels = 0, idx = -1;
1980             for (i = 0; i < nb_input_streams; i++) {
1981                 ist = input_streams[i];
1982                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1983                     ist->st->codec->channels > channels) {
1984                     channels = ist->st->codec->channels;
1985                     idx = i;
1986                 }
1987             }
1988             if (idx >= 0)
1989                 new_audio_stream(o, oc, idx);
1990         }
1991
1992         /* subtitles: pick first */
1993         MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
1994         if (!o->subtitle_disable && (avcodec_find_encoder(oc->oformat->subtitle_codec) || subtitle_codec_name)) {
1995             for (i = 0; i < nb_input_streams; i++)
1996                 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1997                     AVCodecDescriptor const *input_descriptor =
1998                         avcodec_descriptor_get(input_streams[i]->st->codec->codec_id);
1999                     AVCodecDescriptor const *output_descriptor = NULL;
2000                     AVCodec const *output_codec =
2001                         avcodec_find_encoder(oc->oformat->subtitle_codec);
2002                     int input_props = 0, output_props = 0;
2003                     if (output_codec)
2004                         output_descriptor = avcodec_descriptor_get(output_codec->id);
2005                     if (input_descriptor)
2006                         input_props = input_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2007                     if (output_descriptor)
2008                         output_props = output_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2009                     if (subtitle_codec_name ||
2010                         input_props & output_props ||
2011                         // Map dvb teletext which has neither property to any output subtitle encoder
2012                         input_descriptor && output_descriptor &&
2013                         (!input_descriptor->props ||
2014                          !output_descriptor->props)) {
2015                         new_subtitle_stream(o, oc, i);
2016                         break;
2017                     }
2018                 }
2019         }
2020         /* Data only if codec id match */
2021         if (!o->data_disable ) {
2022             enum AVCodecID codec_id = av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_DATA);
2023             for (i = 0; codec_id != AV_CODEC_ID_NONE && i < nb_input_streams; i++) {
2024                 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_DATA
2025                     && input_streams[i]->st->codec->codec_id == codec_id )
2026                     new_data_stream(o, oc, i);
2027             }
2028         }
2029     } else {
2030         for (i = 0; i < o->nb_stream_maps; i++) {
2031             StreamMap *map = &o->stream_maps[i];
2032
2033             if (map->disabled)
2034                 continue;
2035
2036             if (map->linklabel) {
2037                 FilterGraph *fg;
2038                 OutputFilter *ofilter = NULL;
2039                 int j, k;
2040
2041                 for (j = 0; j < nb_filtergraphs; j++) {
2042                     fg = filtergraphs[j];
2043                     for (k = 0; k < fg->nb_outputs; k++) {
2044                         AVFilterInOut *out = fg->outputs[k]->out_tmp;
2045                         if (out && !strcmp(out->name, map->linklabel)) {
2046                             ofilter = fg->outputs[k];
2047                             goto loop_end;
2048                         }
2049                     }
2050                 }
2051 loop_end:
2052                 if (!ofilter) {
2053                     av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
2054                            "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
2055                     exit_program(1);
2056                 }
2057                 init_output_filter(ofilter, o, oc);
2058             } else {
2059                 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
2060
2061                 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
2062                 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
2063                     continue;
2064                 if(o->   audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
2065                     continue;
2066                 if(o->   video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2067                     continue;
2068                 if(o->    data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
2069                     continue;
2070
2071                 ost = NULL;
2072                 switch (ist->st->codec->codec_type) {
2073                 case AVMEDIA_TYPE_VIDEO:      ost = new_video_stream     (o, oc, src_idx); break;
2074                 case AVMEDIA_TYPE_AUDIO:      ost = new_audio_stream     (o, oc, src_idx); break;
2075                 case AVMEDIA_TYPE_SUBTITLE:   ost = new_subtitle_stream  (o, oc, src_idx); break;
2076                 case AVMEDIA_TYPE_DATA:       ost = new_data_stream      (o, oc, src_idx); break;
2077                 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
2078                 case AVMEDIA_TYPE_UNKNOWN:
2079                     if (copy_unknown_streams) {
2080                         ost = new_unknown_stream   (o, oc, src_idx);
2081                         break;
2082                     }
2083                 default:
2084                     av_log(NULL, ignore_unknown_streams ? AV_LOG_WARNING : AV_LOG_FATAL,
2085                            "Cannot map stream #%d:%d - unsupported type.\n",
2086                            map->file_index, map->stream_index);
2087                     if (!ignore_unknown_streams) {
2088                         av_log(NULL, AV_LOG_FATAL,
2089                                "If you want unsupported types ignored instead "
2090                                "of failing, please use the -ignore_unknown option\n"
2091                                "If you want them copied, please use -copy_unknown\n");
2092                         exit_program(1);
2093                     }
2094                 }
2095                 if (ost)
2096                     ost->sync_ist = input_streams[  input_files[map->sync_file_index]->ist_index
2097                                                   + map->sync_stream_index];
2098             }
2099         }
2100     }
2101
2102     /* handle attached files */
2103     for (i = 0; i < o->nb_attachments; i++) {
2104         AVIOContext *pb;
2105         uint8_t *attachment;
2106         const char *p;
2107         int64_t len;
2108
2109         if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
2110             av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
2111                    o->attachments[i]);
2112             exit_program(1);
2113         }
2114         if ((len = avio_size(pb)) <= 0) {
2115             av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
2116                    o->attachments[i]);
2117             exit_program(1);
2118         }
2119         if (!(attachment = av_malloc(len))) {
2120             av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
2121                    o->attachments[i]);
2122             exit_program(1);
2123         }
2124         avio_read(pb, attachment, len);
2125
2126         ost = new_attachment_stream(o, oc, -1);
2127         ost->stream_copy               = 1;
2128         ost->attachment_filename       = o->attachments[i];
2129         ost->finished                  = 1;
2130         ost->st->codec->extradata      = attachment;
2131         ost->st->codec->extradata_size = len;
2132
2133         p = strrchr(o->attachments[i], '/');
2134         av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
2135         avio_closep(&pb);
2136     }
2137
2138     for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
2139         AVDictionaryEntry *e;
2140         ost = output_streams[i];
2141
2142         if ((ost->stream_copy || ost->attachment_filename)
2143             && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
2144             && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
2145             if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
2146                 exit_program(1);
2147     }
2148
2149     if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
2150         av_dump_format(oc, nb_output_files - 1, oc->filename, 1);
2151         av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", nb_output_files - 1);
2152         exit_program(1);
2153     }
2154
2155     /* check if all codec options have been used */
2156     unused_opts = strip_specifiers(o->g->codec_opts);
2157     for (i = of->ost_index; i < nb_output_streams; i++) {
2158         e = NULL;
2159         while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
2160                                 AV_DICT_IGNORE_SUFFIX)))
2161             av_dict_set(&unused_opts, e->key, NULL, 0);
2162     }
2163
2164     e = NULL;
2165     while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
2166         const AVClass *class = avcodec_get_class();
2167         const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
2168                                              AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2169         const AVClass *fclass = avformat_get_class();
2170         const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
2171                                               AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2172         if (!option || foption)
2173             continue;
2174
2175
2176         if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
2177             av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
2178                    "output file #%d (%s) is not an encoding option.\n", e->key,
2179                    option->help ? option->help : "", nb_output_files - 1,
2180                    filename);
2181             exit_program(1);
2182         }
2183
2184         // gop_timecode is injected by generic code but not always used
2185         if (!strcmp(e->key, "gop_timecode"))
2186             continue;
2187
2188         av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
2189                "output file #%d (%s) has not been used for any stream. The most "
2190                "likely reason is either wrong type (e.g. a video option with "
2191                "no video streams) or that it is a private option of some encoder "
2192                "which was not actually used for any stream.\n", e->key,
2193                option->help ? option->help : "", nb_output_files - 1, filename);
2194     }
2195     av_dict_free(&unused_opts);
2196
2197     /* set the encoding/decoding_needed flags */
2198     for (i = of->ost_index; i < nb_output_streams; i++) {
2199         OutputStream *ost = output_streams[i];
2200
2201         ost->encoding_needed = !ost->stream_copy;
2202         if (ost->encoding_needed && ost->source_index >= 0) {
2203             InputStream *ist = input_streams[ost->source_index];
2204             ist->decoding_needed |= DECODING_FOR_OST;
2205         }
2206     }
2207
2208     /* check filename in case of an image number is expected */
2209     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
2210         if (!av_filename_number_test(oc->filename)) {
2211             print_error(oc->filename, AVERROR(EINVAL));
2212             exit_program(1);
2213         }
2214     }
2215
2216     if (!(oc->oformat->flags & AVFMT_NOSTREAMS) && !input_stream_potentially_available) {
2217         av_log(NULL, AV_LOG_ERROR,
2218                "No input streams but output needs an input stream\n");
2219         exit_program(1);
2220     }
2221
2222     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
2223         /* test if it already exists to avoid losing precious files */
2224         assert_file_overwrite(filename);
2225
2226         /* open the file */
2227         if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
2228                               &oc->interrupt_callback,
2229                               &of->opts)) < 0) {
2230             print_error(filename, err);
2231             exit_program(1);
2232         }
2233     } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
2234         assert_file_overwrite(filename);
2235
2236     if (o->mux_preload) {
2237         av_dict_set_int(&of->opts, "preload", o->mux_preload*AV_TIME_BASE, 0);
2238     }
2239     oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
2240
2241     /* copy metadata */
2242     for (i = 0; i < o->nb_metadata_map; i++) {
2243         char *p;
2244         int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
2245
2246         if (in_file_index >= nb_input_files) {
2247             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
2248             exit_program(1);
2249         }
2250         copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
2251                       in_file_index >= 0 ?
2252                       input_files[in_file_index]->ctx : NULL, o);
2253     }
2254
2255     /* copy chapters */
2256     if (o->chapters_input_file >= nb_input_files) {
2257         if (o->chapters_input_file == INT_MAX) {
2258             /* copy chapters from the first input file that has them*/
2259             o->chapters_input_file = -1;
2260             for (i = 0; i < nb_input_files; i++)
2261                 if (input_files[i]->ctx->nb_chapters) {
2262                     o->chapters_input_file = i;
2263                     break;
2264                 }
2265         } else {
2266             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
2267                    o->chapters_input_file);
2268             exit_program(1);
2269         }
2270     }
2271     if (o->chapters_input_file >= 0)
2272         copy_chapters(input_files[o->chapters_input_file], of,
2273                       !o->metadata_chapters_manual);
2274
2275     /* copy global metadata by default */
2276     if (!o->metadata_global_manual && nb_input_files){
2277         av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
2278                      AV_DICT_DONT_OVERWRITE);
2279         if(o->recording_time != INT64_MAX)
2280             av_dict_set(&oc->metadata, "duration", NULL, 0);
2281         av_dict_set(&oc->metadata, "creation_time", NULL, 0);
2282     }
2283     if (!o->metadata_streams_manual)
2284         for (i = of->ost_index; i < nb_output_streams; i++) {
2285             InputStream *ist;
2286             if (output_streams[i]->source_index < 0)         /* this is true e.g. for attached files */
2287                 continue;
2288             ist = input_streams[output_streams[i]->source_index];
2289             av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
2290             if (!output_streams[i]->stream_copy) {
2291                 av_dict_set(&output_streams[i]->st->metadata, "encoder", NULL, 0);
2292                 if (ist->autorotate)
2293                     av_dict_set(&output_streams[i]->st->metadata, "rotate", NULL, 0);
2294             }
2295         }
2296
2297     /* process manually set metadata */
2298     for (i = 0; i < o->nb_metadata; i++) {
2299         AVDictionary **m;
2300         char type, *val;
2301         const char *stream_spec;
2302         int index = 0, j, ret = 0;
2303         char now_time[256];
2304
2305         val = strchr(o->metadata[i].u.str, '=');
2306         if (!val) {
2307             av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
2308                    o->metadata[i].u.str);
2309             exit_program(1);
2310         }
2311         *val++ = 0;
2312
2313         if (!strcmp(o->metadata[i].u.str, "creation_time") &&
2314             !strcmp(val, "now")) {
2315             time_t now = time(0);
2316             struct tm *ptm, tmbuf;
2317             ptm = localtime_r(&now, &tmbuf);
2318             if (ptm) {
2319                 if (strftime(now_time, sizeof(now_time), "%Y-%m-%d %H:%M:%S", ptm))
2320                     val = now_time;
2321             }
2322         }
2323
2324         parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
2325         if (type == 's') {
2326             for (j = 0; j < oc->nb_streams; j++) {
2327                 ost = output_streams[nb_output_streams - oc->nb_streams + j];
2328                 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2329                     av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2330                     if (!strcmp(o->metadata[i].u.str, "rotate")) {
2331                         ost->rotate_overridden = 1;
2332                     }
2333                 } else if (ret < 0)
2334                     exit_program(1);
2335             }
2336         }
2337         else {
2338             switch (type) {
2339             case 'g':
2340                 m = &oc->metadata;
2341                 break;
2342             case 'c':
2343                 if (index < 0 || index >= oc->nb_chapters) {
2344                     av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2345                     exit_program(1);
2346                 }
2347                 m = &oc->chapters[index]->metadata;
2348                 break;
2349             default:
2350                 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2351                 exit_program(1);
2352             }
2353             av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2354         }
2355     }
2356
2357     return 0;
2358 }
2359
2360 static int opt_target(void *optctx, const char *opt, const char *arg)
2361 {
2362     OptionsContext *o = optctx;
2363     enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2364     static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2365
2366     if (!strncmp(arg, "pal-", 4)) {
2367         norm = PAL;
2368         arg += 4;
2369     } else if (!strncmp(arg, "ntsc-", 5)) {
2370         norm = NTSC;
2371         arg += 5;
2372     } else if (!strncmp(arg, "film-", 5)) {
2373         norm = FILM;
2374         arg += 5;
2375     } else {
2376         /* Try to determine PAL/NTSC by peeking in the input files */
2377         if (nb_input_files) {
2378             int i, j, fr;
2379             for (j = 0; j < nb_input_files; j++) {
2380                 for (i = 0; i < input_files[j]->nb_streams; i++) {
2381                     AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
2382                     if (c->codec_type != AVMEDIA_TYPE_VIDEO ||
2383                         !c->time_base.num)
2384                         continue;
2385                     fr = c->time_base.den * 1000 / c->time_base.num;
2386                     if (fr == 25000) {
2387                         norm = PAL;
2388                         break;
2389                     } else if ((fr == 29970) || (fr == 23976)) {
2390                         norm = NTSC;
2391                         break;
2392                     }
2393                 }
2394                 if (norm != UNKNOWN)
2395                     break;
2396             }
2397         }
2398         if (norm != UNKNOWN)
2399             av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2400     }
2401
2402     if (norm == UNKNOWN) {
2403         av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2404         av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2405         av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2406         exit_program(1);
2407     }
2408
2409     if (!strcmp(arg, "vcd")) {
2410         opt_video_codec(o, "c:v", "mpeg1video");
2411         opt_audio_codec(o, "c:a", "mp2");
2412         parse_option(o, "f", "vcd", options);
2413
2414         parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2415         parse_option(o, "r", frame_rates[norm], options);
2416         opt_default(NULL, "g", norm == PAL ? "15" : "18");
2417
2418         opt_default(NULL, "b:v", "1150000");
2419         opt_default(NULL, "maxrate:v", "1150000");
2420         opt_default(NULL, "minrate:v", "1150000");
2421         opt_default(NULL, "bufsize:v", "327680"); // 40*1024*8;
2422
2423         opt_default(NULL, "b:a", "224000");
2424         parse_option(o, "ar", "44100", options);
2425         parse_option(o, "ac", "2", options);
2426
2427         opt_default(NULL, "packetsize", "2324");
2428         opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
2429
2430         /* We have to offset the PTS, so that it is consistent with the SCR.
2431            SCR starts at 36000, but the first two packs contain only padding
2432            and the first pack from the other stream, respectively, may also have
2433            been written before.
2434            So the real data starts at SCR 36000+3*1200. */
2435         o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2436     } else if (!strcmp(arg, "svcd")) {
2437
2438         opt_video_codec(o, "c:v", "mpeg2video");
2439         opt_audio_codec(o, "c:a", "mp2");
2440         parse_option(o, "f", "svcd", options);
2441
2442         parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2443         parse_option(o, "r", frame_rates[norm], options);
2444         parse_option(o, "pix_fmt", "yuv420p", options);
2445         opt_default(NULL, "g", norm == PAL ? "15" : "18");
2446
2447         opt_default(NULL, "b:v", "2040000");
2448         opt_default(NULL, "maxrate:v", "2516000");
2449         opt_default(NULL, "minrate:v", "0"); // 1145000;
2450         opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2451         opt_default(NULL, "scan_offset", "1");
2452
2453         opt_default(NULL, "b:a", "224000");
2454         parse_option(o, "ar", "44100", options);
2455
2456         opt_default(NULL, "packetsize", "2324");
2457
2458     } else if (!strcmp(arg, "dvd")) {
2459
2460         opt_video_codec(o, "c:v", "mpeg2video");
2461         opt_audio_codec(o, "c:a", "ac3");
2462         parse_option(o, "f", "dvd", options);
2463
2464         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2465         parse_option(o, "r", frame_rates[norm], options);
2466         parse_option(o, "pix_fmt", "yuv420p", options);
2467         opt_default(NULL, "g", norm == PAL ? "15" : "18");
2468
2469         opt_default(NULL, "b:v", "6000000");
2470         opt_default(NULL, "maxrate:v", "9000000");
2471         opt_default(NULL, "minrate:v", "0"); // 1500000;
2472         opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2473
2474         opt_default(NULL, "packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
2475         opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2476
2477         opt_default(NULL, "b:a", "448000");
2478         parse_option(o, "ar", "48000", options);
2479
2480     } else if (!strncmp(arg, "dv", 2)) {
2481
2482         parse_option(o, "f", "dv", options);
2483
2484         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2485         parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2486                           norm == PAL ? "yuv420p" : "yuv411p", options);
2487         parse_option(o, "r", frame_rates[norm], options);
2488
2489         parse_option(o, "ar", "48000", options);
2490         parse_option(o, "ac", "2", options);
2491
2492     } else {
2493         av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2494         return AVERROR(EINVAL);
2495     }
2496
2497     av_dict_copy(&o->g->codec_opts,  codec_opts, AV_DICT_DONT_OVERWRITE);
2498     av_dict_copy(&o->g->format_opts, format_opts, AV_DICT_DONT_OVERWRITE);
2499
2500     return 0;
2501 }
2502
2503 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2504 {
2505     av_free (vstats_filename);
2506     vstats_filename = av_strdup (arg);
2507     return 0;
2508 }
2509
2510 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2511 {
2512     char filename[40];
2513     time_t today2 = time(NULL);
2514     struct tm *today = localtime(&today2);
2515
2516     if (!today) { // maybe tomorrow
2517         av_log(NULL, AV_LOG_FATAL, "Unable to get current time: %s\n", strerror(errno));
2518         exit_program(1);
2519     }
2520
2521     snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2522              today->tm_sec);
2523     return opt_vstats_file(NULL, opt, filename);
2524 }
2525
2526 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2527 {
2528     OptionsContext *o = optctx;
2529     return parse_option(o, "frames:v", arg, options);
2530 }
2531
2532 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2533 {
2534     OptionsContext *o = optctx;
2535     return parse_option(o, "frames:a", arg, options);
2536 }
2537
2538 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2539 {
2540     OptionsContext *o = optctx;
2541     return parse_option(o, "frames:d", arg, options);
2542 }
2543
2544 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2545 {
2546     int ret;
2547     AVDictionary *cbak = codec_opts;
2548     AVDictionary *fbak = format_opts;
2549     codec_opts = NULL;
2550     format_opts = NULL;
2551
2552     ret = opt_default(NULL, opt, arg);
2553
2554     av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2555     av_dict_copy(&o->g->format_opts, format_opts, 0);
2556     av_dict_free(&codec_opts);
2557     av_dict_free(&format_opts);
2558     codec_opts = cbak;
2559     format_opts = fbak;
2560
2561     return ret;
2562 }
2563
2564 static int opt_preset(void *optctx, const char *opt, const char *arg)
2565 {
2566     OptionsContext *o = optctx;
2567     FILE *f=NULL;
2568     char filename[1000], line[1000], tmp_line[1000];
2569     const char *codec_name = NULL;
2570
2571     tmp_line[0] = *opt;
2572     tmp_line[1] = 0;
2573     MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2574
2575     if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2576         if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2577             av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2578         }else
2579             av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2580         exit_program(1);
2581     }
2582
2583     while (fgets(line, sizeof(line), f)) {
2584         char *key = tmp_line, *value, *endptr;
2585
2586         if (strcspn(line, "#\n\r") == 0)
2587             continue;
2588         av_strlcpy(tmp_line, line, sizeof(tmp_line));
2589         if (!av_strtok(key,   "=",    &value) ||
2590             !av_strtok(value, "\r\n", &endptr)) {
2591             av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2592             exit_program(1);
2593         }
2594         av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2595
2596         if      (!strcmp(key, "acodec")) opt_audio_codec   (o, key, value);
2597         else if (!strcmp(key, "vcodec")) opt_video_codec   (o, key, value);
2598         else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2599         else if (!strcmp(key, "dcodec")) opt_data_codec    (o, key, value);
2600         else if (opt_default_new(o, key, value) < 0) {
2601             av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2602                    filename, line, key, value);
2603             exit_program(1);
2604         }
2605     }
2606
2607     fclose(f);
2608
2609     return 0;
2610 }
2611
2612 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2613 {
2614     OptionsContext *o = optctx;
2615     char *s = av_asprintf("%s:%c", opt + 1, *opt);
2616     int ret = parse_option(o, s, arg, options);
2617     av_free(s);
2618     return ret;
2619 }
2620
2621 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2622 {
2623     OptionsContext *o = optctx;
2624
2625     if(!strcmp(opt, "ab")){
2626         av_dict_set(&o->g->codec_opts, "b:a", arg, 0);
2627         return 0;
2628     } else if(!strcmp(opt, "b")){
2629         av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2630         av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2631         return 0;
2632     }
2633     av_dict_set(&o->g->codec_opts, opt, arg, 0);
2634     return 0;
2635 }
2636
2637 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2638 {
2639     OptionsContext *o = optctx;
2640     char *s;
2641     int ret;
2642     if(!strcmp(opt, "qscale")){
2643         av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2644         return parse_option(o, "q:v", arg, options);
2645     }
2646     s = av_asprintf("q%s", opt + 6);
2647     ret = parse_option(o, s, arg, options);
2648     av_free(s);
2649     return ret;
2650 }
2651
2652 static int opt_profile(void *optctx, const char *opt, const char *arg)
2653 {
2654     OptionsContext *o = optctx;
2655     if(!strcmp(opt, "profile")){
2656         av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2657         av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
2658         return 0;
2659     }
2660     av_dict_set(&o->g->codec_opts, opt, arg, 0);
2661     return 0;
2662 }
2663
2664 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2665 {
2666     OptionsContext *o = optctx;
2667     return parse_option(o, "filter:v", arg, options);
2668 }
2669
2670 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2671 {
2672     OptionsContext *o = optctx;
2673     return parse_option(o, "filter:a", arg, options);
2674 }
2675
2676 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2677 {
2678     if      (!av_strcasecmp(arg, "cfr"))         video_sync_method = VSYNC_CFR;
2679     else if (!av_strcasecmp(arg, "vfr"))         video_sync_method = VSYNC_VFR;
2680     else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2681     else if (!av_strcasecmp(arg, "drop"))        video_sync_method = VSYNC_DROP;
2682
2683     if (video_sync_method == VSYNC_AUTO)
2684         video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
2685     return 0;
2686 }
2687
2688 static int opt_timecode(void *optctx, const char *opt, const char *arg)
2689 {
2690     OptionsContext *o = optctx;
2691     char *tcr = av_asprintf("timecode=%s", arg);
2692     int ret = parse_option(o, "metadata:g", tcr, options);
2693     if (ret >= 0)
2694         ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
2695     av_free(tcr);
2696     return 0;
2697 }
2698
2699 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2700 {
2701     OptionsContext *o = optctx;
2702     char layout_str[32];
2703     char *stream_str;
2704     char *ac_str;
2705     int ret, channels, ac_str_size;
2706     uint64_t layout;
2707
2708     layout = av_get_channel_layout(arg);
2709     if (!layout) {
2710         av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2711         return AVERROR(EINVAL);
2712     }
2713     snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2714     ret = opt_default_new(o, opt, layout_str);
2715     if (ret < 0)
2716         return ret;
2717
2718     /* set 'ac' option based on channel layout */
2719     channels = av_get_channel_layout_nb_channels(layout);
2720     snprintf(layout_str, sizeof(layout_str), "%d", channels);
2721     stream_str = strchr(opt, ':');
2722     ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2723     ac_str = av_mallocz(ac_str_size);
2724     if (!ac_str)
2725         return AVERROR(ENOMEM);
2726     av_strlcpy(ac_str, "ac", 3);
2727     if (stream_str)
2728         av_strlcat(ac_str, stream_str, ac_str_size);
2729     ret = parse_option(o, ac_str, layout_str, options);
2730     av_free(ac_str);
2731
2732     return ret;
2733 }
2734
2735 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2736 {
2737     OptionsContext *o = optctx;
2738     return parse_option(o, "q:a", arg, options);
2739 }
2740
2741 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2742 {
2743     GROW_ARRAY(filtergraphs, nb_filtergraphs);
2744     if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2745         return AVERROR(ENOMEM);
2746     filtergraphs[nb_filtergraphs - 1]->index      = nb_filtergraphs - 1;
2747     filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
2748     if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
2749         return AVERROR(ENOMEM);
2750
2751     input_stream_potentially_available = 1;
2752
2753     return 0;
2754 }
2755
2756 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
2757 {
2758     uint8_t *graph_desc = read_file(arg);
2759     if (!graph_desc)
2760         return AVERROR(EINVAL);
2761
2762     GROW_ARRAY(filtergraphs, nb_filtergraphs);
2763     if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2764         return AVERROR(ENOMEM);
2765     filtergraphs[nb_filtergraphs - 1]->index      = nb_filtergraphs - 1;
2766     filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
2767
2768     input_stream_potentially_available = 1;
2769
2770     return 0;
2771 }
2772
2773 void show_help_default(const char *opt, const char *arg)
2774 {
2775     /* per-file options have at least one of those set */
2776     const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2777     int show_advanced = 0, show_avoptions = 0;
2778
2779     if (opt && *opt) {
2780         if (!strcmp(opt, "long"))
2781             show_advanced = 1;
2782         else if (!strcmp(opt, "full"))
2783             show_advanced = show_avoptions = 1;
2784         else
2785             av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2786     }
2787
2788     show_usage();
2789
2790     printf("Getting help:\n"
2791            "    -h      -- print basic options\n"
2792            "    -h long -- print more options\n"
2793            "    -h full -- print all options (including all format and codec specific options, very long)\n"
2794            "    See man %s for detailed description of the options.\n"
2795            "\n", program_name);
2796
2797     show_help_options(options, "Print help / information / capabilities:",
2798                       OPT_EXIT, 0, 0);
2799
2800     show_help_options(options, "Global options (affect whole program "
2801                       "instead of just one file:",
2802                       0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2803     if (show_advanced)
2804         show_help_options(options, "Advanced global options:", OPT_EXPERT,
2805                           per_file | OPT_EXIT, 0);
2806
2807     show_help_options(options, "Per-file main options:", 0,
2808                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
2809                       OPT_EXIT, per_file);
2810     if (show_advanced)
2811         show_help_options(options, "Advanced per-file options:",
2812                           OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2813
2814     show_help_options(options, "Video options:",
2815                       OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
2816     if (show_advanced)
2817         show_help_options(options, "Advanced Video options:",
2818                           OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2819
2820     show_help_options(options, "Audio options:",
2821                       OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2822     if (show_advanced)
2823         show_help_options(options, "Advanced Audio options:",
2824                           OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2825     show_help_options(options, "Subtitle options:",
2826                       OPT_SUBTITLE, 0, 0);
2827     printf("\n");
2828
2829     if (show_avoptions) {
2830         int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2831         show_help_children(avcodec_get_class(), flags);
2832         show_help_children(avformat_get_class(), flags);
2833 #if CONFIG_SWSCALE
2834         show_help_children(sws_get_class(), flags);
2835 #endif
2836         show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
2837         show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM);
2838     }
2839 }
2840
2841 void show_usage(void)
2842 {
2843     av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
2844     av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2845     av_log(NULL, AV_LOG_INFO, "\n");
2846 }
2847
2848 enum OptGroup {
2849     GROUP_OUTFILE,
2850     GROUP_INFILE,
2851 };
2852
2853 static const OptionGroupDef groups[] = {
2854     [GROUP_OUTFILE] = { "output file",  NULL, OPT_OUTPUT },
2855     [GROUP_INFILE]  = { "input file",   "i",  OPT_INPUT },
2856 };
2857
2858 static int open_files(OptionGroupList *l, const char *inout,
2859                       int (*open_file)(OptionsContext*, const char*))
2860 {
2861     int i, ret;
2862
2863     for (i = 0; i < l->nb_groups; i++) {
2864         OptionGroup *g = &l->groups[i];
2865         OptionsContext o;
2866
2867         init_options(&o);
2868         o.g = g;
2869
2870         ret = parse_optgroup(&o, g);
2871         if (ret < 0) {
2872             av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
2873                    "%s.\n", inout, g->arg);
2874             return ret;
2875         }
2876
2877         av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
2878         ret = open_file(&o, g->arg);
2879         uninit_options(&o);
2880         if (ret < 0) {
2881             av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
2882                    inout, g->arg);
2883             return ret;
2884         }
2885         av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
2886     }
2887
2888     return 0;
2889 }
2890
2891 int ffmpeg_parse_options(int argc, char **argv)
2892 {
2893     OptionParseContext octx;
2894     uint8_t error[128];
2895     int ret;
2896
2897     memset(&octx, 0, sizeof(octx));
2898
2899     /* split the commandline into an internal representation */
2900     ret = split_commandline(&octx, argc, argv, options, groups,
2901                             FF_ARRAY_ELEMS(groups));
2902     if (ret < 0) {
2903         av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
2904         goto fail;
2905     }
2906
2907     /* apply global options */
2908     ret = parse_optgroup(NULL, &octx.global_opts);
2909     if (ret < 0) {
2910         av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
2911         goto fail;
2912     }
2913
2914     /* open input files */
2915     ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
2916     if (ret < 0) {
2917         av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
2918         goto fail;
2919     }
2920
2921     /* create the complex filtergraphs */
2922     ret = configure_complex_filters();
2923     if (ret < 0) {
2924         av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
2925         goto fail;
2926     }
2927
2928     /* open output files */
2929     ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
2930     if (ret < 0) {
2931         av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
2932         goto fail;
2933     }
2934
2935 fail:
2936     uninit_parse_context(&octx);
2937     if (ret < 0) {
2938         av_strerror(ret, error, sizeof(error));
2939         av_log(NULL, AV_LOG_FATAL, "%s\n", error);
2940     }
2941     return ret;
2942 }
2943
2944 static int opt_progress(void *optctx, const char *opt, const char *arg)
2945 {
2946     AVIOContext *avio = NULL;
2947     int ret;
2948
2949     if (!strcmp(arg, "-"))
2950         arg = "pipe:";
2951     ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
2952     if (ret < 0) {
2953         av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
2954                arg, av_err2str(ret));
2955         return ret;
2956     }
2957     progress_avio = avio;
2958     return 0;
2959 }
2960
2961 #define OFFSET(x) offsetof(OptionsContext, x)
2962 const OptionDef options[] = {
2963     /* main options */
2964 #include "cmdutils_common_opts.h"
2965     { "f",              HAS_ARG | OPT_STRING | OPT_OFFSET |
2966                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(format) },
2967         "force format", "fmt" },
2968     { "y",              OPT_BOOL,                                    {              &file_overwrite },
2969         "overwrite output files" },
2970     { "n",              OPT_BOOL,                                    {              &no_file_overwrite },
2971         "never overwrite output files" },
2972     { "ignore_unknown", OPT_BOOL,                                    {              &ignore_unknown_streams },
2973         "Ignore unknown stream types" },
2974     { "copy_unknown",   OPT_BOOL | OPT_EXPERT,                       {              &copy_unknown_streams },
2975         "Copy unknown stream types" },
2976     { "c",              HAS_ARG | OPT_STRING | OPT_SPEC |
2977                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(codec_names) },
2978         "codec name", "codec" },
2979     { "codec",          HAS_ARG | OPT_STRING | OPT_SPEC |
2980                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(codec_names) },
2981         "codec name", "codec" },
2982     { "pre",            HAS_ARG | OPT_STRING | OPT_SPEC |
2983                         OPT_OUTPUT,                                  { .off       = OFFSET(presets) },
2984         "preset name", "preset" },
2985     { "map",            HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2986                         OPT_OUTPUT,                                  { .func_arg = opt_map },
2987         "set input stream mapping",
2988         "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
2989     { "map_channel",    HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
2990         "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
2991     { "map_metadata",   HAS_ARG | OPT_STRING | OPT_SPEC |
2992                         OPT_OUTPUT,                                  { .off       = OFFSET(metadata_map) },
2993         "set metadata information of outfile from infile",
2994         "outfile[,metadata]:infile[,metadata]" },
2995     { "map_chapters",   HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
2996                         OPT_OUTPUT,                                  { .off = OFFSET(chapters_input_file) },
2997         "set chapters mapping", "input_file_index" },
2998     { "t",              HAS_ARG | OPT_TIME | OPT_OFFSET |
2999                         OPT_INPUT | OPT_OUTPUT,                      { .off = OFFSET(recording_time) },
3000         "record or transcode \"duration\" seconds of audio/video",
3001         "duration" },
3002     { "to",             HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_OUTPUT,  { .off = OFFSET(stop_time) },
3003         "record or transcode stop time", "time_stop" },
3004     { "fs",             HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
3005         "set the limit file size in bytes", "limit_size" },
3006     { "ss",             HAS_ARG | OPT_TIME | OPT_OFFSET |
3007                         OPT_INPUT | OPT_OUTPUT,                      { .off = OFFSET(start_time) },
3008         "set the start time offset", "time_off" },
3009     { "seek_timestamp", HAS_ARG | OPT_INT | OPT_OFFSET |
3010                         OPT_INPUT,                                   { .off = OFFSET(seek_timestamp) },
3011         "enable/disable seeking by timestamp with -ss" },
3012     { "accurate_seek",  OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
3013                         OPT_INPUT,                                   { .off = OFFSET(accurate_seek) },
3014         "enable/disable accurate seeking with -ss" },
3015     { "itsoffset",      HAS_ARG | OPT_TIME | OPT_OFFSET |
3016                         OPT_EXPERT | OPT_INPUT,                      { .off = OFFSET(input_ts_offset) },
3017         "set the input ts offset", "time_off" },
3018     { "itsscale",       HAS_ARG | OPT_DOUBLE | OPT_SPEC |
3019                         OPT_EXPERT | OPT_INPUT,                      { .off = OFFSET(ts_scale) },
3020         "set the input ts scale", "scale" },
3021     { "timestamp",      HAS_ARG | OPT_PERFILE | OPT_OUTPUT,          { .func_arg = opt_recording_timestamp },
3022         "set the recording timestamp ('now' to set the current time)", "time" },
3023     { "metadata",       HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
3024         "add metadata", "string=string" },
3025     { "dframes",        HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3026                         OPT_OUTPUT,                                  { .func_arg = opt_data_frames },
3027         "set the number of data frames to output", "number" },
3028     { "benchmark",      OPT_BOOL | OPT_EXPERT,                       { &do_benchmark },
3029         "add timings for benchmarking" },
3030     { "benchmark_all",  OPT_BOOL | OPT_EXPERT,                       { &do_benchmark_all },
3031       "add timings for each task" },
3032     { "progress",       HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_progress },
3033       "write program-readable progress information", "url" },
3034     { "stdin",          OPT_BOOL | OPT_EXPERT,                       { &stdin_interaction },
3035       "enable or disable interaction on standard input" },
3036     { "timelimit",      HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_timelimit },
3037         "set max runtime in seconds", "limit" },
3038     { "dump",           OPT_BOOL | OPT_EXPERT,                       { &do_pkt_dump },
3039         "dump each input packet" },
3040     { "hex",            OPT_BOOL | OPT_EXPERT,                       { &do_hex_dump },
3041         "when dumping packets, also dump the payload" },
3042     { "re",             OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3043                         OPT_INPUT,                                   { .off = OFFSET(rate_emu) },
3044         "read input at native frame rate", "" },
3045     { "target",         HAS_ARG | OPT_PERFILE | OPT_OUTPUT,          { .func_arg = opt_target },
3046         "specify target file type (\"vcd\", \"svcd\", \"dvd\","
3047         " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3048     { "vsync",          HAS_ARG | OPT_EXPERT,                        { opt_vsync },
3049         "video sync method", "" },
3050     { "frame_drop_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,      { &frame_drop_threshold },
3051         "frame drop threshold", "" },
3052     { "async",          HAS_ARG | OPT_INT | OPT_EXPERT,              { &audio_sync_method },
3053         "audio sync method", "" },
3054     { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,          { &audio_drift_threshold },
3055         "audio drift threshold", "threshold" },
3056     { "copyts",         OPT_BOOL | OPT_EXPERT,                       { &copy_ts },
3057         "copy timestamps" },
3058     { "start_at_zero",  OPT_BOOL | OPT_EXPERT,                       { &start_at_zero },
3059         "shift input timestamps to start at 0 when using copyts" },
3060     { "copytb",         HAS_ARG | OPT_INT | OPT_EXPERT,              { &copy_tb },
3061         "copy input stream time base when stream copying", "mode" },
3062     { "shortest",       OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3063                         OPT_OUTPUT,                                  { .off = OFFSET(shortest) },
3064         "finish encoding within shortest input" },
3065     { "apad",           OPT_STRING | HAS_ARG | OPT_SPEC |
3066                         OPT_OUTPUT,                                  { .off = OFFSET(apad) },
3067         "audio pad", "" },
3068     { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,       { &dts_delta_threshold },
3069         "timestamp discontinuity delta threshold", "threshold" },
3070     { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,       { &dts_error_threshold },
3071         "timestamp error delta threshold", "threshold" },
3072     { "xerror",         OPT_BOOL | OPT_EXPERT,                       { &exit_on_error },
3073         "exit on error", "error" },
3074     { "copyinkf",       OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3075                         OPT_OUTPUT,                                  { .off = OFFSET(copy_initial_nonkeyframes) },
3076         "copy initial non-keyframes" },
3077     { "copypriorss",    OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT,   { .off = OFFSET(copy_prior_start) },
3078         "copy or discard frames before start time" },
3079     { "frames",         OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
3080         "set the number of frames to output", "number" },
3081     { "tag",            OPT_STRING | HAS_ARG | OPT_SPEC |
3082                         OPT_EXPERT | OPT_OUTPUT | OPT_INPUT,         { .off = OFFSET(codec_tags) },
3083         "force codec tag/fourcc", "fourcc/tag" },
3084     { "q",              HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
3085                         OPT_SPEC | OPT_OUTPUT,                       { .off = OFFSET(qscale) },
3086         "use fixed quality scale (VBR)", "q" },
3087     { "qscale",         HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3088                         OPT_OUTPUT,                                  { .func_arg = opt_qscale },
3089         "use fixed quality scale (VBR)", "q" },
3090     { "profile",        HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
3091         "set profile", "profile" },
3092     { "filter",         HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
3093         "set stream filtergraph", "filter_graph" },
3094     { "filter_script",  HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
3095         "read stream filtergraph description from a file", "filename" },
3096     { "reinit_filter",  HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT,    { .off = OFFSET(reinit_filters) },
3097         "reinit filtergraph on input parameter changes", "" },
3098     { "filter_complex", HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_filter_complex },
3099         "create a complex filtergraph", "graph_description" },
3100     { "lavfi",          HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_filter_complex },
3101         "create a complex filtergraph", "graph_description" },
3102     { "filter_complex_script", HAS_ARG | OPT_EXPERT,                 { .func_arg = opt_filter_complex_script },
3103         "read complex filtergraph description from a file", "filename" },
3104     { "stats",          OPT_BOOL,                                    { &print_stats },
3105         "print progress report during encoding", },
3106     { "attach",         HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3107                         OPT_OUTPUT,                                  { .func_arg = opt_attach },
3108         "add an attachment to the output file", "filename" },
3109     { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
3110                          OPT_EXPERT | OPT_INPUT,                     { .off = OFFSET(dump_attachment) },
3111         "extract an attachment into a file", "filename" },
3112     { "debug_ts",       OPT_BOOL | OPT_EXPERT,                       { &debug_ts },
3113         "print timestamp debugging info" },
3114     { "max_error_rate",  HAS_ARG | OPT_FLOAT,                        { &max_error_rate },
3115         "maximum error rate", "ratio of errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success." },
3116     { "discard",        OPT_STRING | HAS_ARG | OPT_SPEC |
3117                         OPT_INPUT,                                   { .off = OFFSET(discard) },
3118         "discard", "" },
3119     { "disposition",    OPT_STRING | HAS_ARG | OPT_SPEC |
3120                         OPT_OUTPUT,                                  { .off = OFFSET(disposition) },
3121         "disposition", "" },
3122     { "thread_queue_size", HAS_ARG | OPT_INT | OPT_OFFSET | OPT_EXPERT | OPT_INPUT,
3123                                                                      { .off = OFFSET(thread_queue_size) },
3124         "set the maximum number of queued packets from the demuxer" },
3125
3126     /* video options */
3127     { "vframes",      OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_video_frames },
3128         "set the number of video frames to output", "number" },
3129     { "r",            OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC |
3130                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_rates) },
3131         "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3132     { "s",            OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC |
3133                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_sizes) },
3134         "set frame size (WxH or abbreviation)", "size" },
3135     { "aspect",       OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC |
3136                       OPT_OUTPUT,                                                { .off = OFFSET(frame_aspect_ratios) },
3137         "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3138     { "pix_fmt",      OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
3139                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_pix_fmts) },
3140         "set pixel format", "format" },
3141     { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG,                      { &frame_bits_per_raw_sample },
3142         "set the number of bits per raw sample", "number" },
3143     { "intra",        OPT_VIDEO | OPT_BOOL | OPT_EXPERT,                         { &intra_only },
3144         "deprecated use -g 1" },
3145     { "vn",           OPT_VIDEO | OPT_BOOL  | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) },
3146         "disable video" },
3147     { "rc_override",  OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
3148                       OPT_OUTPUT,                                                { .off = OFFSET(rc_overrides) },
3149         "rate control override for specific intervals", "override" },
3150     { "vcodec",       OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_INPUT |
3151                       OPT_OUTPUT,                                                { .func_arg = opt_video_codec },
3152         "force video codec ('copy' to copy stream)", "codec" },
3153     { "sameq",        OPT_VIDEO | OPT_EXPERT ,                                   { .func_arg = opt_sameq },
3154         "Removed" },
3155     { "same_quant",   OPT_VIDEO | OPT_EXPERT ,                                   { .func_arg = opt_sameq },
3156         "Removed" },
3157     { "timecode",     OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT,            { .func_arg = opt_timecode },
3158         "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
3159     { "pass",         OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT,     { .off = OFFSET(pass) },
3160         "select the pass number (1 to 3)", "n" },
3161     { "passlogfile",  OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
3162                       OPT_OUTPUT,                                                { .off = OFFSET(passlogfiles) },
3163         "select two pass log file name prefix", "prefix" },
3164     { "deinterlace",  OPT_VIDEO | OPT_BOOL | OPT_EXPERT,                         { &do_deinterlace },
3165         "this option is deprecated, use the yadif filter instead" },
3166     { "psnr",         OPT_VIDEO | OPT_BOOL | OPT_EXPERT,                         { &do_psnr },
3167         "calculate PSNR of compressed frames" },
3168     { "vstats",       OPT_VIDEO | OPT_EXPERT ,                                   { &opt_vstats },
3169         "dump video coding statistics to file" },
3170     { "vstats_file",  OPT_VIDEO | HAS_ARG | OPT_EXPERT ,                         { opt_vstats_file },
3171         "dump video coding statistics to file", "file" },
3172     { "vf",           OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_video_filters },
3173         "set video filters", "filter_graph" },
3174     { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
3175                       OPT_OUTPUT,                                                { .off = OFFSET(intra_matrices) },
3176         "specify intra matrix coeffs", "matrix" },
3177     { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
3178                       OPT_OUTPUT,                                                { .off = OFFSET(inter_matrices) },
3179         "specify inter matrix coeffs", "matrix" },
3180     { "chroma_intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
3181                       OPT_OUTPUT,                                                { .off = OFFSET(chroma_intra_matrices) },
3182         "specify intra matrix coeffs", "matrix" },
3183     { "top",          OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_INT| OPT_SPEC |
3184                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(top_field_first) },
3185         "top=1/bottom=0/auto=-1 field first", "" },
3186     { "vtag",         OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_PERFILE |
3187                       OPT_INPUT | OPT_OUTPUT,                                    { .func_arg = opt_old2new },
3188         "force video tag/fourcc", "fourcc/tag" },
3189     { "qphist",       OPT_VIDEO | OPT_BOOL | OPT_EXPERT ,                        { &qp_hist },
3190         "show QP histogram" },
3191     { "force_fps",    OPT_VIDEO | OPT_BOOL | OPT_EXPERT  | OPT_SPEC |
3192                       OPT_OUTPUT,                                                { .off = OFFSET(force_fps) },
3193         "force the selected framerate, disable the best supported framerate selection" },
3194     { "streamid",     OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3195                       OPT_OUTPUT,                                                { .func_arg = opt_streamid },
3196         "set the value of an outfile streamid", "streamIndex:value" },
3197     { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3198                           OPT_SPEC | OPT_OUTPUT,                                 { .off = OFFSET(forced_key_frames) },
3199         "force key frames at specified timestamps", "timestamps" },
3200     { "ab",           OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT,            { .func_arg = opt_bitrate },
3201         "audio bitrate (please use -b:a)", "bitrate" },
3202     { "b",            OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT,            { .func_arg = opt_bitrate },
3203         "video bitrate (please use -b:v)", "bitrate" },
3204     { "hwaccel",          OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3205                           OPT_SPEC | OPT_INPUT,                                  { .off = OFFSET(hwaccels) },
3206         "use HW accelerated decoding", "hwaccel name" },
3207     { "hwaccel_device",   OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3208                           OPT_SPEC | OPT_INPUT,                                  { .off = OFFSET(hwaccel_devices) },
3209         "select a device for HW acceleration" "devicename" },
3210 #if HAVE_VDPAU_X11
3211     { "vdpau_api_ver", HAS_ARG | OPT_INT | OPT_EXPERT, { &vdpau_api_ver }, "" },
3212 #endif
3213     { "autorotate",       HAS_ARG | OPT_BOOL | OPT_SPEC |
3214                           OPT_EXPERT | OPT_INPUT,                                { .off = OFFSET(autorotate) },
3215         "automatically insert correct rotate filters" },
3216
3217     /* audio options */
3218     { "aframes",        OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_frames },
3219         "set the number of audio frames to output", "number" },
3220     { "aq",             OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_qscale },
3221         "set audio quality (codec-specific)", "quality", },
3222     { "ar",             OPT_AUDIO | HAS_ARG  | OPT_INT | OPT_SPEC |
3223                         OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(audio_sample_rate) },
3224         "set audio sampling rate (in Hz)", "rate" },
3225     { "ac",             OPT_AUDIO | HAS_ARG  | OPT_INT | OPT_SPEC |
3226                         OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(audio_channels) },
3227         "set number of audio channels", "channels" },
3228     { "an",             OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) },
3229         "disable audio" },
3230     { "acodec",         OPT_AUDIO | HAS_ARG  | OPT_PERFILE |
3231                         OPT_INPUT | OPT_OUTPUT,                                    { .func_arg = opt_audio_codec },
3232         "force audio codec ('copy' to copy stream)", "codec" },
3233     { "atag",           OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_PERFILE |
3234                         OPT_OUTPUT,                                                { .func_arg = opt_old2new },
3235         "force audio tag/fourcc", "fourcc/tag" },
3236     { "vol",            OPT_AUDIO | HAS_ARG  | OPT_INT,                            { &audio_volume },
3237         "change audio volume (256=normal)" , "volume" },
3238     { "sample_fmt",     OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_SPEC |
3239                         OPT_STRING | OPT_INPUT | OPT_OUTPUT,                       { .off = OFFSET(sample_fmts) },
3240         "set sample format", "format" },
3241     { "channel_layout", OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_PERFILE |
3242                         OPT_INPUT | OPT_OUTPUT,                                    { .func_arg = opt_channel_layout },
3243         "set channel layout", "layout" },
3244     { "af",             OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_filters },
3245         "set audio filters", "filter_graph" },
3246     { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
3247       "set the maximum number of channels to try to guess the channel layout" },
3248
3249     /* subtitle options */
3250     { "sn",     OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
3251         "disable subtitle" },
3252     { "scodec", OPT_SUBTITLE | HAS_ARG  | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
3253         "force subtitle codec ('copy' to copy stream)", "codec" },
3254     { "stag",   OPT_SUBTITLE | HAS_ARG  | OPT_EXPERT  | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
3255         , "force subtitle tag/fourcc", "fourcc/tag" },
3256     { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
3257         "fix subtitles duration" },
3258     { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
3259         "set canvas size (WxH or abbreviation)", "size" },
3260
3261     /* grab options */
3262     { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
3263         "deprecated, use -channel", "channel" },
3264     { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
3265         "deprecated, use -standard", "standard" },
3266     { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
3267
3268     /* muxer options */
3269     { "muxdelay",   OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
3270         "set the maximum demux-decode delay", "seconds" },
3271     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
3272         "set the initial demux-decode delay", "seconds" },
3273     { "override_ffserver", OPT_BOOL | OPT_EXPERT | OPT_OUTPUT, { &override_ffserver },
3274         "override the options from ffserver", "" },
3275     { "sdp_file", HAS_ARG | OPT_EXPERT | OPT_OUTPUT, { opt_sdp_file },
3276         "specify a file in which to print sdp information", "file" },
3277
3278     { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
3279         "A comma-separated list of bitstream filters", "bitstream_filters" },
3280     { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3281         "deprecated", "audio bitstream_filters" },
3282     { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3283         "deprecated", "video bitstream_filters" },
3284
3285     { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT,    { .func_arg = opt_preset },
3286         "set the audio options to the indicated preset", "preset" },
3287     { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT,    { .func_arg = opt_preset },
3288         "set the video options to the indicated preset", "preset" },
3289     { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3290         "set the subtitle options to the indicated preset", "preset" },
3291     { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT,                { .func_arg = opt_preset },
3292         "set options from indicated preset file", "filename" },
3293     /* data codec support */
3294     { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
3295         "force data codec ('copy' to copy stream)", "codec" },
3296     { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },
3297         "disable data" },
3298
3299     { NULL, },
3300 };