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