Merge commit 'cc29d96d5a379dbcf2649947d884c202c2a52767'
[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         if (arg)
1259             if (!(bsfc->args = av_strdup(arg))) {
1260                 av_log(NULL, AV_LOG_FATAL, "Bitstream filter memory allocation failed\n");
1261                 exit_program(1);
1262             }
1263
1264         bsfc_prev = bsfc;
1265         bsf       = next;
1266     }
1267
1268     MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1269     if (codec_tag) {
1270         uint32_t tag = strtol(codec_tag, &next, 0);
1271         if (*next)
1272             tag = AV_RL32(codec_tag);
1273         ost->st->codec->codec_tag =
1274         ost->enc_ctx->codec_tag = tag;
1275     }
1276
1277     MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1278     if (qscale >= 0) {
1279         ost->enc_ctx->flags |= AV_CODEC_FLAG_QSCALE;
1280         ost->enc_ctx->global_quality = FF_QP2LAMBDA * qscale;
1281     }
1282
1283     MATCH_PER_STREAM_OPT(disposition, str, ost->disposition, oc, st);
1284     ost->disposition = av_strdup(ost->disposition);
1285
1286     if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1287         ost->enc_ctx->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
1288
1289     av_dict_copy(&ost->sws_dict, o->g->sws_dict, 0);
1290
1291     av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0);
1292     if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24)
1293         av_dict_set(&ost->swr_opts, "output_sample_bits", "24", 0);
1294
1295     av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1296
1297     ost->source_index = source_index;
1298     if (source_index >= 0) {
1299         ost->sync_ist = input_streams[source_index];
1300         input_streams[source_index]->discard = 0;
1301         input_streams[source_index]->st->discard = input_streams[source_index]->user_set_discard;
1302     }
1303     ost->last_mux_dts = AV_NOPTS_VALUE;
1304
1305     return ost;
1306 }
1307
1308 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1309 {
1310     int i;
1311     const char *p = str;
1312     for (i = 0;; i++) {
1313         dest[i] = atoi(p);
1314         if (i == 63)
1315             break;
1316         p = strchr(p, ',');
1317         if (!p) {
1318             av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1319             exit_program(1);
1320         }
1321         p++;
1322     }
1323 }
1324
1325 /* read file contents into a string */
1326 static uint8_t *read_file(const char *filename)
1327 {
1328     AVIOContext *pb      = NULL;
1329     AVIOContext *dyn_buf = NULL;
1330     int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1331     uint8_t buf[1024], *str;
1332
1333     if (ret < 0) {
1334         av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1335         return NULL;
1336     }
1337
1338     ret = avio_open_dyn_buf(&dyn_buf);
1339     if (ret < 0) {
1340         avio_closep(&pb);
1341         return NULL;
1342     }
1343     while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1344         avio_write(dyn_buf, buf, ret);
1345     avio_w8(dyn_buf, 0);
1346     avio_closep(&pb);
1347
1348     ret = avio_close_dyn_buf(dyn_buf, &str);
1349     if (ret < 0)
1350         return NULL;
1351     return str;
1352 }
1353
1354 static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
1355                              OutputStream *ost)
1356 {
1357     AVStream *st = ost->st;
1358
1359     if (ost->filters_script && ost->filters) {
1360         av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1361                "output stream #%d:%d.\n", nb_output_files, st->index);
1362         exit_program(1);
1363     }
1364
1365     if (ost->filters_script)
1366         return read_file(ost->filters_script);
1367     else if (ost->filters)
1368         return av_strdup(ost->filters);
1369
1370     return av_strdup(st->codec->codec_type == AVMEDIA_TYPE_VIDEO ?
1371                      "null" : "anull");
1372 }
1373
1374 static void check_streamcopy_filters(OptionsContext *o, AVFormatContext *oc,
1375                                      const OutputStream *ost, enum AVMediaType type)
1376 {
1377     if (ost->filters_script || ost->filters) {
1378         av_log(NULL, AV_LOG_ERROR,
1379                "%s '%s' was defined for %s output stream %d:%d but codec copy was selected.\n"
1380                "Filtering and streamcopy cannot be used together.\n",
1381                ost->filters ? "Filtergraph" : "Filtergraph script",
1382                ost->filters ? ost->filters : ost->filters_script,
1383                av_get_media_type_string(type), ost->file_index, ost->index);
1384         exit_program(1);
1385     }
1386 }
1387
1388 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1389 {
1390     AVStream *st;
1391     OutputStream *ost;
1392     AVCodecContext *video_enc;
1393     char *frame_rate = NULL, *frame_aspect_ratio = NULL;
1394
1395     ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1396     st  = ost->st;
1397     video_enc = ost->enc_ctx;
1398
1399     MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1400     if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1401         av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1402         exit_program(1);
1403     }
1404     if (frame_rate && video_sync_method == VSYNC_PASSTHROUGH)
1405         av_log(NULL, AV_LOG_ERROR, "Using -vsync 0 and -r can produce invalid output files\n");
1406
1407     MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1408     if (frame_aspect_ratio) {
1409         AVRational q;
1410         if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1411             q.num <= 0 || q.den <= 0) {
1412             av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1413             exit_program(1);
1414         }
1415         ost->frame_aspect_ratio = q;
1416     }
1417
1418     MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1419     MATCH_PER_STREAM_OPT(filters,        str, ost->filters,        oc, st);
1420
1421     if (!ost->stream_copy) {
1422         const char *p = NULL;
1423         char *frame_size = NULL;
1424         char *frame_pix_fmt = NULL;
1425         char *intra_matrix = NULL, *inter_matrix = NULL;
1426         char *chroma_intra_matrix = NULL;
1427         int do_pass = 0;
1428         int i;
1429
1430         MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1431         if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1432             av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1433             exit_program(1);
1434         }
1435
1436         video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1437         MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1438         if (frame_pix_fmt && *frame_pix_fmt == '+') {
1439             ost->keep_pix_fmt = 1;
1440             if (!*++frame_pix_fmt)
1441                 frame_pix_fmt = NULL;
1442         }
1443         if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1444             av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1445             exit_program(1);
1446         }
1447         st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1448
1449         if (intra_only)
1450             video_enc->gop_size = 0;
1451         MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1452         if (intra_matrix) {
1453             if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1454                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1455                 exit_program(1);
1456             }
1457             parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1458         }
1459         MATCH_PER_STREAM_OPT(chroma_intra_matrices, str, chroma_intra_matrix, oc, st);
1460         if (chroma_intra_matrix) {
1461             uint16_t *p = av_mallocz(sizeof(*video_enc->chroma_intra_matrix) * 64);
1462             if (!p) {
1463                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1464                 exit_program(1);
1465             }
1466             av_codec_set_chroma_intra_matrix(video_enc, p);
1467             parse_matrix_coeffs(p, chroma_intra_matrix);
1468         }
1469         MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1470         if (inter_matrix) {
1471             if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1472                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1473                 exit_program(1);
1474             }
1475             parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1476         }
1477
1478         MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1479         for (i = 0; p; i++) {
1480             int start, end, q;
1481             int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1482             if (e != 3) {
1483                 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1484                 exit_program(1);
1485             }
1486             video_enc->rc_override =
1487                 av_realloc_array(video_enc->rc_override,
1488                                  i + 1, sizeof(RcOverride));
1489             if (!video_enc->rc_override) {
1490                 av_log(NULL, AV_LOG_FATAL, "Could not (re)allocate memory for rc_override.\n");
1491                 exit_program(1);
1492             }
1493             video_enc->rc_override[i].start_frame = start;
1494             video_enc->rc_override[i].end_frame   = end;
1495             if (q > 0) {
1496                 video_enc->rc_override[i].qscale         = q;
1497                 video_enc->rc_override[i].quality_factor = 1.0;
1498             }
1499             else {
1500                 video_enc->rc_override[i].qscale         = 0;
1501                 video_enc->rc_override[i].quality_factor = -q/100.0;
1502             }
1503             p = strchr(p, '/');
1504             if (p) p++;
1505         }
1506         video_enc->rc_override_count = i;
1507
1508         if (do_psnr)
1509             video_enc->flags|= AV_CODEC_FLAG_PSNR;
1510
1511         /* two pass mode */
1512         MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1513         if (do_pass) {
1514             if (do_pass & 1) {
1515                 video_enc->flags |= AV_CODEC_FLAG_PASS1;
1516                 av_dict_set(&ost->encoder_opts, "flags", "+pass1", AV_DICT_APPEND);
1517             }
1518             if (do_pass & 2) {
1519                 video_enc->flags |= AV_CODEC_FLAG_PASS2;
1520                 av_dict_set(&ost->encoder_opts, "flags", "+pass2", AV_DICT_APPEND);
1521             }
1522         }
1523
1524         MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1525         if (ost->logfile_prefix &&
1526             !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1527             exit_program(1);
1528
1529         if (do_pass) {
1530             char logfilename[1024];
1531             FILE *f;
1532
1533             snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1534                      ost->logfile_prefix ? ost->logfile_prefix :
1535                                            DEFAULT_PASS_LOGFILENAME_PREFIX,
1536                      i);
1537             if (!strcmp(ost->enc->name, "libx264")) {
1538                 av_dict_set(&ost->encoder_opts, "stats", logfilename, AV_DICT_DONT_OVERWRITE);
1539             } else {
1540                 if (video_enc->flags & AV_CODEC_FLAG_PASS2) {
1541                     char  *logbuffer = read_file(logfilename);
1542
1543                     if (!logbuffer) {
1544                         av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
1545                                logfilename);
1546                         exit_program(1);
1547                     }
1548                     video_enc->stats_in = logbuffer;
1549                 }
1550                 if (video_enc->flags & AV_CODEC_FLAG_PASS1) {
1551                     f = av_fopen_utf8(logfilename, "wb");
1552                     if (!f) {
1553                         av_log(NULL, AV_LOG_FATAL,
1554                                "Cannot write log file '%s' for pass-1 encoding: %s\n",
1555                                logfilename, strerror(errno));
1556                         exit_program(1);
1557                     }
1558                     ost->logfile = f;
1559                 }
1560             }
1561         }
1562
1563         MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1564         if (ost->forced_keyframes)
1565             ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1566
1567         MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1568
1569         ost->top_field_first = -1;
1570         MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1571
1572
1573         ost->avfilter = get_ost_filters(o, oc, ost);
1574         if (!ost->avfilter)
1575             exit_program(1);
1576     } else {
1577         MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1578     }
1579
1580     if (ost->stream_copy)
1581         check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_VIDEO);
1582
1583     return ost;
1584 }
1585
1586 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1587 {
1588     int n;
1589     AVStream *st;
1590     OutputStream *ost;
1591     AVCodecContext *audio_enc;
1592
1593     ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1594     st  = ost->st;
1595
1596     audio_enc = ost->enc_ctx;
1597     audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1598
1599     MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1600     MATCH_PER_STREAM_OPT(filters,        str, ost->filters,        oc, st);
1601
1602     if (!ost->stream_copy) {
1603         char *sample_fmt = NULL;
1604
1605         MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1606
1607         MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1608         if (sample_fmt &&
1609             (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1610             av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1611             exit_program(1);
1612         }
1613
1614         MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1615
1616         MATCH_PER_STREAM_OPT(apad, str, ost->apad, oc, st);
1617         ost->apad = av_strdup(ost->apad);
1618
1619         ost->avfilter = get_ost_filters(o, oc, ost);
1620         if (!ost->avfilter)
1621             exit_program(1);
1622
1623         /* check for channel mapping for this audio stream */
1624         for (n = 0; n < o->nb_audio_channel_maps; n++) {
1625             AudioChannelMap *map = &o->audio_channel_maps[n];
1626             if ((map->ofile_idx   == -1 || ost->file_index == map->ofile_idx) &&
1627                 (map->ostream_idx == -1 || ost->st->index  == map->ostream_idx)) {
1628                 InputStream *ist;
1629
1630                 if (map->channel_idx == -1) {
1631                     ist = NULL;
1632                 } else if (ost->source_index < 0) {
1633                     av_log(NULL, AV_LOG_FATAL, "Cannot determine input stream for channel mapping %d.%d\n",
1634                            ost->file_index, ost->st->index);
1635                     continue;
1636                 } else {
1637                     ist = input_streams[ost->source_index];
1638                 }
1639
1640                 if (!ist || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) {
1641                     if (av_reallocp_array(&ost->audio_channels_map,
1642                                           ost->audio_channels_mapped + 1,
1643                                           sizeof(*ost->audio_channels_map)
1644                                           ) < 0 )
1645                         exit_program(1);
1646
1647                     ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1648                 }
1649             }
1650         }
1651     }
1652
1653     if (ost->stream_copy)
1654         check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_AUDIO);
1655
1656     return ost;
1657 }
1658
1659 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1660 {
1661     OutputStream *ost;
1662
1663     ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1664     if (!ost->stream_copy) {
1665         av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1666         exit_program(1);
1667     }
1668
1669     return ost;
1670 }
1671
1672 static OutputStream *new_unknown_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1673 {
1674     OutputStream *ost;
1675
1676     ost = new_output_stream(o, oc, AVMEDIA_TYPE_UNKNOWN, source_index);
1677     if (!ost->stream_copy) {
1678         av_log(NULL, AV_LOG_FATAL, "Unknown stream encoding not supported yet (only streamcopy)\n");
1679         exit_program(1);
1680     }
1681
1682     return ost;
1683 }
1684
1685 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1686 {
1687     OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1688     ost->stream_copy = 1;
1689     ost->finished    = 1;
1690     return ost;
1691 }
1692
1693 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1694 {
1695     AVStream *st;
1696     OutputStream *ost;
1697     AVCodecContext *subtitle_enc;
1698
1699     ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1700     st  = ost->st;
1701     subtitle_enc = ost->enc_ctx;
1702
1703     subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1704
1705     MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1706
1707     if (!ost->stream_copy) {
1708         char *frame_size = NULL;
1709
1710         MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1711         if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1712             av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1713             exit_program(1);
1714         }
1715     }
1716
1717     return ost;
1718 }
1719
1720 /* arg format is "output-stream-index:streamid-value". */
1721 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1722 {
1723     OptionsContext *o = optctx;
1724     int idx;
1725     char *p;
1726     char idx_str[16];
1727
1728     av_strlcpy(idx_str, arg, sizeof(idx_str));
1729     p = strchr(idx_str, ':');
1730     if (!p) {
1731         av_log(NULL, AV_LOG_FATAL,
1732                "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1733                arg, opt);
1734         exit_program(1);
1735     }
1736     *p++ = '\0';
1737     idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1738     o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1739     o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1740     return 0;
1741 }
1742
1743 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1744 {
1745     AVFormatContext *is = ifile->ctx;
1746     AVFormatContext *os = ofile->ctx;
1747     AVChapter **tmp;
1748     int i;
1749
1750     tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1751     if (!tmp)
1752         return AVERROR(ENOMEM);
1753     os->chapters = tmp;
1754
1755     for (i = 0; i < is->nb_chapters; i++) {
1756         AVChapter *in_ch = is->chapters[i], *out_ch;
1757         int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
1758         int64_t ts_off   = av_rescale_q(start_time - ifile->ts_offset,
1759                                        AV_TIME_BASE_Q, in_ch->time_base);
1760         int64_t rt       = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1761                            av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1762
1763
1764         if (in_ch->end < ts_off)
1765             continue;
1766         if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1767             break;
1768
1769         out_ch = av_mallocz(sizeof(AVChapter));
1770         if (!out_ch)
1771             return AVERROR(ENOMEM);
1772
1773         out_ch->id        = in_ch->id;
1774         out_ch->time_base = in_ch->time_base;
1775         out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
1776         out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
1777
1778         if (copy_metadata)
1779             av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1780
1781         os->chapters[os->nb_chapters++] = out_ch;
1782     }
1783     return 0;
1784 }
1785
1786 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
1787 {
1788     int i, err;
1789     AVFormatContext *ic = avformat_alloc_context();
1790
1791     ic->interrupt_callback = int_cb;
1792     err = avformat_open_input(&ic, filename, NULL, NULL);
1793     if (err < 0)
1794         return err;
1795     /* copy stream format */
1796     for(i=0;i<ic->nb_streams;i++) {
1797         AVStream *st;
1798         OutputStream *ost;
1799         AVCodec *codec;
1800         const char *enc_config;
1801
1802         codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
1803         if (!codec) {
1804             av_log(s, AV_LOG_ERROR, "no encoder found for codec id %i\n", ic->streams[i]->codec->codec_id);
1805             return AVERROR(EINVAL);
1806         }
1807         if (codec->type == AVMEDIA_TYPE_AUDIO)
1808             opt_audio_codec(o, "c:a", codec->name);
1809         else if (codec->type == AVMEDIA_TYPE_VIDEO)
1810             opt_video_codec(o, "c:v", codec->name);
1811         ost   = new_output_stream(o, s, codec->type, -1);
1812         st    = ost->st;
1813
1814         avcodec_get_context_defaults3(st->codec, codec);
1815         enc_config = av_stream_get_recommended_encoder_configuration(ic->streams[i]);
1816         if (enc_config) {
1817             AVDictionary *opts = NULL;
1818             av_dict_parse_string(&opts, enc_config, "=", ",", 0);
1819             av_opt_set_dict2(st->codec, &opts, AV_OPT_SEARCH_CHILDREN);
1820             av_dict_free(&opts);
1821         }
1822
1823         if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
1824             choose_sample_fmt(st, codec);
1825         else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
1826             choose_pixel_fmt(st, st->codec, codec, st->codec->pix_fmt);
1827         avcodec_copy_context(ost->enc_ctx, st->codec);
1828         if (enc_config)
1829             av_dict_parse_string(&ost->encoder_opts, enc_config, "=", ",", 0);
1830     }
1831
1832     avformat_close_input(&ic);
1833     return err;
1834 }
1835
1836 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1837                                AVFormatContext *oc)
1838 {
1839     OutputStream *ost;
1840
1841     switch (ofilter->type) {
1842     case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
1843     case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
1844     default:
1845         av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1846                "currently.\n");
1847         exit_program(1);
1848     }
1849
1850     ost->source_index = -1;
1851     ost->filter       = ofilter;
1852
1853     ofilter->ost      = ost;
1854
1855     if (ost->stream_copy) {
1856         av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1857                "which is fed from a complex filtergraph. Filtering and streamcopy "
1858                "cannot be used together.\n", ost->file_index, ost->index);
1859         exit_program(1);
1860     }
1861
1862     if (ost->avfilter && (ost->filters || ost->filters_script)) {
1863         const char *opt = ost->filters ? "-vf/-af/-filter" : "-filter_script";
1864         av_log(NULL, AV_LOG_ERROR,
1865                "%s '%s' was specified through the %s option "
1866                "for output stream %d:%d, which is fed from a complex filtergraph.\n"
1867                "%s and -filter_complex cannot be used together for the same stream.\n",
1868                ost->filters ? "Filtergraph" : "Filtergraph script",
1869                ost->filters ? ost->filters : ost->filters_script,
1870                opt, ost->file_index, ost->index, opt);
1871         exit_program(1);
1872     }
1873
1874     avfilter_inout_free(&ofilter->out_tmp);
1875 }
1876
1877 static int init_complex_filters(void)
1878 {
1879     int i, ret = 0;
1880
1881     for (i = 0; i < nb_filtergraphs; i++) {
1882         ret = init_complex_filtergraph(filtergraphs[i]);
1883         if (ret < 0)
1884             return ret;
1885     }
1886     return 0;
1887 }
1888
1889 static int configure_complex_filters(void)
1890 {
1891     int i, ret = 0;
1892
1893     for (i = 0; i < nb_filtergraphs; i++)
1894         if (!filtergraphs[i]->graph &&
1895             (ret = configure_filtergraph(filtergraphs[i])) < 0)
1896             return ret;
1897     return 0;
1898 }
1899
1900 static int open_output_file(OptionsContext *o, const char *filename)
1901 {
1902     AVFormatContext *oc;
1903     int i, j, err;
1904     AVOutputFormat *file_oformat;
1905     OutputFile *of;
1906     OutputStream *ost;
1907     InputStream  *ist;
1908     AVDictionary *unused_opts = NULL;
1909     AVDictionaryEntry *e = NULL;
1910
1911
1912     if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
1913         o->stop_time = INT64_MAX;
1914         av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
1915     }
1916
1917     if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
1918         int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
1919         if (o->stop_time <= start_time) {
1920             av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
1921             exit_program(1);
1922         } else {
1923             o->recording_time = o->stop_time - start_time;
1924         }
1925     }
1926
1927     GROW_ARRAY(output_files, nb_output_files);
1928     of = av_mallocz(sizeof(*of));
1929     if (!of)
1930         exit_program(1);
1931     output_files[nb_output_files - 1] = of;
1932
1933     of->ost_index      = nb_output_streams;
1934     of->recording_time = o->recording_time;
1935     of->start_time     = o->start_time;
1936     of->limit_filesize = o->limit_filesize;
1937     of->shortest       = o->shortest;
1938     av_dict_copy(&of->opts, o->g->format_opts, 0);
1939
1940     if (!strcmp(filename, "-"))
1941         filename = "pipe:";
1942
1943     err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
1944     if (!oc) {
1945         print_error(filename, err);
1946         exit_program(1);
1947     }
1948
1949     of->ctx = oc;
1950     if (o->recording_time != INT64_MAX)
1951         oc->duration = o->recording_time;
1952
1953     file_oformat= oc->oformat;
1954     oc->interrupt_callback = int_cb;
1955
1956     /* create streams for all unlabeled output pads */
1957     for (i = 0; i < nb_filtergraphs; i++) {
1958         FilterGraph *fg = filtergraphs[i];
1959         for (j = 0; j < fg->nb_outputs; j++) {
1960             OutputFilter *ofilter = fg->outputs[j];
1961
1962             if (!ofilter->out_tmp || ofilter->out_tmp->name)
1963                 continue;
1964
1965             switch (ofilter->type) {
1966             case AVMEDIA_TYPE_VIDEO:    o->video_disable    = 1; break;
1967             case AVMEDIA_TYPE_AUDIO:    o->audio_disable    = 1; break;
1968             case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1969             }
1970             init_output_filter(ofilter, o, oc);
1971         }
1972     }
1973
1974     /* ffserver seeking with date=... needs a date reference */
1975     if (!strcmp(file_oformat->name, "ffm") &&
1976         av_strstart(filename, "http:", NULL)) {
1977         int err = parse_option(o, "metadata", "creation_time=now", options);
1978         if (err < 0) {
1979             print_error(filename, err);
1980             exit_program(1);
1981         }
1982     }
1983
1984     if (!strcmp(file_oformat->name, "ffm") && !override_ffserver &&
1985         av_strstart(filename, "http:", NULL)) {
1986         int j;
1987         /* special case for files sent to ffserver: we get the stream
1988            parameters from ffserver */
1989         int err = read_ffserver_streams(o, oc, filename);
1990         if (err < 0) {
1991             print_error(filename, err);
1992             exit_program(1);
1993         }
1994         for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
1995             ost = output_streams[j];
1996             for (i = 0; i < nb_input_streams; i++) {
1997                 ist = input_streams[i];
1998                 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
1999                     ost->sync_ist= ist;
2000                     ost->source_index= i;
2001                     if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
2002                     if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
2003                     ist->discard = 0;
2004                     ist->st->discard = ist->user_set_discard;
2005                     break;
2006                 }
2007             }
2008             if(!ost->sync_ist){
2009                 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));
2010                 exit_program(1);
2011             }
2012         }
2013     } else if (!o->nb_stream_maps) {
2014         char *subtitle_codec_name = NULL;
2015         /* pick the "best" stream of each type */
2016
2017         /* video: highest resolution */
2018         if (!o->video_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_VIDEO) != AV_CODEC_ID_NONE) {
2019             int area = 0, idx = -1;
2020             int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
2021             for (i = 0; i < nb_input_streams; i++) {
2022                 int new_area;
2023                 ist = input_streams[i];
2024                 new_area = ist->st->codec->width * ist->st->codec->height + 100000000*!!ist->st->codec_info_nb_frames;
2025                 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2026                     new_area = 1;
2027                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
2028                     new_area > area) {
2029                     if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2030                         continue;
2031                     area = new_area;
2032                     idx = i;
2033                 }
2034             }
2035             if (idx >= 0)
2036                 new_video_stream(o, oc, idx);
2037         }
2038
2039         /* audio: most channels */
2040         if (!o->audio_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_AUDIO) != AV_CODEC_ID_NONE) {
2041             int best_score = 0, idx = -1;
2042             for (i = 0; i < nb_input_streams; i++) {
2043                 int score;
2044                 ist = input_streams[i];
2045                 score = ist->st->codec->channels + 100000000*!!ist->st->codec_info_nb_frames;
2046                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
2047                     score > best_score) {
2048                     best_score = score;
2049                     idx = i;
2050                 }
2051             }
2052             if (idx >= 0)
2053                 new_audio_stream(o, oc, idx);
2054         }
2055
2056         /* subtitles: pick first */
2057         MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
2058         if (!o->subtitle_disable && (avcodec_find_encoder(oc->oformat->subtitle_codec) || subtitle_codec_name)) {
2059             for (i = 0; i < nb_input_streams; i++)
2060                 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2061                     AVCodecDescriptor const *input_descriptor =
2062                         avcodec_descriptor_get(input_streams[i]->st->codec->codec_id);
2063                     AVCodecDescriptor const *output_descriptor = NULL;
2064                     AVCodec const *output_codec =
2065                         avcodec_find_encoder(oc->oformat->subtitle_codec);
2066                     int input_props = 0, output_props = 0;
2067                     if (output_codec)
2068                         output_descriptor = avcodec_descriptor_get(output_codec->id);
2069                     if (input_descriptor)
2070                         input_props = input_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2071                     if (output_descriptor)
2072                         output_props = output_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2073                     if (subtitle_codec_name ||
2074                         input_props & output_props ||
2075                         // Map dvb teletext which has neither property to any output subtitle encoder
2076                         input_descriptor && output_descriptor &&
2077                         (!input_descriptor->props ||
2078                          !output_descriptor->props)) {
2079                         new_subtitle_stream(o, oc, i);
2080                         break;
2081                     }
2082                 }
2083         }
2084         /* Data only if codec id match */
2085         if (!o->data_disable ) {
2086             enum AVCodecID codec_id = av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_DATA);
2087             for (i = 0; codec_id != AV_CODEC_ID_NONE && i < nb_input_streams; i++) {
2088                 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_DATA
2089                     && input_streams[i]->st->codec->codec_id == codec_id )
2090                     new_data_stream(o, oc, i);
2091             }
2092         }
2093     } else {
2094         for (i = 0; i < o->nb_stream_maps; i++) {
2095             StreamMap *map = &o->stream_maps[i];
2096
2097             if (map->disabled)
2098                 continue;
2099
2100             if (map->linklabel) {
2101                 FilterGraph *fg;
2102                 OutputFilter *ofilter = NULL;
2103                 int j, k;
2104
2105                 for (j = 0; j < nb_filtergraphs; j++) {
2106                     fg = filtergraphs[j];
2107                     for (k = 0; k < fg->nb_outputs; k++) {
2108                         AVFilterInOut *out = fg->outputs[k]->out_tmp;
2109                         if (out && !strcmp(out->name, map->linklabel)) {
2110                             ofilter = fg->outputs[k];
2111                             goto loop_end;
2112                         }
2113                     }
2114                 }
2115 loop_end:
2116                 if (!ofilter) {
2117                     av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
2118                            "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
2119                     exit_program(1);
2120                 }
2121                 init_output_filter(ofilter, o, oc);
2122             } else {
2123                 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
2124
2125                 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
2126                 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
2127                     continue;
2128                 if(o->   audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
2129                     continue;
2130                 if(o->   video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2131                     continue;
2132                 if(o->    data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
2133                     continue;
2134
2135                 ost = NULL;
2136                 switch (ist->st->codec->codec_type) {
2137                 case AVMEDIA_TYPE_VIDEO:      ost = new_video_stream     (o, oc, src_idx); break;
2138                 case AVMEDIA_TYPE_AUDIO:      ost = new_audio_stream     (o, oc, src_idx); break;
2139                 case AVMEDIA_TYPE_SUBTITLE:   ost = new_subtitle_stream  (o, oc, src_idx); break;
2140                 case AVMEDIA_TYPE_DATA:       ost = new_data_stream      (o, oc, src_idx); break;
2141                 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
2142                 case AVMEDIA_TYPE_UNKNOWN:
2143                     if (copy_unknown_streams) {
2144                         ost = new_unknown_stream   (o, oc, src_idx);
2145                         break;
2146                     }
2147                 default:
2148                     av_log(NULL, ignore_unknown_streams ? AV_LOG_WARNING : AV_LOG_FATAL,
2149                            "Cannot map stream #%d:%d - unsupported type.\n",
2150                            map->file_index, map->stream_index);
2151                     if (!ignore_unknown_streams) {
2152                         av_log(NULL, AV_LOG_FATAL,
2153                                "If you want unsupported types ignored instead "
2154                                "of failing, please use the -ignore_unknown option\n"
2155                                "If you want them copied, please use -copy_unknown\n");
2156                         exit_program(1);
2157                     }
2158                 }
2159                 if (ost)
2160                     ost->sync_ist = input_streams[  input_files[map->sync_file_index]->ist_index
2161                                                   + map->sync_stream_index];
2162             }
2163         }
2164     }
2165
2166     /* handle attached files */
2167     for (i = 0; i < o->nb_attachments; i++) {
2168         AVIOContext *pb;
2169         uint8_t *attachment;
2170         const char *p;
2171         int64_t len;
2172
2173         if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
2174             av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
2175                    o->attachments[i]);
2176             exit_program(1);
2177         }
2178         if ((len = avio_size(pb)) <= 0) {
2179             av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
2180                    o->attachments[i]);
2181             exit_program(1);
2182         }
2183         if (!(attachment = av_malloc(len))) {
2184             av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
2185                    o->attachments[i]);
2186             exit_program(1);
2187         }
2188         avio_read(pb, attachment, len);
2189
2190         ost = new_attachment_stream(o, oc, -1);
2191         ost->stream_copy               = 1;
2192         ost->attachment_filename       = o->attachments[i];
2193         ost->finished                  = 1;
2194         ost->st->codec->extradata      = attachment;
2195         ost->st->codec->extradata_size = len;
2196
2197         p = strrchr(o->attachments[i], '/');
2198         av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
2199         avio_closep(&pb);
2200     }
2201
2202     for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
2203         AVDictionaryEntry *e;
2204         ost = output_streams[i];
2205
2206         if ((ost->stream_copy || ost->attachment_filename)
2207             && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
2208             && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
2209             if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
2210                 exit_program(1);
2211     }
2212
2213     if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
2214         av_dump_format(oc, nb_output_files - 1, oc->filename, 1);
2215         av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", nb_output_files - 1);
2216         exit_program(1);
2217     }
2218
2219     /* check if all codec options have been used */
2220     unused_opts = strip_specifiers(o->g->codec_opts);
2221     for (i = of->ost_index; i < nb_output_streams; i++) {
2222         e = NULL;
2223         while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
2224                                 AV_DICT_IGNORE_SUFFIX)))
2225             av_dict_set(&unused_opts, e->key, NULL, 0);
2226     }
2227
2228     e = NULL;
2229     while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
2230         const AVClass *class = avcodec_get_class();
2231         const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
2232                                              AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2233         const AVClass *fclass = avformat_get_class();
2234         const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
2235                                               AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2236         if (!option || foption)
2237             continue;
2238
2239
2240         if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
2241             av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
2242                    "output file #%d (%s) is not an encoding option.\n", e->key,
2243                    option->help ? option->help : "", nb_output_files - 1,
2244                    filename);
2245             exit_program(1);
2246         }
2247
2248         // gop_timecode is injected by generic code but not always used
2249         if (!strcmp(e->key, "gop_timecode"))
2250             continue;
2251
2252         av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
2253                "output file #%d (%s) has not been used for any stream. The most "
2254                "likely reason is either wrong type (e.g. a video option with "
2255                "no video streams) or that it is a private option of some encoder "
2256                "which was not actually used for any stream.\n", e->key,
2257                option->help ? option->help : "", nb_output_files - 1, filename);
2258     }
2259     av_dict_free(&unused_opts);
2260
2261     /* set the encoding/decoding_needed flags */
2262     for (i = of->ost_index; i < nb_output_streams; i++) {
2263         OutputStream *ost = output_streams[i];
2264
2265         ost->encoding_needed = !ost->stream_copy;
2266         if (ost->encoding_needed && ost->source_index >= 0) {
2267             InputStream *ist = input_streams[ost->source_index];
2268             ist->decoding_needed |= DECODING_FOR_OST;
2269         }
2270     }
2271
2272     /* check filename in case of an image number is expected */
2273     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
2274         if (!av_filename_number_test(oc->filename)) {
2275             print_error(oc->filename, AVERROR(EINVAL));
2276             exit_program(1);
2277         }
2278     }
2279
2280     if (!(oc->oformat->flags & AVFMT_NOSTREAMS) && !input_stream_potentially_available) {
2281         av_log(NULL, AV_LOG_ERROR,
2282                "No input streams but output needs an input stream\n");
2283         exit_program(1);
2284     }
2285
2286     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
2287         /* test if it already exists to avoid losing precious files */
2288         assert_file_overwrite(filename);
2289
2290         /* open the file */
2291         if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
2292                               &oc->interrupt_callback,
2293                               &of->opts)) < 0) {
2294             print_error(filename, err);
2295             exit_program(1);
2296         }
2297     } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
2298         assert_file_overwrite(filename);
2299
2300     if (o->mux_preload) {
2301         av_dict_set_int(&of->opts, "preload", o->mux_preload*AV_TIME_BASE, 0);
2302     }
2303     oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
2304
2305     /* copy metadata */
2306     for (i = 0; i < o->nb_metadata_map; i++) {
2307         char *p;
2308         int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
2309
2310         if (in_file_index >= nb_input_files) {
2311             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
2312             exit_program(1);
2313         }
2314         copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
2315                       in_file_index >= 0 ?
2316                       input_files[in_file_index]->ctx : NULL, o);
2317     }
2318
2319     /* copy chapters */
2320     if (o->chapters_input_file >= nb_input_files) {
2321         if (o->chapters_input_file == INT_MAX) {
2322             /* copy chapters from the first input file that has them*/
2323             o->chapters_input_file = -1;
2324             for (i = 0; i < nb_input_files; i++)
2325                 if (input_files[i]->ctx->nb_chapters) {
2326                     o->chapters_input_file = i;
2327                     break;
2328                 }
2329         } else {
2330             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
2331                    o->chapters_input_file);
2332             exit_program(1);
2333         }
2334     }
2335     if (o->chapters_input_file >= 0)
2336         copy_chapters(input_files[o->chapters_input_file], of,
2337                       !o->metadata_chapters_manual);
2338
2339     /* copy global metadata by default */
2340     if (!o->metadata_global_manual && nb_input_files){
2341         av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
2342                      AV_DICT_DONT_OVERWRITE);
2343         if(o->recording_time != INT64_MAX)
2344             av_dict_set(&oc->metadata, "duration", NULL, 0);
2345         av_dict_set(&oc->metadata, "creation_time", NULL, 0);
2346     }
2347     if (!o->metadata_streams_manual)
2348         for (i = of->ost_index; i < nb_output_streams; i++) {
2349             InputStream *ist;
2350             if (output_streams[i]->source_index < 0)         /* this is true e.g. for attached files */
2351                 continue;
2352             ist = input_streams[output_streams[i]->source_index];
2353             av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
2354             if (!output_streams[i]->stream_copy) {
2355                 av_dict_set(&output_streams[i]->st->metadata, "encoder", NULL, 0);
2356                 if (ist->autorotate)
2357                     av_dict_set(&output_streams[i]->st->metadata, "rotate", NULL, 0);
2358             }
2359         }
2360
2361     /* process manually set metadata */
2362     for (i = 0; i < o->nb_metadata; i++) {
2363         AVDictionary **m;
2364         char type, *val;
2365         const char *stream_spec;
2366         int index = 0, j, ret = 0;
2367         char now_time[256];
2368
2369         val = strchr(o->metadata[i].u.str, '=');
2370         if (!val) {
2371             av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
2372                    o->metadata[i].u.str);
2373             exit_program(1);
2374         }
2375         *val++ = 0;
2376
2377         if (!strcmp(o->metadata[i].u.str, "creation_time") &&
2378             !strcmp(val, "now")) {
2379             time_t now = time(0);
2380             struct tm *ptm, tmbuf;
2381             ptm = localtime_r(&now, &tmbuf);
2382             if (ptm) {
2383                 if (strftime(now_time, sizeof(now_time), "%Y-%m-%d %H:%M:%S", ptm))
2384                     val = now_time;
2385             }
2386         }
2387
2388         parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
2389         if (type == 's') {
2390             for (j = 0; j < oc->nb_streams; j++) {
2391                 ost = output_streams[nb_output_streams - oc->nb_streams + j];
2392                 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2393                     av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2394                     if (!strcmp(o->metadata[i].u.str, "rotate")) {
2395                         ost->rotate_overridden = 1;
2396                     }
2397                 } else if (ret < 0)
2398                     exit_program(1);
2399             }
2400         }
2401         else {
2402             switch (type) {
2403             case 'g':
2404                 m = &oc->metadata;
2405                 break;
2406             case 'c':
2407                 if (index < 0 || index >= oc->nb_chapters) {
2408                     av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2409                     exit_program(1);
2410                 }
2411                 m = &oc->chapters[index]->metadata;
2412                 break;
2413             default:
2414                 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2415                 exit_program(1);
2416             }
2417             av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2418         }
2419     }
2420
2421     /* process manually set programs */
2422     for (i = 0; i < o->nb_program; i++) {
2423         const char *p = o->program[i].u.str;
2424         int progid = i+1;
2425         AVProgram *program;
2426
2427         while(*p) {
2428             const char *p2 = av_get_token(&p, ":");
2429             char *key;
2430             if (!p2)
2431                 break;
2432             if(*p) p++;
2433
2434             key = av_get_token(&p2, "=");
2435             if (!key || !*p2)
2436                 break;
2437             p2++;
2438
2439             if (!strcmp(key, "program_num"))
2440                 progid = strtol(p2, NULL, 0);
2441         }
2442
2443         program = av_new_program(oc, progid);
2444
2445         p = o->program[i].u.str;
2446         while(*p) {
2447             const char *p2 = av_get_token(&p, ":");
2448             char *key;
2449             if (!p2)
2450                 break;
2451             if(*p) p++;
2452
2453             key = av_get_token(&p2, "=");
2454             if (!key) {
2455                 av_log(NULL, AV_LOG_FATAL,
2456                        "No '=' character in program string %s.\n",
2457                        p2);
2458                 exit_program(1);
2459             }
2460             if (!*p2)
2461                 exit_program(1);
2462             p2++;
2463
2464             if (!strcmp(key, "title")) {
2465                 av_dict_set(&program->metadata, "title", p2, 0);
2466             } else if (!strcmp(key, "program_num")) {
2467             } else if (!strcmp(key, "st")) {
2468                 int st_num = strtol(p2, NULL, 0);
2469                 av_program_add_stream_index(oc, progid, st_num);
2470             } else {
2471                 av_log(NULL, AV_LOG_FATAL, "Unknown program key %s.\n", key);
2472                 exit_program(1);
2473             }
2474         }
2475     }
2476
2477     return 0;
2478 }
2479
2480 static int opt_target(void *optctx, const char *opt, const char *arg)
2481 {
2482     OptionsContext *o = optctx;
2483     enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2484     static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2485
2486     if (!strncmp(arg, "pal-", 4)) {
2487         norm = PAL;
2488         arg += 4;
2489     } else if (!strncmp(arg, "ntsc-", 5)) {
2490         norm = NTSC;
2491         arg += 5;
2492     } else if (!strncmp(arg, "film-", 5)) {
2493         norm = FILM;
2494         arg += 5;
2495     } else {
2496         /* Try to determine PAL/NTSC by peeking in the input files */
2497         if (nb_input_files) {
2498             int i, j, fr;
2499             for (j = 0; j < nb_input_files; j++) {
2500                 for (i = 0; i < input_files[j]->nb_streams; i++) {
2501                     AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
2502                     if (c->codec_type != AVMEDIA_TYPE_VIDEO ||
2503                         !c->time_base.num)
2504                         continue;
2505                     fr = c->time_base.den * 1000 / c->time_base.num;
2506                     if (fr == 25000) {
2507                         norm = PAL;
2508                         break;
2509                     } else if ((fr == 29970) || (fr == 23976)) {
2510                         norm = NTSC;
2511                         break;
2512                     }
2513                 }
2514                 if (norm != UNKNOWN)
2515                     break;
2516             }
2517         }
2518         if (norm != UNKNOWN)
2519             av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2520     }
2521
2522     if (norm == UNKNOWN) {
2523         av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2524         av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2525         av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2526         exit_program(1);
2527     }
2528
2529     if (!strcmp(arg, "vcd")) {
2530         opt_video_codec(o, "c:v", "mpeg1video");
2531         opt_audio_codec(o, "c:a", "mp2");
2532         parse_option(o, "f", "vcd", options);
2533
2534         parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2535         parse_option(o, "r", frame_rates[norm], options);
2536         opt_default(NULL, "g", norm == PAL ? "15" : "18");
2537
2538         opt_default(NULL, "b:v", "1150000");
2539         opt_default(NULL, "maxrate:v", "1150000");
2540         opt_default(NULL, "minrate:v", "1150000");
2541         opt_default(NULL, "bufsize:v", "327680"); // 40*1024*8;
2542
2543         opt_default(NULL, "b:a", "224000");
2544         parse_option(o, "ar", "44100", options);
2545         parse_option(o, "ac", "2", options);
2546
2547         opt_default(NULL, "packetsize", "2324");
2548         opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
2549
2550         /* We have to offset the PTS, so that it is consistent with the SCR.
2551            SCR starts at 36000, but the first two packs contain only padding
2552            and the first pack from the other stream, respectively, may also have
2553            been written before.
2554            So the real data starts at SCR 36000+3*1200. */
2555         o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2556     } else if (!strcmp(arg, "svcd")) {
2557
2558         opt_video_codec(o, "c:v", "mpeg2video");
2559         opt_audio_codec(o, "c:a", "mp2");
2560         parse_option(o, "f", "svcd", options);
2561
2562         parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2563         parse_option(o, "r", frame_rates[norm], options);
2564         parse_option(o, "pix_fmt", "yuv420p", options);
2565         opt_default(NULL, "g", norm == PAL ? "15" : "18");
2566
2567         opt_default(NULL, "b:v", "2040000");
2568         opt_default(NULL, "maxrate:v", "2516000");
2569         opt_default(NULL, "minrate:v", "0"); // 1145000;
2570         opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2571         opt_default(NULL, "scan_offset", "1");
2572
2573         opt_default(NULL, "b:a", "224000");
2574         parse_option(o, "ar", "44100", options);
2575
2576         opt_default(NULL, "packetsize", "2324");
2577
2578     } else if (!strcmp(arg, "dvd")) {
2579
2580         opt_video_codec(o, "c:v", "mpeg2video");
2581         opt_audio_codec(o, "c:a", "ac3");
2582         parse_option(o, "f", "dvd", options);
2583
2584         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2585         parse_option(o, "r", frame_rates[norm], options);
2586         parse_option(o, "pix_fmt", "yuv420p", options);
2587         opt_default(NULL, "g", norm == PAL ? "15" : "18");
2588
2589         opt_default(NULL, "b:v", "6000000");
2590         opt_default(NULL, "maxrate:v", "9000000");
2591         opt_default(NULL, "minrate:v", "0"); // 1500000;
2592         opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2593
2594         opt_default(NULL, "packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
2595         opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2596
2597         opt_default(NULL, "b:a", "448000");
2598         parse_option(o, "ar", "48000", options);
2599
2600     } else if (!strncmp(arg, "dv", 2)) {
2601
2602         parse_option(o, "f", "dv", options);
2603
2604         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2605         parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2606                           norm == PAL ? "yuv420p" : "yuv411p", options);
2607         parse_option(o, "r", frame_rates[norm], options);
2608
2609         parse_option(o, "ar", "48000", options);
2610         parse_option(o, "ac", "2", options);
2611
2612     } else {
2613         av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2614         return AVERROR(EINVAL);
2615     }
2616
2617     av_dict_copy(&o->g->codec_opts,  codec_opts, AV_DICT_DONT_OVERWRITE);
2618     av_dict_copy(&o->g->format_opts, format_opts, AV_DICT_DONT_OVERWRITE);
2619
2620     return 0;
2621 }
2622
2623 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2624 {
2625     av_free (vstats_filename);
2626     vstats_filename = av_strdup (arg);
2627     return 0;
2628 }
2629
2630 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2631 {
2632     char filename[40];
2633     time_t today2 = time(NULL);
2634     struct tm *today = localtime(&today2);
2635
2636     if (!today) { // maybe tomorrow
2637         av_log(NULL, AV_LOG_FATAL, "Unable to get current time: %s\n", strerror(errno));
2638         exit_program(1);
2639     }
2640
2641     snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2642              today->tm_sec);
2643     return opt_vstats_file(NULL, opt, filename);
2644 }
2645
2646 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2647 {
2648     OptionsContext *o = optctx;
2649     return parse_option(o, "frames:v", arg, options);
2650 }
2651
2652 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2653 {
2654     OptionsContext *o = optctx;
2655     return parse_option(o, "frames:a", arg, options);
2656 }
2657
2658 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2659 {
2660     OptionsContext *o = optctx;
2661     return parse_option(o, "frames:d", arg, options);
2662 }
2663
2664 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2665 {
2666     int ret;
2667     AVDictionary *cbak = codec_opts;
2668     AVDictionary *fbak = format_opts;
2669     codec_opts = NULL;
2670     format_opts = NULL;
2671
2672     ret = opt_default(NULL, opt, arg);
2673
2674     av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2675     av_dict_copy(&o->g->format_opts, format_opts, 0);
2676     av_dict_free(&codec_opts);
2677     av_dict_free(&format_opts);
2678     codec_opts = cbak;
2679     format_opts = fbak;
2680
2681     return ret;
2682 }
2683
2684 static int opt_preset(void *optctx, const char *opt, const char *arg)
2685 {
2686     OptionsContext *o = optctx;
2687     FILE *f=NULL;
2688     char filename[1000], line[1000], tmp_line[1000];
2689     const char *codec_name = NULL;
2690
2691     tmp_line[0] = *opt;
2692     tmp_line[1] = 0;
2693     MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2694
2695     if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2696         if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2697             av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2698         }else
2699             av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2700         exit_program(1);
2701     }
2702
2703     while (fgets(line, sizeof(line), f)) {
2704         char *key = tmp_line, *value, *endptr;
2705
2706         if (strcspn(line, "#\n\r") == 0)
2707             continue;
2708         av_strlcpy(tmp_line, line, sizeof(tmp_line));
2709         if (!av_strtok(key,   "=",    &value) ||
2710             !av_strtok(value, "\r\n", &endptr)) {
2711             av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2712             exit_program(1);
2713         }
2714         av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2715
2716         if      (!strcmp(key, "acodec")) opt_audio_codec   (o, key, value);
2717         else if (!strcmp(key, "vcodec")) opt_video_codec   (o, key, value);
2718         else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2719         else if (!strcmp(key, "dcodec")) opt_data_codec    (o, key, value);
2720         else if (opt_default_new(o, key, value) < 0) {
2721             av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2722                    filename, line, key, value);
2723             exit_program(1);
2724         }
2725     }
2726
2727     fclose(f);
2728
2729     return 0;
2730 }
2731
2732 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2733 {
2734     OptionsContext *o = optctx;
2735     char *s = av_asprintf("%s:%c", opt + 1, *opt);
2736     int ret = parse_option(o, s, arg, options);
2737     av_free(s);
2738     return ret;
2739 }
2740
2741 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2742 {
2743     OptionsContext *o = optctx;
2744
2745     if(!strcmp(opt, "ab")){
2746         av_dict_set(&o->g->codec_opts, "b:a", arg, 0);
2747         return 0;
2748     } else if(!strcmp(opt, "b")){
2749         av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2750         av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2751         return 0;
2752     }
2753     av_dict_set(&o->g->codec_opts, opt, arg, 0);
2754     return 0;
2755 }
2756
2757 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2758 {
2759     OptionsContext *o = optctx;
2760     char *s;
2761     int ret;
2762     if(!strcmp(opt, "qscale")){
2763         av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2764         return parse_option(o, "q:v", arg, options);
2765     }
2766     s = av_asprintf("q%s", opt + 6);
2767     ret = parse_option(o, s, arg, options);
2768     av_free(s);
2769     return ret;
2770 }
2771
2772 static int opt_profile(void *optctx, const char *opt, const char *arg)
2773 {
2774     OptionsContext *o = optctx;
2775     if(!strcmp(opt, "profile")){
2776         av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2777         av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
2778         return 0;
2779     }
2780     av_dict_set(&o->g->codec_opts, opt, arg, 0);
2781     return 0;
2782 }
2783
2784 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2785 {
2786     OptionsContext *o = optctx;
2787     return parse_option(o, "filter:v", arg, options);
2788 }
2789
2790 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2791 {
2792     OptionsContext *o = optctx;
2793     return parse_option(o, "filter:a", arg, options);
2794 }
2795
2796 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2797 {
2798     if      (!av_strcasecmp(arg, "cfr"))         video_sync_method = VSYNC_CFR;
2799     else if (!av_strcasecmp(arg, "vfr"))         video_sync_method = VSYNC_VFR;
2800     else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2801     else if (!av_strcasecmp(arg, "drop"))        video_sync_method = VSYNC_DROP;
2802
2803     if (video_sync_method == VSYNC_AUTO)
2804         video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
2805     return 0;
2806 }
2807
2808 static int opt_timecode(void *optctx, const char *opt, const char *arg)
2809 {
2810     OptionsContext *o = optctx;
2811     char *tcr = av_asprintf("timecode=%s", arg);
2812     int ret = parse_option(o, "metadata:g", tcr, options);
2813     if (ret >= 0)
2814         ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
2815     av_free(tcr);
2816     return 0;
2817 }
2818
2819 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2820 {
2821     OptionsContext *o = optctx;
2822     char layout_str[32];
2823     char *stream_str;
2824     char *ac_str;
2825     int ret, channels, ac_str_size;
2826     uint64_t layout;
2827
2828     layout = av_get_channel_layout(arg);
2829     if (!layout) {
2830         av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2831         return AVERROR(EINVAL);
2832     }
2833     snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2834     ret = opt_default_new(o, opt, layout_str);
2835     if (ret < 0)
2836         return ret;
2837
2838     /* set 'ac' option based on channel layout */
2839     channels = av_get_channel_layout_nb_channels(layout);
2840     snprintf(layout_str, sizeof(layout_str), "%d", channels);
2841     stream_str = strchr(opt, ':');
2842     ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2843     ac_str = av_mallocz(ac_str_size);
2844     if (!ac_str)
2845         return AVERROR(ENOMEM);
2846     av_strlcpy(ac_str, "ac", 3);
2847     if (stream_str)
2848         av_strlcat(ac_str, stream_str, ac_str_size);
2849     ret = parse_option(o, ac_str, layout_str, options);
2850     av_free(ac_str);
2851
2852     return ret;
2853 }
2854
2855 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2856 {
2857     OptionsContext *o = optctx;
2858     return parse_option(o, "q:a", arg, options);
2859 }
2860
2861 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2862 {
2863     GROW_ARRAY(filtergraphs, nb_filtergraphs);
2864     if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2865         return AVERROR(ENOMEM);
2866     filtergraphs[nb_filtergraphs - 1]->index      = nb_filtergraphs - 1;
2867     filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
2868     if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
2869         return AVERROR(ENOMEM);
2870
2871     input_stream_potentially_available = 1;
2872
2873     return 0;
2874 }
2875
2876 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
2877 {
2878     uint8_t *graph_desc = read_file(arg);
2879     if (!graph_desc)
2880         return AVERROR(EINVAL);
2881
2882     GROW_ARRAY(filtergraphs, nb_filtergraphs);
2883     if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2884         return AVERROR(ENOMEM);
2885     filtergraphs[nb_filtergraphs - 1]->index      = nb_filtergraphs - 1;
2886     filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
2887
2888     input_stream_potentially_available = 1;
2889
2890     return 0;
2891 }
2892
2893 void show_help_default(const char *opt, const char *arg)
2894 {
2895     /* per-file options have at least one of those set */
2896     const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2897     int show_advanced = 0, show_avoptions = 0;
2898
2899     if (opt && *opt) {
2900         if (!strcmp(opt, "long"))
2901             show_advanced = 1;
2902         else if (!strcmp(opt, "full"))
2903             show_advanced = show_avoptions = 1;
2904         else
2905             av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2906     }
2907
2908     show_usage();
2909
2910     printf("Getting help:\n"
2911            "    -h      -- print basic options\n"
2912            "    -h long -- print more options\n"
2913            "    -h full -- print all options (including all format and codec specific options, very long)\n"
2914            "    -h type=name -- print all options for the named decoder/encoder/demuxer/muxer/filter\n"
2915            "    See man %s for detailed description of the options.\n"
2916            "\n", program_name);
2917
2918     show_help_options(options, "Print help / information / capabilities:",
2919                       OPT_EXIT, 0, 0);
2920
2921     show_help_options(options, "Global options (affect whole program "
2922                       "instead of just one file:",
2923                       0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2924     if (show_advanced)
2925         show_help_options(options, "Advanced global options:", OPT_EXPERT,
2926                           per_file | OPT_EXIT, 0);
2927
2928     show_help_options(options, "Per-file main options:", 0,
2929                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
2930                       OPT_EXIT, per_file);
2931     if (show_advanced)
2932         show_help_options(options, "Advanced per-file options:",
2933                           OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2934
2935     show_help_options(options, "Video options:",
2936                       OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
2937     if (show_advanced)
2938         show_help_options(options, "Advanced Video options:",
2939                           OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2940
2941     show_help_options(options, "Audio options:",
2942                       OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2943     if (show_advanced)
2944         show_help_options(options, "Advanced Audio options:",
2945                           OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2946     show_help_options(options, "Subtitle options:",
2947                       OPT_SUBTITLE, 0, 0);
2948     printf("\n");
2949
2950     if (show_avoptions) {
2951         int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2952         show_help_children(avcodec_get_class(), flags);
2953         show_help_children(avformat_get_class(), flags);
2954 #if CONFIG_SWSCALE
2955         show_help_children(sws_get_class(), flags);
2956 #endif
2957         show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
2958         show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM);
2959     }
2960 }
2961
2962 void show_usage(void)
2963 {
2964     av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
2965     av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2966     av_log(NULL, AV_LOG_INFO, "\n");
2967 }
2968
2969 enum OptGroup {
2970     GROUP_OUTFILE,
2971     GROUP_INFILE,
2972 };
2973
2974 static const OptionGroupDef groups[] = {
2975     [GROUP_OUTFILE] = { "output file",  NULL, OPT_OUTPUT },
2976     [GROUP_INFILE]  = { "input file",   "i",  OPT_INPUT },
2977 };
2978
2979 static int open_files(OptionGroupList *l, const char *inout,
2980                       int (*open_file)(OptionsContext*, const char*))
2981 {
2982     int i, ret;
2983
2984     for (i = 0; i < l->nb_groups; i++) {
2985         OptionGroup *g = &l->groups[i];
2986         OptionsContext o;
2987
2988         init_options(&o);
2989         o.g = g;
2990
2991         ret = parse_optgroup(&o, g);
2992         if (ret < 0) {
2993             av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
2994                    "%s.\n", inout, g->arg);
2995             return ret;
2996         }
2997
2998         av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
2999         ret = open_file(&o, g->arg);
3000         uninit_options(&o);
3001         if (ret < 0) {
3002             av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
3003                    inout, g->arg);
3004             return ret;
3005         }
3006         av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
3007     }
3008
3009     return 0;
3010 }
3011
3012 int ffmpeg_parse_options(int argc, char **argv)
3013 {
3014     OptionParseContext octx;
3015     uint8_t error[128];
3016     int ret;
3017
3018     memset(&octx, 0, sizeof(octx));
3019
3020     /* split the commandline into an internal representation */
3021     ret = split_commandline(&octx, argc, argv, options, groups,
3022                             FF_ARRAY_ELEMS(groups));
3023     if (ret < 0) {
3024         av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
3025         goto fail;
3026     }
3027
3028     /* apply global options */
3029     ret = parse_optgroup(NULL, &octx.global_opts);
3030     if (ret < 0) {
3031         av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
3032         goto fail;
3033     }
3034
3035     /* open input files */
3036     ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
3037     if (ret < 0) {
3038         av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
3039         goto fail;
3040     }
3041
3042     /* create the complex filtergraphs */
3043     ret = init_complex_filters();
3044     if (ret < 0) {
3045         av_log(NULL, AV_LOG_FATAL, "Error initializing complex filters.\n");
3046         goto fail;
3047     }
3048
3049     /* open output files */
3050     ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
3051     if (ret < 0) {
3052         av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
3053         goto fail;
3054     }
3055
3056     /* configure the complex filtergraphs */
3057     ret = configure_complex_filters();
3058     if (ret < 0) {
3059         av_log(NULL, AV_LOG_FATAL, "Error configuring complex filters.\n");
3060         goto fail;
3061     }
3062
3063 fail:
3064     uninit_parse_context(&octx);
3065     if (ret < 0) {
3066         av_strerror(ret, error, sizeof(error));
3067         av_log(NULL, AV_LOG_FATAL, "%s\n", error);
3068     }
3069     return ret;
3070 }
3071
3072 static int opt_progress(void *optctx, const char *opt, const char *arg)
3073 {
3074     AVIOContext *avio = NULL;
3075     int ret;
3076
3077     if (!strcmp(arg, "-"))
3078         arg = "pipe:";
3079     ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
3080     if (ret < 0) {
3081         av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
3082                arg, av_err2str(ret));
3083         return ret;
3084     }
3085     progress_avio = avio;
3086     return 0;
3087 }
3088
3089 #define OFFSET(x) offsetof(OptionsContext, x)
3090 const OptionDef options[] = {
3091     /* main options */
3092 #include "cmdutils_common_opts.h"
3093     { "f",              HAS_ARG | OPT_STRING | OPT_OFFSET |
3094                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(format) },
3095         "force format", "fmt" },
3096     { "y",              OPT_BOOL,                                    {              &file_overwrite },
3097         "overwrite output files" },
3098     { "n",              OPT_BOOL,                                    {              &no_file_overwrite },
3099         "never overwrite output files" },
3100     { "ignore_unknown", OPT_BOOL,                                    {              &ignore_unknown_streams },
3101         "Ignore unknown stream types" },
3102     { "copy_unknown",   OPT_BOOL | OPT_EXPERT,                       {              &copy_unknown_streams },
3103         "Copy unknown stream types" },
3104     { "c",              HAS_ARG | OPT_STRING | OPT_SPEC |
3105                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(codec_names) },
3106         "codec name", "codec" },
3107     { "codec",          HAS_ARG | OPT_STRING | OPT_SPEC |
3108                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(codec_names) },
3109         "codec name", "codec" },
3110     { "pre",            HAS_ARG | OPT_STRING | OPT_SPEC |
3111                         OPT_OUTPUT,                                  { .off       = OFFSET(presets) },
3112         "preset name", "preset" },
3113     { "map",            HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3114                         OPT_OUTPUT,                                  { .func_arg = opt_map },
3115         "set input stream mapping",
3116         "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
3117     { "map_channel",    HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
3118         "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
3119     { "map_metadata",   HAS_ARG | OPT_STRING | OPT_SPEC |
3120                         OPT_OUTPUT,                                  { .off       = OFFSET(metadata_map) },
3121         "set metadata information of outfile from infile",
3122         "outfile[,metadata]:infile[,metadata]" },
3123     { "map_chapters",   HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
3124                         OPT_OUTPUT,                                  { .off = OFFSET(chapters_input_file) },
3125         "set chapters mapping", "input_file_index" },
3126     { "t",              HAS_ARG | OPT_TIME | OPT_OFFSET |
3127                         OPT_INPUT | OPT_OUTPUT,                      { .off = OFFSET(recording_time) },
3128         "record or transcode \"duration\" seconds of audio/video",
3129         "duration" },
3130     { "to",             HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_OUTPUT,  { .off = OFFSET(stop_time) },
3131         "record or transcode stop time", "time_stop" },
3132     { "fs",             HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
3133         "set the limit file size in bytes", "limit_size" },
3134     { "ss",             HAS_ARG | OPT_TIME | OPT_OFFSET |
3135                         OPT_INPUT | OPT_OUTPUT,                      { .off = OFFSET(start_time) },
3136         "set the start time offset", "time_off" },
3137     { "sseof",          HAS_ARG | OPT_TIME | OPT_OFFSET |
3138                         OPT_INPUT | OPT_OUTPUT,                      { .off = OFFSET(start_time_eof) },
3139         "set the start time offset relative to EOF", "time_off" },
3140     { "seek_timestamp", HAS_ARG | OPT_INT | OPT_OFFSET |
3141                         OPT_INPUT,                                   { .off = OFFSET(seek_timestamp) },
3142         "enable/disable seeking by timestamp with -ss" },
3143     { "accurate_seek",  OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
3144                         OPT_INPUT,                                   { .off = OFFSET(accurate_seek) },
3145         "enable/disable accurate seeking with -ss" },
3146     { "itsoffset",      HAS_ARG | OPT_TIME | OPT_OFFSET |
3147                         OPT_EXPERT | OPT_INPUT,                      { .off = OFFSET(input_ts_offset) },
3148         "set the input ts offset", "time_off" },
3149     { "itsscale",       HAS_ARG | OPT_DOUBLE | OPT_SPEC |
3150                         OPT_EXPERT | OPT_INPUT,                      { .off = OFFSET(ts_scale) },
3151         "set the input ts scale", "scale" },
3152     { "timestamp",      HAS_ARG | OPT_PERFILE | OPT_OUTPUT,          { .func_arg = opt_recording_timestamp },
3153         "set the recording timestamp ('now' to set the current time)", "time" },
3154     { "metadata",       HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
3155         "add metadata", "string=string" },
3156     { "program",        HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(program) },
3157         "add program with specified streams", "title=string:st=number..." },
3158     { "dframes",        HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3159                         OPT_OUTPUT,                                  { .func_arg = opt_data_frames },
3160         "set the number of data frames to output", "number" },
3161     { "benchmark",      OPT_BOOL | OPT_EXPERT,                       { &do_benchmark },
3162         "add timings for benchmarking" },
3163     { "benchmark_all",  OPT_BOOL | OPT_EXPERT,                       { &do_benchmark_all },
3164       "add timings for each task" },
3165     { "progress",       HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_progress },
3166       "write program-readable progress information", "url" },
3167     { "stdin",          OPT_BOOL | OPT_EXPERT,                       { &stdin_interaction },
3168       "enable or disable interaction on standard input" },
3169     { "timelimit",      HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_timelimit },
3170         "set max runtime in seconds", "limit" },
3171     { "dump",           OPT_BOOL | OPT_EXPERT,                       { &do_pkt_dump },
3172         "dump each input packet" },
3173     { "hex",            OPT_BOOL | OPT_EXPERT,                       { &do_hex_dump },
3174         "when dumping packets, also dump the payload" },
3175     { "re",             OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3176                         OPT_INPUT,                                   { .off = OFFSET(rate_emu) },
3177         "read input at native frame rate", "" },
3178     { "target",         HAS_ARG | OPT_PERFILE | OPT_OUTPUT,          { .func_arg = opt_target },
3179         "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\" or \"dv50\" "
3180         "with optional prefixes \"pal-\", \"ntsc-\" or \"film-\")", "type" },
3181     { "vsync",          HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_vsync },
3182         "video sync method", "" },
3183     { "frame_drop_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,      { &frame_drop_threshold },
3184         "frame drop threshold", "" },
3185     { "async",          HAS_ARG | OPT_INT | OPT_EXPERT,              { &audio_sync_method },
3186         "audio sync method", "" },
3187     { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,          { &audio_drift_threshold },
3188         "audio drift threshold", "threshold" },
3189     { "copyts",         OPT_BOOL | OPT_EXPERT,                       { &copy_ts },
3190         "copy timestamps" },
3191     { "start_at_zero",  OPT_BOOL | OPT_EXPERT,                       { &start_at_zero },
3192         "shift input timestamps to start at 0 when using copyts" },
3193     { "copytb",         HAS_ARG | OPT_INT | OPT_EXPERT,              { &copy_tb },
3194         "copy input stream time base when stream copying", "mode" },
3195     { "shortest",       OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3196                         OPT_OUTPUT,                                  { .off = OFFSET(shortest) },
3197         "finish encoding within shortest input" },
3198     { "apad",           OPT_STRING | HAS_ARG | OPT_SPEC |
3199                         OPT_OUTPUT,                                  { .off = OFFSET(apad) },
3200         "audio pad", "" },
3201     { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,       { &dts_delta_threshold },
3202         "timestamp discontinuity delta threshold", "threshold" },
3203     { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,       { &dts_error_threshold },
3204         "timestamp error delta threshold", "threshold" },
3205     { "xerror",         OPT_BOOL | OPT_EXPERT,                       { &exit_on_error },
3206         "exit on error", "error" },
3207     { "abort_on",       HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_abort_on },
3208         "abort on the specified condition flags", "flags" },
3209     { "copyinkf",       OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3210                         OPT_OUTPUT,                                  { .off = OFFSET(copy_initial_nonkeyframes) },
3211         "copy initial non-keyframes" },
3212     { "copypriorss",    OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT,   { .off = OFFSET(copy_prior_start) },
3213         "copy or discard frames before start time" },
3214     { "frames",         OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
3215         "set the number of frames to output", "number" },
3216     { "tag",            OPT_STRING | HAS_ARG | OPT_SPEC |
3217                         OPT_EXPERT | OPT_OUTPUT | OPT_INPUT,         { .off = OFFSET(codec_tags) },
3218         "force codec tag/fourcc", "fourcc/tag" },
3219     { "q",              HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
3220                         OPT_SPEC | OPT_OUTPUT,                       { .off = OFFSET(qscale) },
3221         "use fixed quality scale (VBR)", "q" },
3222     { "qscale",         HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3223                         OPT_OUTPUT,                                  { .func_arg = opt_qscale },
3224         "use fixed quality scale (VBR)", "q" },
3225     { "profile",        HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
3226         "set profile", "profile" },
3227     { "filter",         HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
3228         "set stream filtergraph", "filter_graph" },
3229     { "filter_script",  HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
3230         "read stream filtergraph description from a file", "filename" },
3231     { "reinit_filter",  HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT,    { .off = OFFSET(reinit_filters) },
3232         "reinit filtergraph on input parameter changes", "" },
3233     { "filter_complex", HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_filter_complex },
3234         "create a complex filtergraph", "graph_description" },
3235     { "lavfi",          HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_filter_complex },
3236         "create a complex filtergraph", "graph_description" },
3237     { "filter_complex_script", HAS_ARG | OPT_EXPERT,                 { .func_arg = opt_filter_complex_script },
3238         "read complex filtergraph description from a file", "filename" },
3239     { "stats",          OPT_BOOL,                                    { &print_stats },
3240         "print progress report during encoding", },
3241     { "attach",         HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3242                         OPT_OUTPUT,                                  { .func_arg = opt_attach },
3243         "add an attachment to the output file", "filename" },
3244     { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
3245                          OPT_EXPERT | OPT_INPUT,                     { .off = OFFSET(dump_attachment) },
3246         "extract an attachment into a file", "filename" },
3247     { "stream_loop", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_INPUT |
3248                         OPT_OFFSET,                                  { .off = OFFSET(loop) }, "set number of times input stream shall be looped", "loop count" },
3249     { "debug_ts",       OPT_BOOL | OPT_EXPERT,                       { &debug_ts },
3250         "print timestamp debugging info" },
3251     { "max_error_rate",  HAS_ARG | OPT_FLOAT,                        { &max_error_rate },
3252         "maximum error rate", "ratio of errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success." },
3253     { "discard",        OPT_STRING | HAS_ARG | OPT_SPEC |
3254                         OPT_INPUT,                                   { .off = OFFSET(discard) },
3255         "discard", "" },
3256     { "disposition",    OPT_STRING | HAS_ARG | OPT_SPEC |
3257                         OPT_OUTPUT,                                  { .off = OFFSET(disposition) },
3258         "disposition", "" },
3259     { "thread_queue_size", HAS_ARG | OPT_INT | OPT_OFFSET | OPT_EXPERT | OPT_INPUT,
3260                                                                      { .off = OFFSET(thread_queue_size) },
3261         "set the maximum number of queued packets from the demuxer" },
3262
3263     /* video options */
3264     { "vframes",      OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_video_frames },
3265         "set the number of video frames to output", "number" },
3266     { "r",            OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC |
3267                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_rates) },
3268         "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3269     { "s",            OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC |
3270                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_sizes) },
3271         "set frame size (WxH or abbreviation)", "size" },
3272     { "aspect",       OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC |
3273                       OPT_OUTPUT,                                                { .off = OFFSET(frame_aspect_ratios) },
3274         "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3275     { "pix_fmt",      OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
3276                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_pix_fmts) },
3277         "set pixel format", "format" },
3278     { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG,                      { &frame_bits_per_raw_sample },
3279         "set the number of bits per raw sample", "number" },
3280     { "intra",        OPT_VIDEO | OPT_BOOL | OPT_EXPERT,                         { &intra_only },
3281         "deprecated use -g 1" },
3282     { "vn",           OPT_VIDEO | OPT_BOOL  | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) },
3283         "disable video" },
3284     { "rc_override",  OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
3285                       OPT_OUTPUT,                                                { .off = OFFSET(rc_overrides) },
3286         "rate control override for specific intervals", "override" },
3287     { "vcodec",       OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_INPUT |
3288                       OPT_OUTPUT,                                                { .func_arg = opt_video_codec },
3289         "force video codec ('copy' to copy stream)", "codec" },
3290     { "sameq",        OPT_VIDEO | OPT_EXPERT ,                                   { .func_arg = opt_sameq },
3291         "Removed" },
3292     { "same_quant",   OPT_VIDEO | OPT_EXPERT ,                                   { .func_arg = opt_sameq },
3293         "Removed" },
3294     { "timecode",     OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT,            { .func_arg = opt_timecode },
3295         "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
3296     { "pass",         OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT,     { .off = OFFSET(pass) },
3297         "select the pass number (1 to 3)", "n" },
3298     { "passlogfile",  OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
3299                       OPT_OUTPUT,                                                { .off = OFFSET(passlogfiles) },
3300         "select two pass log file name prefix", "prefix" },
3301     { "deinterlace",  OPT_VIDEO | OPT_BOOL | OPT_EXPERT,                         { &do_deinterlace },
3302         "this option is deprecated, use the yadif filter instead" },
3303     { "psnr",         OPT_VIDEO | OPT_BOOL | OPT_EXPERT,                         { &do_psnr },
3304         "calculate PSNR of compressed frames" },
3305     { "vstats",       OPT_VIDEO | OPT_EXPERT ,                                   { .func_arg = opt_vstats },
3306         "dump video coding statistics to file" },
3307     { "vstats_file",  OPT_VIDEO | HAS_ARG | OPT_EXPERT ,                         { .func_arg = opt_vstats_file },
3308         "dump video coding statistics to file", "file" },
3309     { "vf",           OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_video_filters },
3310         "set video filters", "filter_graph" },
3311     { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
3312                       OPT_OUTPUT,                                                { .off = OFFSET(intra_matrices) },
3313         "specify intra matrix coeffs", "matrix" },
3314     { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
3315                       OPT_OUTPUT,                                                { .off = OFFSET(inter_matrices) },
3316         "specify inter matrix coeffs", "matrix" },
3317     { "chroma_intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
3318                       OPT_OUTPUT,                                                { .off = OFFSET(chroma_intra_matrices) },
3319         "specify intra matrix coeffs", "matrix" },
3320     { "top",          OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_INT| OPT_SPEC |
3321                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(top_field_first) },
3322         "top=1/bottom=0/auto=-1 field first", "" },
3323     { "vtag",         OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_PERFILE |
3324                       OPT_INPUT | OPT_OUTPUT,                                    { .func_arg = opt_old2new },
3325         "force video tag/fourcc", "fourcc/tag" },
3326     { "qphist",       OPT_VIDEO | OPT_BOOL | OPT_EXPERT ,                        { &qp_hist },
3327         "show QP histogram" },
3328     { "force_fps",    OPT_VIDEO | OPT_BOOL | OPT_EXPERT  | OPT_SPEC |
3329                       OPT_OUTPUT,                                                { .off = OFFSET(force_fps) },
3330         "force the selected framerate, disable the best supported framerate selection" },
3331     { "streamid",     OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3332                       OPT_OUTPUT,                                                { .func_arg = opt_streamid },
3333         "set the value of an outfile streamid", "streamIndex:value" },
3334     { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3335                           OPT_SPEC | OPT_OUTPUT,                                 { .off = OFFSET(forced_key_frames) },
3336         "force key frames at specified timestamps", "timestamps" },
3337     { "ab",           OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT,            { .func_arg = opt_bitrate },
3338         "audio bitrate (please use -b:a)", "bitrate" },
3339     { "b",            OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT,            { .func_arg = opt_bitrate },
3340         "video bitrate (please use -b:v)", "bitrate" },
3341     { "hwaccel",          OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3342                           OPT_SPEC | OPT_INPUT,                                  { .off = OFFSET(hwaccels) },
3343         "use HW accelerated decoding", "hwaccel name" },
3344     { "hwaccel_device",   OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3345                           OPT_SPEC | OPT_INPUT,                                  { .off = OFFSET(hwaccel_devices) },
3346         "select a device for HW acceleration", "devicename" },
3347 #if HAVE_VDPAU_X11
3348     { "vdpau_api_ver", HAS_ARG | OPT_INT | OPT_EXPERT, { &vdpau_api_ver }, "" },
3349 #endif
3350 #if CONFIG_VDA || CONFIG_VIDEOTOOLBOX
3351     { "videotoolbox_pixfmt", HAS_ARG | OPT_STRING | OPT_EXPERT, { &videotoolbox_pixfmt}, "" },
3352 #endif
3353     { "hwaccels",         OPT_EXIT,                                              { .func_arg = show_hwaccels },
3354         "show available HW acceleration methods" },
3355     { "autorotate",       HAS_ARG | OPT_BOOL | OPT_SPEC |
3356                           OPT_EXPERT | OPT_INPUT,                                { .off = OFFSET(autorotate) },
3357         "automatically insert correct rotate filters" },
3358
3359     /* audio options */
3360     { "aframes",        OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_frames },
3361         "set the number of audio frames to output", "number" },
3362     { "aq",             OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_qscale },
3363         "set audio quality (codec-specific)", "quality", },
3364     { "ar",             OPT_AUDIO | HAS_ARG  | OPT_INT | OPT_SPEC |
3365                         OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(audio_sample_rate) },
3366         "set audio sampling rate (in Hz)", "rate" },
3367     { "ac",             OPT_AUDIO | HAS_ARG  | OPT_INT | OPT_SPEC |
3368                         OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(audio_channels) },
3369         "set number of audio channels", "channels" },
3370     { "an",             OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) },
3371         "disable audio" },
3372     { "acodec",         OPT_AUDIO | HAS_ARG  | OPT_PERFILE |
3373                         OPT_INPUT | OPT_OUTPUT,                                    { .func_arg = opt_audio_codec },
3374         "force audio codec ('copy' to copy stream)", "codec" },
3375     { "atag",           OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_PERFILE |
3376                         OPT_OUTPUT,                                                { .func_arg = opt_old2new },
3377         "force audio tag/fourcc", "fourcc/tag" },
3378     { "vol",            OPT_AUDIO | HAS_ARG  | OPT_INT,                            { &audio_volume },
3379         "change audio volume (256=normal)" , "volume" },
3380     { "sample_fmt",     OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_SPEC |
3381                         OPT_STRING | OPT_INPUT | OPT_OUTPUT,                       { .off = OFFSET(sample_fmts) },
3382         "set sample format", "format" },
3383     { "channel_layout", OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_PERFILE |
3384                         OPT_INPUT | OPT_OUTPUT,                                    { .func_arg = opt_channel_layout },
3385         "set channel layout", "layout" },
3386     { "af",             OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_filters },
3387         "set audio filters", "filter_graph" },
3388     { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
3389       "set the maximum number of channels to try to guess the channel layout" },
3390
3391     /* subtitle options */
3392     { "sn",     OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
3393         "disable subtitle" },
3394     { "scodec", OPT_SUBTITLE | HAS_ARG  | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
3395         "force subtitle codec ('copy' to copy stream)", "codec" },
3396     { "stag",   OPT_SUBTITLE | HAS_ARG  | OPT_EXPERT  | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
3397         , "force subtitle tag/fourcc", "fourcc/tag" },
3398     { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
3399         "fix subtitles duration" },
3400     { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
3401         "set canvas size (WxH or abbreviation)", "size" },
3402
3403     /* grab options */
3404     { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
3405         "deprecated, use -channel", "channel" },
3406     { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
3407         "deprecated, use -standard", "standard" },
3408     { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
3409
3410     /* muxer options */
3411     { "muxdelay",   OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
3412         "set the maximum demux-decode delay", "seconds" },
3413     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
3414         "set the initial demux-decode delay", "seconds" },
3415     { "override_ffserver", OPT_BOOL | OPT_EXPERT | OPT_OUTPUT, { &override_ffserver },
3416         "override the options from ffserver", "" },
3417     { "sdp_file", HAS_ARG | OPT_EXPERT | OPT_OUTPUT, { .func_arg = opt_sdp_file },
3418         "specify a file in which to print sdp information", "file" },
3419
3420     { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
3421         "A comma-separated list of bitstream filters", "bitstream_filters" },
3422     { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3423         "deprecated", "audio bitstream_filters" },
3424     { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3425         "deprecated", "video bitstream_filters" },
3426
3427     { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT,    { .func_arg = opt_preset },
3428         "set the audio options to the indicated preset", "preset" },
3429     { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT,    { .func_arg = opt_preset },
3430         "set the video options to the indicated preset", "preset" },
3431     { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3432         "set the subtitle options to the indicated preset", "preset" },
3433     { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT,                { .func_arg = opt_preset },
3434         "set options from indicated preset file", "filename" },
3435     /* data codec support */
3436     { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
3437         "force data codec ('copy' to copy stream)", "codec" },
3438     { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },
3439         "disable data" },
3440
3441     { NULL, },
3442 };