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