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