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