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