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