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