4fe78fa757ffd2821fbdc4b4528e2108deb673ec
[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->filename,
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     AVOutputFormat *file_oformat;
2058     OutputFile *of;
2059     OutputStream *ost;
2060     InputStream  *ist;
2061     AVDictionary *unused_opts = NULL;
2062     AVDictionaryEntry *e = NULL;
2063     int format_flags = 0;
2064
2065     if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
2066         o->stop_time = INT64_MAX;
2067         av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
2068     }
2069
2070     if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
2071         int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
2072         if (o->stop_time <= start_time) {
2073             av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
2074             exit_program(1);
2075         } else {
2076             o->recording_time = o->stop_time - start_time;
2077         }
2078     }
2079
2080     GROW_ARRAY(output_files, nb_output_files);
2081     of = av_mallocz(sizeof(*of));
2082     if (!of)
2083         exit_program(1);
2084     output_files[nb_output_files - 1] = of;
2085
2086     of->ost_index      = nb_output_streams;
2087     of->recording_time = o->recording_time;
2088     of->start_time     = o->start_time;
2089     of->limit_filesize = o->limit_filesize;
2090     of->shortest       = o->shortest;
2091     av_dict_copy(&of->opts, o->g->format_opts, 0);
2092
2093     if (!strcmp(filename, "-"))
2094         filename = "pipe:";
2095
2096     err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
2097     if (!oc) {
2098         print_error(filename, err);
2099         exit_program(1);
2100     }
2101
2102     of->ctx = oc;
2103     if (o->recording_time != INT64_MAX)
2104         oc->duration = o->recording_time;
2105
2106     file_oformat= oc->oformat;
2107     oc->interrupt_callback = int_cb;
2108
2109     e = av_dict_get(o->g->format_opts, "fflags", NULL, 0);
2110     if (e) {
2111         const AVOption *o = av_opt_find(oc, "fflags", NULL, 0, 0);
2112         av_opt_eval_flags(oc, o, e->value, &format_flags);
2113     }
2114     if (o->bitexact) {
2115         format_flags |= AVFMT_FLAG_BITEXACT;
2116         oc->flags    |= AVFMT_FLAG_BITEXACT;
2117     }
2118
2119     /* create streams for all unlabeled output pads */
2120     for (i = 0; i < nb_filtergraphs; i++) {
2121         FilterGraph *fg = filtergraphs[i];
2122         for (j = 0; j < fg->nb_outputs; j++) {
2123             OutputFilter *ofilter = fg->outputs[j];
2124
2125             if (!ofilter->out_tmp || ofilter->out_tmp->name)
2126                 continue;
2127
2128             switch (ofilter->type) {
2129             case AVMEDIA_TYPE_VIDEO:    o->video_disable    = 1; break;
2130             case AVMEDIA_TYPE_AUDIO:    o->audio_disable    = 1; break;
2131             case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
2132             }
2133             init_output_filter(ofilter, o, oc);
2134         }
2135     }
2136
2137     if (!o->nb_stream_maps) {
2138         char *subtitle_codec_name = NULL;
2139         /* pick the "best" stream of each type */
2140
2141         /* video: highest resolution */
2142         if (!o->video_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_VIDEO) != AV_CODEC_ID_NONE) {
2143             int area = 0, idx = -1;
2144             int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
2145             for (i = 0; i < nb_input_streams; i++) {
2146                 int new_area;
2147                 ist = input_streams[i];
2148                 new_area = ist->st->codecpar->width * ist->st->codecpar->height + 100000000*!!ist->st->codec_info_nb_frames;
2149                 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2150                     new_area = 1;
2151                 if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
2152                     new_area > area) {
2153                     if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2154                         continue;
2155                     area = new_area;
2156                     idx = i;
2157                 }
2158             }
2159             if (idx >= 0)
2160                 new_video_stream(o, oc, idx);
2161         }
2162
2163         /* audio: most channels */
2164         if (!o->audio_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_AUDIO) != AV_CODEC_ID_NONE) {
2165             int best_score = 0, idx = -1;
2166             for (i = 0; i < nb_input_streams; i++) {
2167                 int score;
2168                 ist = input_streams[i];
2169                 score = ist->st->codecpar->channels + 100000000*!!ist->st->codec_info_nb_frames;
2170                 if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
2171                     score > best_score) {
2172                     best_score = score;
2173                     idx = i;
2174                 }
2175             }
2176             if (idx >= 0)
2177                 new_audio_stream(o, oc, idx);
2178         }
2179
2180         /* subtitles: pick first */
2181         MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
2182         if (!o->subtitle_disable && (avcodec_find_encoder(oc->oformat->subtitle_codec) || subtitle_codec_name)) {
2183             for (i = 0; i < nb_input_streams; i++)
2184                 if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2185                     AVCodecDescriptor const *input_descriptor =
2186                         avcodec_descriptor_get(input_streams[i]->st->codecpar->codec_id);
2187                     AVCodecDescriptor const *output_descriptor = NULL;
2188                     AVCodec const *output_codec =
2189                         avcodec_find_encoder(oc->oformat->subtitle_codec);
2190                     int input_props = 0, output_props = 0;
2191                     if (output_codec)
2192                         output_descriptor = avcodec_descriptor_get(output_codec->id);
2193                     if (input_descriptor)
2194                         input_props = input_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2195                     if (output_descriptor)
2196                         output_props = output_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2197                     if (subtitle_codec_name ||
2198                         input_props & output_props ||
2199                         // Map dvb teletext which has neither property to any output subtitle encoder
2200                         input_descriptor && output_descriptor &&
2201                         (!input_descriptor->props ||
2202                          !output_descriptor->props)) {
2203                         new_subtitle_stream(o, oc, i);
2204                         break;
2205                     }
2206                 }
2207         }
2208         /* Data only if codec id match */
2209         if (!o->data_disable ) {
2210             enum AVCodecID codec_id = av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_DATA);
2211             for (i = 0; codec_id != AV_CODEC_ID_NONE && i < nb_input_streams; i++) {
2212                 if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_DATA
2213                     && input_streams[i]->st->codecpar->codec_id == codec_id )
2214                     new_data_stream(o, oc, i);
2215             }
2216         }
2217     } else {
2218         for (i = 0; i < o->nb_stream_maps; i++) {
2219             StreamMap *map = &o->stream_maps[i];
2220
2221             if (map->disabled)
2222                 continue;
2223
2224             if (map->linklabel) {
2225                 FilterGraph *fg;
2226                 OutputFilter *ofilter = NULL;
2227                 int j, k;
2228
2229                 for (j = 0; j < nb_filtergraphs; j++) {
2230                     fg = filtergraphs[j];
2231                     for (k = 0; k < fg->nb_outputs; k++) {
2232                         AVFilterInOut *out = fg->outputs[k]->out_tmp;
2233                         if (out && !strcmp(out->name, map->linklabel)) {
2234                             ofilter = fg->outputs[k];
2235                             goto loop_end;
2236                         }
2237                     }
2238                 }
2239 loop_end:
2240                 if (!ofilter) {
2241                     av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
2242                            "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
2243                     exit_program(1);
2244                 }
2245                 init_output_filter(ofilter, o, oc);
2246             } else {
2247                 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
2248
2249                 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
2250                 if(o->subtitle_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE)
2251                     continue;
2252                 if(o->   audio_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
2253                     continue;
2254                 if(o->   video_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
2255                     continue;
2256                 if(o->    data_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_DATA)
2257                     continue;
2258
2259                 ost = NULL;
2260                 switch (ist->st->codecpar->codec_type) {
2261                 case AVMEDIA_TYPE_VIDEO:      ost = new_video_stream     (o, oc, src_idx); break;
2262                 case AVMEDIA_TYPE_AUDIO:      ost = new_audio_stream     (o, oc, src_idx); break;
2263                 case AVMEDIA_TYPE_SUBTITLE:   ost = new_subtitle_stream  (o, oc, src_idx); break;
2264                 case AVMEDIA_TYPE_DATA:       ost = new_data_stream      (o, oc, src_idx); break;
2265                 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
2266                 case AVMEDIA_TYPE_UNKNOWN:
2267                     if (copy_unknown_streams) {
2268                         ost = new_unknown_stream   (o, oc, src_idx);
2269                         break;
2270                     }
2271                 default:
2272                     av_log(NULL, ignore_unknown_streams ? AV_LOG_WARNING : AV_LOG_FATAL,
2273                            "Cannot map stream #%d:%d - unsupported type.\n",
2274                            map->file_index, map->stream_index);
2275                     if (!ignore_unknown_streams) {
2276                         av_log(NULL, AV_LOG_FATAL,
2277                                "If you want unsupported types ignored instead "
2278                                "of failing, please use the -ignore_unknown option\n"
2279                                "If you want them copied, please use -copy_unknown\n");
2280                         exit_program(1);
2281                     }
2282                 }
2283                 if (ost)
2284                     ost->sync_ist = input_streams[  input_files[map->sync_file_index]->ist_index
2285                                                   + map->sync_stream_index];
2286             }
2287         }
2288     }
2289
2290     /* handle attached files */
2291     for (i = 0; i < o->nb_attachments; i++) {
2292         AVIOContext *pb;
2293         uint8_t *attachment;
2294         const char *p;
2295         int64_t len;
2296
2297         if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
2298             av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
2299                    o->attachments[i]);
2300             exit_program(1);
2301         }
2302         if ((len = avio_size(pb)) <= 0) {
2303             av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
2304                    o->attachments[i]);
2305             exit_program(1);
2306         }
2307         if (!(attachment = av_malloc(len))) {
2308             av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
2309                    o->attachments[i]);
2310             exit_program(1);
2311         }
2312         avio_read(pb, attachment, len);
2313
2314         ost = new_attachment_stream(o, oc, -1);
2315         ost->stream_copy               = 0;
2316         ost->attachment_filename       = o->attachments[i];
2317         ost->st->codecpar->extradata      = attachment;
2318         ost->st->codecpar->extradata_size = len;
2319
2320         p = strrchr(o->attachments[i], '/');
2321         av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
2322         avio_closep(&pb);
2323     }
2324
2325 #if FF_API_LAVF_AVCTX
2326     for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
2327         AVDictionaryEntry *e;
2328         ost = output_streams[i];
2329
2330         if ((ost->stream_copy || ost->attachment_filename)
2331             && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
2332             && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
2333             if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
2334                 exit_program(1);
2335     }
2336 #endif
2337
2338     if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
2339         av_dump_format(oc, nb_output_files - 1, oc->filename, 1);
2340         av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", nb_output_files - 1);
2341         exit_program(1);
2342     }
2343
2344     /* check if all codec options have been used */
2345     unused_opts = strip_specifiers(o->g->codec_opts);
2346     for (i = of->ost_index; i < nb_output_streams; i++) {
2347         e = NULL;
2348         while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
2349                                 AV_DICT_IGNORE_SUFFIX)))
2350             av_dict_set(&unused_opts, e->key, NULL, 0);
2351     }
2352
2353     e = NULL;
2354     while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
2355         const AVClass *class = avcodec_get_class();
2356         const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
2357                                              AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2358         const AVClass *fclass = avformat_get_class();
2359         const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
2360                                               AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2361         if (!option || foption)
2362             continue;
2363
2364
2365         if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
2366             av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
2367                    "output file #%d (%s) is not an encoding option.\n", e->key,
2368                    option->help ? option->help : "", nb_output_files - 1,
2369                    filename);
2370             exit_program(1);
2371         }
2372
2373         // gop_timecode is injected by generic code but not always used
2374         if (!strcmp(e->key, "gop_timecode"))
2375             continue;
2376
2377         av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
2378                "output file #%d (%s) has not been used for any stream. The most "
2379                "likely reason is either wrong type (e.g. a video option with "
2380                "no video streams) or that it is a private option of some encoder "
2381                "which was not actually used for any stream.\n", e->key,
2382                option->help ? option->help : "", nb_output_files - 1, filename);
2383     }
2384     av_dict_free(&unused_opts);
2385
2386     /* set the decoding_needed flags and create simple filtergraphs */
2387     for (i = of->ost_index; i < nb_output_streams; i++) {
2388         OutputStream *ost = output_streams[i];
2389
2390         if (ost->encoding_needed && ost->source_index >= 0) {
2391             InputStream *ist = input_streams[ost->source_index];
2392             ist->decoding_needed |= DECODING_FOR_OST;
2393
2394             if (ost->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
2395                 ost->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
2396                 err = init_simple_filtergraph(ist, ost);
2397                 if (err < 0) {
2398                     av_log(NULL, AV_LOG_ERROR,
2399                            "Error initializing a simple filtergraph between streams "
2400                            "%d:%d->%d:%d\n", ist->file_index, ost->source_index,
2401                            nb_output_files - 1, ost->st->index);
2402                     exit_program(1);
2403                 }
2404             }
2405         }
2406
2407         /* set the filter output constraints */
2408         if (ost->filter) {
2409             OutputFilter *f = ost->filter;
2410             int count;
2411             switch (ost->enc_ctx->codec_type) {
2412             case AVMEDIA_TYPE_VIDEO:
2413                 f->frame_rate = ost->frame_rate;
2414                 f->width      = ost->enc_ctx->width;
2415                 f->height     = ost->enc_ctx->height;
2416                 if (ost->enc_ctx->pix_fmt != AV_PIX_FMT_NONE) {
2417                     f->format = ost->enc_ctx->pix_fmt;
2418                 } else if (ost->enc->pix_fmts) {
2419                     count = 0;
2420                     while (ost->enc->pix_fmts[count] != AV_PIX_FMT_NONE)
2421                         count++;
2422                     f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
2423                     if (!f->formats)
2424                         exit_program(1);
2425                     memcpy(f->formats, ost->enc->pix_fmts, (count + 1) * sizeof(*f->formats));
2426                 }
2427                 break;
2428             case AVMEDIA_TYPE_AUDIO:
2429                 if (ost->enc_ctx->sample_fmt != AV_SAMPLE_FMT_NONE) {
2430                     f->format = ost->enc_ctx->sample_fmt;
2431                 } else if (ost->enc->sample_fmts) {
2432                     count = 0;
2433                     while (ost->enc->sample_fmts[count] != AV_SAMPLE_FMT_NONE)
2434                         count++;
2435                     f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
2436                     if (!f->formats)
2437                         exit_program(1);
2438                     memcpy(f->formats, ost->enc->sample_fmts, (count + 1) * sizeof(*f->formats));
2439                 }
2440                 if (ost->enc_ctx->sample_rate) {
2441                     f->sample_rate = ost->enc_ctx->sample_rate;
2442                 } else if (ost->enc->supported_samplerates) {
2443                     count = 0;
2444                     while (ost->enc->supported_samplerates[count])
2445                         count++;
2446                     f->sample_rates = av_mallocz_array(count + 1, sizeof(*f->sample_rates));
2447                     if (!f->sample_rates)
2448                         exit_program(1);
2449                     memcpy(f->sample_rates, ost->enc->supported_samplerates,
2450                            (count + 1) * sizeof(*f->sample_rates));
2451                 }
2452                 if (ost->enc_ctx->channels) {
2453                     f->channel_layout = av_get_default_channel_layout(ost->enc_ctx->channels);
2454                 } else if (ost->enc->channel_layouts) {
2455                     count = 0;
2456                     while (ost->enc->channel_layouts[count])
2457                         count++;
2458                     f->channel_layouts = av_mallocz_array(count + 1, sizeof(*f->channel_layouts));
2459                     if (!f->channel_layouts)
2460                         exit_program(1);
2461                     memcpy(f->channel_layouts, ost->enc->channel_layouts,
2462                            (count + 1) * sizeof(*f->channel_layouts));
2463                 }
2464                 break;
2465             }
2466         }
2467     }
2468
2469     /* check filename in case of an image number is expected */
2470     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
2471         if (!av_filename_number_test(oc->filename)) {
2472             print_error(oc->filename, AVERROR(EINVAL));
2473             exit_program(1);
2474         }
2475     }
2476
2477     if (!(oc->oformat->flags & AVFMT_NOSTREAMS) && !input_stream_potentially_available) {
2478         av_log(NULL, AV_LOG_ERROR,
2479                "No input streams but output needs an input stream\n");
2480         exit_program(1);
2481     }
2482
2483     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
2484         /* test if it already exists to avoid losing precious files */
2485         assert_file_overwrite(filename);
2486
2487         /* open the file */
2488         if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
2489                               &oc->interrupt_callback,
2490                               &of->opts)) < 0) {
2491             print_error(filename, err);
2492             exit_program(1);
2493         }
2494     } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
2495         assert_file_overwrite(filename);
2496
2497     if (o->mux_preload) {
2498         av_dict_set_int(&of->opts, "preload", o->mux_preload*AV_TIME_BASE, 0);
2499     }
2500     oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
2501
2502     /* copy metadata */
2503     for (i = 0; i < o->nb_metadata_map; i++) {
2504         char *p;
2505         int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
2506
2507         if (in_file_index >= nb_input_files) {
2508             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
2509             exit_program(1);
2510         }
2511         copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
2512                       in_file_index >= 0 ?
2513                       input_files[in_file_index]->ctx : NULL, o);
2514     }
2515
2516     /* copy chapters */
2517     if (o->chapters_input_file >= nb_input_files) {
2518         if (o->chapters_input_file == INT_MAX) {
2519             /* copy chapters from the first input file that has them*/
2520             o->chapters_input_file = -1;
2521             for (i = 0; i < nb_input_files; i++)
2522                 if (input_files[i]->ctx->nb_chapters) {
2523                     o->chapters_input_file = i;
2524                     break;
2525                 }
2526         } else {
2527             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
2528                    o->chapters_input_file);
2529             exit_program(1);
2530         }
2531     }
2532     if (o->chapters_input_file >= 0)
2533         copy_chapters(input_files[o->chapters_input_file], of,
2534                       !o->metadata_chapters_manual);
2535
2536     /* copy global metadata by default */
2537     if (!o->metadata_global_manual && nb_input_files){
2538         av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
2539                      AV_DICT_DONT_OVERWRITE);
2540         if(o->recording_time != INT64_MAX)
2541             av_dict_set(&oc->metadata, "duration", NULL, 0);
2542         av_dict_set(&oc->metadata, "creation_time", NULL, 0);
2543     }
2544     if (!o->metadata_streams_manual)
2545         for (i = of->ost_index; i < nb_output_streams; i++) {
2546             InputStream *ist;
2547             if (output_streams[i]->source_index < 0)         /* this is true e.g. for attached files */
2548                 continue;
2549             ist = input_streams[output_streams[i]->source_index];
2550             av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
2551             if (!output_streams[i]->stream_copy) {
2552                 av_dict_set(&output_streams[i]->st->metadata, "encoder", NULL, 0);
2553             }
2554         }
2555
2556     /* process manually set programs */
2557     for (i = 0; i < o->nb_program; i++) {
2558         const char *p = o->program[i].u.str;
2559         int progid = i+1;
2560         AVProgram *program;
2561
2562         while(*p) {
2563             const char *p2 = av_get_token(&p, ":");
2564             const char *to_dealloc = p2;
2565             char *key;
2566             if (!p2)
2567                 break;
2568
2569             if(*p) p++;
2570
2571             key = av_get_token(&p2, "=");
2572             if (!key || !*p2) {
2573                 av_freep(&to_dealloc);
2574                 av_freep(&key);
2575                 break;
2576             }
2577             p2++;
2578
2579             if (!strcmp(key, "program_num"))
2580                 progid = strtol(p2, NULL, 0);
2581             av_freep(&to_dealloc);
2582             av_freep(&key);
2583         }
2584
2585         program = av_new_program(oc, progid);
2586
2587         p = o->program[i].u.str;
2588         while(*p) {
2589             const char *p2 = av_get_token(&p, ":");
2590             const char *to_dealloc = p2;
2591             char *key;
2592             if (!p2)
2593                 break;
2594             if(*p) p++;
2595
2596             key = av_get_token(&p2, "=");
2597             if (!key) {
2598                 av_log(NULL, AV_LOG_FATAL,
2599                        "No '=' character in program string %s.\n",
2600                        p2);
2601                 exit_program(1);
2602             }
2603             if (!*p2)
2604                 exit_program(1);
2605             p2++;
2606
2607             if (!strcmp(key, "title")) {
2608                 av_dict_set(&program->metadata, "title", p2, 0);
2609             } else if (!strcmp(key, "program_num")) {
2610             } else if (!strcmp(key, "st")) {
2611                 int st_num = strtol(p2, NULL, 0);
2612                 av_program_add_stream_index(oc, progid, st_num);
2613             } else {
2614                 av_log(NULL, AV_LOG_FATAL, "Unknown program key %s.\n", key);
2615                 exit_program(1);
2616             }
2617             av_freep(&to_dealloc);
2618             av_freep(&key);
2619         }
2620     }
2621
2622     /* process manually set metadata */
2623     for (i = 0; i < o->nb_metadata; i++) {
2624         AVDictionary **m;
2625         char type, *val;
2626         const char *stream_spec;
2627         int index = 0, j, ret = 0;
2628
2629         val = strchr(o->metadata[i].u.str, '=');
2630         if (!val) {
2631             av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
2632                    o->metadata[i].u.str);
2633             exit_program(1);
2634         }
2635         *val++ = 0;
2636
2637         parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
2638         if (type == 's') {
2639             for (j = 0; j < oc->nb_streams; j++) {
2640                 ost = output_streams[nb_output_streams - oc->nb_streams + j];
2641                 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2642                     if (!strcmp(o->metadata[i].u.str, "rotate")) {
2643                         char *tail;
2644                         double theta = av_strtod(val, &tail);
2645                         if (!*tail) {
2646                             ost->rotate_overridden = 1;
2647                             ost->rotate_override_value = theta;
2648                         }
2649                     } else {
2650                         av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2651                     }
2652                 } else if (ret < 0)
2653                     exit_program(1);
2654             }
2655         }
2656         else {
2657             switch (type) {
2658             case 'g':
2659                 m = &oc->metadata;
2660                 break;
2661             case 'c':
2662                 if (index < 0 || index >= oc->nb_chapters) {
2663                     av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2664                     exit_program(1);
2665                 }
2666                 m = &oc->chapters[index]->metadata;
2667                 break;
2668             case 'p':
2669                 if (index < 0 || index >= oc->nb_programs) {
2670                     av_log(NULL, AV_LOG_FATAL, "Invalid program index %d in metadata specifier.\n", index);
2671                     exit_program(1);
2672                 }
2673                 m = &oc->programs[index]->metadata;
2674                 break;
2675             default:
2676                 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2677                 exit_program(1);
2678             }
2679             av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2680         }
2681     }
2682
2683     return 0;
2684 }
2685
2686 static int opt_target(void *optctx, const char *opt, const char *arg)
2687 {
2688     OptionsContext *o = optctx;
2689     enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2690     static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2691
2692     if (!strncmp(arg, "pal-", 4)) {
2693         norm = PAL;
2694         arg += 4;
2695     } else if (!strncmp(arg, "ntsc-", 5)) {
2696         norm = NTSC;
2697         arg += 5;
2698     } else if (!strncmp(arg, "film-", 5)) {
2699         norm = FILM;
2700         arg += 5;
2701     } else {
2702         /* Try to determine PAL/NTSC by peeking in the input files */
2703         if (nb_input_files) {
2704             int i, j, fr;
2705             for (j = 0; j < nb_input_files; j++) {
2706                 for (i = 0; i < input_files[j]->nb_streams; i++) {
2707                     AVStream *st = input_files[j]->ctx->streams[i];
2708                     if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO)
2709                         continue;
2710                     fr = st->time_base.den * 1000 / st->time_base.num;
2711                     if (fr == 25000) {
2712                         norm = PAL;
2713                         break;
2714                     } else if ((fr == 29970) || (fr == 23976)) {
2715                         norm = NTSC;
2716                         break;
2717                     }
2718                 }
2719                 if (norm != UNKNOWN)
2720                     break;
2721             }
2722         }
2723         if (norm != UNKNOWN)
2724             av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2725     }
2726
2727     if (norm == UNKNOWN) {
2728         av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2729         av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2730         av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2731         exit_program(1);
2732     }
2733
2734     if (!strcmp(arg, "vcd")) {
2735         opt_video_codec(o, "c:v", "mpeg1video");
2736         opt_audio_codec(o, "c:a", "mp2");
2737         parse_option(o, "f", "vcd", options);
2738
2739         parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2740         parse_option(o, "r", frame_rates[norm], options);
2741         opt_default(NULL, "g", norm == PAL ? "15" : "18");
2742
2743         opt_default(NULL, "b:v", "1150000");
2744         opt_default(NULL, "maxrate:v", "1150000");
2745         opt_default(NULL, "minrate:v", "1150000");
2746         opt_default(NULL, "bufsize:v", "327680"); // 40*1024*8;
2747
2748         opt_default(NULL, "b:a", "224000");
2749         parse_option(o, "ar", "44100", options);
2750         parse_option(o, "ac", "2", options);
2751
2752         opt_default(NULL, "packetsize", "2324");
2753         opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
2754
2755         /* We have to offset the PTS, so that it is consistent with the SCR.
2756            SCR starts at 36000, but the first two packs contain only padding
2757            and the first pack from the other stream, respectively, may also have
2758            been written before.
2759            So the real data starts at SCR 36000+3*1200. */
2760         o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2761     } else if (!strcmp(arg, "svcd")) {
2762
2763         opt_video_codec(o, "c:v", "mpeg2video");
2764         opt_audio_codec(o, "c:a", "mp2");
2765         parse_option(o, "f", "svcd", options);
2766
2767         parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2768         parse_option(o, "r", frame_rates[norm], options);
2769         parse_option(o, "pix_fmt", "yuv420p", options);
2770         opt_default(NULL, "g", norm == PAL ? "15" : "18");
2771
2772         opt_default(NULL, "b:v", "2040000");
2773         opt_default(NULL, "maxrate:v", "2516000");
2774         opt_default(NULL, "minrate:v", "0"); // 1145000;
2775         opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2776         opt_default(NULL, "scan_offset", "1");
2777
2778         opt_default(NULL, "b:a", "224000");
2779         parse_option(o, "ar", "44100", options);
2780
2781         opt_default(NULL, "packetsize", "2324");
2782
2783     } else if (!strcmp(arg, "dvd")) {
2784
2785         opt_video_codec(o, "c:v", "mpeg2video");
2786         opt_audio_codec(o, "c:a", "ac3");
2787         parse_option(o, "f", "dvd", options);
2788
2789         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2790         parse_option(o, "r", frame_rates[norm], options);
2791         parse_option(o, "pix_fmt", "yuv420p", options);
2792         opt_default(NULL, "g", norm == PAL ? "15" : "18");
2793
2794         opt_default(NULL, "b:v", "6000000");
2795         opt_default(NULL, "maxrate:v", "9000000");
2796         opt_default(NULL, "minrate:v", "0"); // 1500000;
2797         opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2798
2799         opt_default(NULL, "packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
2800         opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2801
2802         opt_default(NULL, "b:a", "448000");
2803         parse_option(o, "ar", "48000", options);
2804
2805     } else if (!strncmp(arg, "dv", 2)) {
2806
2807         parse_option(o, "f", "dv", options);
2808
2809         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2810         parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2811                           norm == PAL ? "yuv420p" : "yuv411p", options);
2812         parse_option(o, "r", frame_rates[norm], options);
2813
2814         parse_option(o, "ar", "48000", options);
2815         parse_option(o, "ac", "2", options);
2816
2817     } else {
2818         av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2819         return AVERROR(EINVAL);
2820     }
2821
2822     av_dict_copy(&o->g->codec_opts,  codec_opts, AV_DICT_DONT_OVERWRITE);
2823     av_dict_copy(&o->g->format_opts, format_opts, AV_DICT_DONT_OVERWRITE);
2824
2825     return 0;
2826 }
2827
2828 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2829 {
2830     av_free (vstats_filename);
2831     vstats_filename = av_strdup (arg);
2832     return 0;
2833 }
2834
2835 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2836 {
2837     char filename[40];
2838     time_t today2 = time(NULL);
2839     struct tm *today = localtime(&today2);
2840
2841     if (!today) { // maybe tomorrow
2842         av_log(NULL, AV_LOG_FATAL, "Unable to get current time: %s\n", strerror(errno));
2843         exit_program(1);
2844     }
2845
2846     snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2847              today->tm_sec);
2848     return opt_vstats_file(NULL, opt, filename);
2849 }
2850
2851 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2852 {
2853     OptionsContext *o = optctx;
2854     return parse_option(o, "frames:v", arg, options);
2855 }
2856
2857 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2858 {
2859     OptionsContext *o = optctx;
2860     return parse_option(o, "frames:a", arg, options);
2861 }
2862
2863 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2864 {
2865     OptionsContext *o = optctx;
2866     return parse_option(o, "frames:d", arg, options);
2867 }
2868
2869 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2870 {
2871     int ret;
2872     AVDictionary *cbak = codec_opts;
2873     AVDictionary *fbak = format_opts;
2874     codec_opts = NULL;
2875     format_opts = NULL;
2876
2877     ret = opt_default(NULL, opt, arg);
2878
2879     av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2880     av_dict_copy(&o->g->format_opts, format_opts, 0);
2881     av_dict_free(&codec_opts);
2882     av_dict_free(&format_opts);
2883     codec_opts = cbak;
2884     format_opts = fbak;
2885
2886     return ret;
2887 }
2888
2889 static int opt_preset(void *optctx, const char *opt, const char *arg)
2890 {
2891     OptionsContext *o = optctx;
2892     FILE *f=NULL;
2893     char filename[1000], line[1000], tmp_line[1000];
2894     const char *codec_name = NULL;
2895
2896     tmp_line[0] = *opt;
2897     tmp_line[1] = 0;
2898     MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2899
2900     if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2901         if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2902             av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2903         }else
2904             av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2905         exit_program(1);
2906     }
2907
2908     while (fgets(line, sizeof(line), f)) {
2909         char *key = tmp_line, *value, *endptr;
2910
2911         if (strcspn(line, "#\n\r") == 0)
2912             continue;
2913         av_strlcpy(tmp_line, line, sizeof(tmp_line));
2914         if (!av_strtok(key,   "=",    &value) ||
2915             !av_strtok(value, "\r\n", &endptr)) {
2916             av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2917             exit_program(1);
2918         }
2919         av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2920
2921         if      (!strcmp(key, "acodec")) opt_audio_codec   (o, key, value);
2922         else if (!strcmp(key, "vcodec")) opt_video_codec   (o, key, value);
2923         else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2924         else if (!strcmp(key, "dcodec")) opt_data_codec    (o, key, value);
2925         else if (opt_default_new(o, key, value) < 0) {
2926             av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2927                    filename, line, key, value);
2928             exit_program(1);
2929         }
2930     }
2931
2932     fclose(f);
2933
2934     return 0;
2935 }
2936
2937 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2938 {
2939     OptionsContext *o = optctx;
2940     char *s = av_asprintf("%s:%c", opt + 1, *opt);
2941     int ret = parse_option(o, s, arg, options);
2942     av_free(s);
2943     return ret;
2944 }
2945
2946 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2947 {
2948     OptionsContext *o = optctx;
2949
2950     if(!strcmp(opt, "ab")){
2951         av_dict_set(&o->g->codec_opts, "b:a", arg, 0);
2952         return 0;
2953     } else if(!strcmp(opt, "b")){
2954         av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2955         av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2956         return 0;
2957     }
2958     av_dict_set(&o->g->codec_opts, opt, arg, 0);
2959     return 0;
2960 }
2961
2962 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2963 {
2964     OptionsContext *o = optctx;
2965     char *s;
2966     int ret;
2967     if(!strcmp(opt, "qscale")){
2968         av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2969         return parse_option(o, "q:v", arg, options);
2970     }
2971     s = av_asprintf("q%s", opt + 6);
2972     ret = parse_option(o, s, arg, options);
2973     av_free(s);
2974     return ret;
2975 }
2976
2977 static int opt_profile(void *optctx, const char *opt, const char *arg)
2978 {
2979     OptionsContext *o = optctx;
2980     if(!strcmp(opt, "profile")){
2981         av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2982         av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
2983         return 0;
2984     }
2985     av_dict_set(&o->g->codec_opts, opt, arg, 0);
2986     return 0;
2987 }
2988
2989 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2990 {
2991     OptionsContext *o = optctx;
2992     return parse_option(o, "filter:v", arg, options);
2993 }
2994
2995 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2996 {
2997     OptionsContext *o = optctx;
2998     return parse_option(o, "filter:a", arg, options);
2999 }
3000
3001 static int opt_vsync(void *optctx, const char *opt, const char *arg)
3002 {
3003     if      (!av_strcasecmp(arg, "cfr"))         video_sync_method = VSYNC_CFR;
3004     else if (!av_strcasecmp(arg, "vfr"))         video_sync_method = VSYNC_VFR;
3005     else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
3006     else if (!av_strcasecmp(arg, "drop"))        video_sync_method = VSYNC_DROP;
3007
3008     if (video_sync_method == VSYNC_AUTO)
3009         video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
3010     return 0;
3011 }
3012
3013 static int opt_timecode(void *optctx, const char *opt, const char *arg)
3014 {
3015     OptionsContext *o = optctx;
3016     char *tcr = av_asprintf("timecode=%s", arg);
3017     int ret = parse_option(o, "metadata:g", tcr, options);
3018     if (ret >= 0)
3019         ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
3020     av_free(tcr);
3021     return ret;
3022 }
3023
3024 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
3025 {
3026     OptionsContext *o = optctx;
3027     char layout_str[32];
3028     char *stream_str;
3029     char *ac_str;
3030     int ret, channels, ac_str_size;
3031     uint64_t layout;
3032
3033     layout = av_get_channel_layout(arg);
3034     if (!layout) {
3035         av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
3036         return AVERROR(EINVAL);
3037     }
3038     snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
3039     ret = opt_default_new(o, opt, layout_str);
3040     if (ret < 0)
3041         return ret;
3042
3043     /* set 'ac' option based on channel layout */
3044     channels = av_get_channel_layout_nb_channels(layout);
3045     snprintf(layout_str, sizeof(layout_str), "%d", channels);
3046     stream_str = strchr(opt, ':');
3047     ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
3048     ac_str = av_mallocz(ac_str_size);
3049     if (!ac_str)
3050         return AVERROR(ENOMEM);
3051     av_strlcpy(ac_str, "ac", 3);
3052     if (stream_str)
3053         av_strlcat(ac_str, stream_str, ac_str_size);
3054     ret = parse_option(o, ac_str, layout_str, options);
3055     av_free(ac_str);
3056
3057     return ret;
3058 }
3059
3060 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
3061 {
3062     OptionsContext *o = optctx;
3063     return parse_option(o, "q:a", arg, options);
3064 }
3065
3066 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
3067 {
3068     GROW_ARRAY(filtergraphs, nb_filtergraphs);
3069     if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
3070         return AVERROR(ENOMEM);
3071     filtergraphs[nb_filtergraphs - 1]->index      = nb_filtergraphs - 1;
3072     filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
3073     if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
3074         return AVERROR(ENOMEM);
3075
3076     input_stream_potentially_available = 1;
3077
3078     return 0;
3079 }
3080
3081 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
3082 {
3083     uint8_t *graph_desc = read_file(arg);
3084     if (!graph_desc)
3085         return AVERROR(EINVAL);
3086
3087     GROW_ARRAY(filtergraphs, nb_filtergraphs);
3088     if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
3089         return AVERROR(ENOMEM);
3090     filtergraphs[nb_filtergraphs - 1]->index      = nb_filtergraphs - 1;
3091     filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
3092
3093     input_stream_potentially_available = 1;
3094
3095     return 0;
3096 }
3097
3098 void show_help_default(const char *opt, const char *arg)
3099 {
3100     /* per-file options have at least one of those set */
3101     const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
3102     int show_advanced = 0, show_avoptions = 0;
3103
3104     if (opt && *opt) {
3105         if (!strcmp(opt, "long"))
3106             show_advanced = 1;
3107         else if (!strcmp(opt, "full"))
3108             show_advanced = show_avoptions = 1;
3109         else
3110             av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
3111     }
3112
3113     show_usage();
3114
3115     printf("Getting help:\n"
3116            "    -h      -- print basic options\n"
3117            "    -h long -- print more options\n"
3118            "    -h full -- print all options (including all format and codec specific options, very long)\n"
3119            "    -h type=name -- print all options for the named decoder/encoder/demuxer/muxer/filter\n"
3120            "    See man %s for detailed description of the options.\n"
3121            "\n", program_name);
3122
3123     show_help_options(options, "Print help / information / capabilities:",
3124                       OPT_EXIT, 0, 0);
3125
3126     show_help_options(options, "Global options (affect whole program "
3127                       "instead of just one file:",
3128                       0, per_file | OPT_EXIT | OPT_EXPERT, 0);
3129     if (show_advanced)
3130         show_help_options(options, "Advanced global options:", OPT_EXPERT,
3131                           per_file | OPT_EXIT, 0);
3132
3133     show_help_options(options, "Per-file main options:", 0,
3134                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
3135                       OPT_EXIT, per_file);
3136     if (show_advanced)
3137         show_help_options(options, "Advanced per-file options:",
3138                           OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
3139
3140     show_help_options(options, "Video options:",
3141                       OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
3142     if (show_advanced)
3143         show_help_options(options, "Advanced Video options:",
3144                           OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
3145
3146     show_help_options(options, "Audio options:",
3147                       OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
3148     if (show_advanced)
3149         show_help_options(options, "Advanced Audio options:",
3150                           OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
3151     show_help_options(options, "Subtitle options:",
3152                       OPT_SUBTITLE, 0, 0);
3153     printf("\n");
3154
3155     if (show_avoptions) {
3156         int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
3157         show_help_children(avcodec_get_class(), flags);
3158         show_help_children(avformat_get_class(), flags);
3159 #if CONFIG_SWSCALE
3160         show_help_children(sws_get_class(), flags);
3161 #endif
3162         show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
3163         show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM);
3164     }
3165 }
3166
3167 void show_usage(void)
3168 {
3169     av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
3170     av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
3171     av_log(NULL, AV_LOG_INFO, "\n");
3172 }
3173
3174 enum OptGroup {
3175     GROUP_OUTFILE,
3176     GROUP_INFILE,
3177 };
3178
3179 static const OptionGroupDef groups[] = {
3180     [GROUP_OUTFILE] = { "output url",  NULL, OPT_OUTPUT },
3181     [GROUP_INFILE]  = { "input url",   "i",  OPT_INPUT },
3182 };
3183
3184 static int open_files(OptionGroupList *l, const char *inout,
3185                       int (*open_file)(OptionsContext*, const char*))
3186 {
3187     int i, ret;
3188
3189     for (i = 0; i < l->nb_groups; i++) {
3190         OptionGroup *g = &l->groups[i];
3191         OptionsContext o;
3192
3193         init_options(&o);
3194         o.g = g;
3195
3196         ret = parse_optgroup(&o, g);
3197         if (ret < 0) {
3198             av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
3199                    "%s.\n", inout, g->arg);
3200             return ret;
3201         }
3202
3203         av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
3204         ret = open_file(&o, g->arg);
3205         uninit_options(&o);
3206         if (ret < 0) {
3207             av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
3208                    inout, g->arg);
3209             return ret;
3210         }
3211         av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
3212     }
3213
3214     return 0;
3215 }
3216
3217 int ffmpeg_parse_options(int argc, char **argv)
3218 {
3219     OptionParseContext octx;
3220     uint8_t error[128];
3221     int ret;
3222
3223     memset(&octx, 0, sizeof(octx));
3224
3225     /* split the commandline into an internal representation */
3226     ret = split_commandline(&octx, argc, argv, options, groups,
3227                             FF_ARRAY_ELEMS(groups));
3228     if (ret < 0) {
3229         av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
3230         goto fail;
3231     }
3232
3233     /* apply global options */
3234     ret = parse_optgroup(NULL, &octx.global_opts);
3235     if (ret < 0) {
3236         av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
3237         goto fail;
3238     }
3239
3240     /* configure terminal and setup signal handlers */
3241     term_init();
3242
3243     /* open input files */
3244     ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
3245     if (ret < 0) {
3246         av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
3247         goto fail;
3248     }
3249
3250     /* create the complex filtergraphs */
3251     ret = init_complex_filters();
3252     if (ret < 0) {
3253         av_log(NULL, AV_LOG_FATAL, "Error initializing complex filters.\n");
3254         goto fail;
3255     }
3256
3257     /* open output files */
3258     ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
3259     if (ret < 0) {
3260         av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
3261         goto fail;
3262     }
3263
3264     check_filter_outputs();
3265
3266 fail:
3267     uninit_parse_context(&octx);
3268     if (ret < 0) {
3269         av_strerror(ret, error, sizeof(error));
3270         av_log(NULL, AV_LOG_FATAL, "%s\n", error);
3271     }
3272     return ret;
3273 }
3274
3275 static int opt_progress(void *optctx, const char *opt, const char *arg)
3276 {
3277     AVIOContext *avio = NULL;
3278     int ret;
3279
3280     if (!strcmp(arg, "-"))
3281         arg = "pipe:";
3282     ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
3283     if (ret < 0) {
3284         av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
3285                arg, av_err2str(ret));
3286         return ret;
3287     }
3288     progress_avio = avio;
3289     return 0;
3290 }
3291
3292 #define OFFSET(x) offsetof(OptionsContext, x)
3293 const OptionDef options[] = {
3294     /* main options */
3295     CMDUTILS_COMMON_OPTIONS
3296     { "f",              HAS_ARG | OPT_STRING | OPT_OFFSET |
3297                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(format) },
3298         "force format", "fmt" },
3299     { "y",              OPT_BOOL,                                    {              &file_overwrite },
3300         "overwrite output files" },
3301     { "n",              OPT_BOOL,                                    {              &no_file_overwrite },
3302         "never overwrite output files" },
3303     { "ignore_unknown", OPT_BOOL,                                    {              &ignore_unknown_streams },
3304         "Ignore unknown stream types" },
3305     { "copy_unknown",   OPT_BOOL | OPT_EXPERT,                       {              &copy_unknown_streams },
3306         "Copy unknown stream types" },
3307     { "c",              HAS_ARG | OPT_STRING | OPT_SPEC |
3308                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(codec_names) },
3309         "codec name", "codec" },
3310     { "codec",          HAS_ARG | OPT_STRING | OPT_SPEC |
3311                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(codec_names) },
3312         "codec name", "codec" },
3313     { "pre",            HAS_ARG | OPT_STRING | OPT_SPEC |
3314                         OPT_OUTPUT,                                  { .off       = OFFSET(presets) },
3315         "preset name", "preset" },
3316     { "map",            HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3317                         OPT_OUTPUT,                                  { .func_arg = opt_map },
3318         "set input stream mapping",
3319         "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
3320     { "map_channel",    HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
3321         "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
3322     { "map_metadata",   HAS_ARG | OPT_STRING | OPT_SPEC |
3323                         OPT_OUTPUT,                                  { .off       = OFFSET(metadata_map) },
3324         "set metadata information of outfile from infile",
3325         "outfile[,metadata]:infile[,metadata]" },
3326     { "map_chapters",   HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
3327                         OPT_OUTPUT,                                  { .off = OFFSET(chapters_input_file) },
3328         "set chapters mapping", "input_file_index" },
3329     { "t",              HAS_ARG | OPT_TIME | OPT_OFFSET |
3330                         OPT_INPUT | OPT_OUTPUT,                      { .off = OFFSET(recording_time) },
3331         "record or transcode \"duration\" seconds of audio/video",
3332         "duration" },
3333     { "to",             HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,  { .off = OFFSET(stop_time) },
3334         "record or transcode stop time", "time_stop" },
3335     { "fs",             HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
3336         "set the limit file size in bytes", "limit_size" },
3337     { "ss",             HAS_ARG | OPT_TIME | OPT_OFFSET |
3338                         OPT_INPUT | OPT_OUTPUT,                      { .off = OFFSET(start_time) },
3339         "set the start time offset", "time_off" },
3340     { "sseof",          HAS_ARG | OPT_TIME | OPT_OFFSET |
3341                         OPT_INPUT | OPT_OUTPUT,                      { .off = OFFSET(start_time_eof) },
3342         "set the start time offset relative to EOF", "time_off" },
3343     { "seek_timestamp", HAS_ARG | OPT_INT | OPT_OFFSET |
3344                         OPT_INPUT,                                   { .off = OFFSET(seek_timestamp) },
3345         "enable/disable seeking by timestamp with -ss" },
3346     { "accurate_seek",  OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
3347                         OPT_INPUT,                                   { .off = OFFSET(accurate_seek) },
3348         "enable/disable accurate seeking with -ss" },
3349     { "itsoffset",      HAS_ARG | OPT_TIME | OPT_OFFSET |
3350                         OPT_EXPERT | OPT_INPUT,                      { .off = OFFSET(input_ts_offset) },
3351         "set the input ts offset", "time_off" },
3352     { "itsscale",       HAS_ARG | OPT_DOUBLE | OPT_SPEC |
3353                         OPT_EXPERT | OPT_INPUT,                      { .off = OFFSET(ts_scale) },
3354         "set the input ts scale", "scale" },
3355     { "timestamp",      HAS_ARG | OPT_PERFILE | OPT_OUTPUT,          { .func_arg = opt_recording_timestamp },
3356         "set the recording timestamp ('now' to set the current time)", "time" },
3357     { "metadata",       HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
3358         "add metadata", "string=string" },
3359     { "program",        HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(program) },
3360         "add program with specified streams", "title=string:st=number..." },
3361     { "dframes",        HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3362                         OPT_OUTPUT,                                  { .func_arg = opt_data_frames },
3363         "set the number of data frames to output", "number" },
3364     { "benchmark",      OPT_BOOL | OPT_EXPERT,                       { &do_benchmark },
3365         "add timings for benchmarking" },
3366     { "benchmark_all",  OPT_BOOL | OPT_EXPERT,                       { &do_benchmark_all },
3367       "add timings for each task" },
3368     { "progress",       HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_progress },
3369       "write program-readable progress information", "url" },
3370     { "stdin",          OPT_BOOL | OPT_EXPERT,                       { &stdin_interaction },
3371       "enable or disable interaction on standard input" },
3372     { "timelimit",      HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_timelimit },
3373         "set max runtime in seconds", "limit" },
3374     { "dump",           OPT_BOOL | OPT_EXPERT,                       { &do_pkt_dump },
3375         "dump each input packet" },
3376     { "hex",            OPT_BOOL | OPT_EXPERT,                       { &do_hex_dump },
3377         "when dumping packets, also dump the payload" },
3378     { "re",             OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3379                         OPT_INPUT,                                   { .off = OFFSET(rate_emu) },
3380         "read input at native frame rate", "" },
3381     { "target",         HAS_ARG | OPT_PERFILE | OPT_OUTPUT,          { .func_arg = opt_target },
3382         "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\" or \"dv50\" "
3383         "with optional prefixes \"pal-\", \"ntsc-\" or \"film-\")", "type" },
3384     { "vsync",          HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_vsync },
3385         "video sync method", "" },
3386     { "frame_drop_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,      { &frame_drop_threshold },
3387         "frame drop threshold", "" },
3388     { "async",          HAS_ARG | OPT_INT | OPT_EXPERT,              { &audio_sync_method },
3389         "audio sync method", "" },
3390     { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,          { &audio_drift_threshold },
3391         "audio drift threshold", "threshold" },
3392     { "copyts",         OPT_BOOL | OPT_EXPERT,                       { &copy_ts },
3393         "copy timestamps" },
3394     { "start_at_zero",  OPT_BOOL | OPT_EXPERT,                       { &start_at_zero },
3395         "shift input timestamps to start at 0 when using copyts" },
3396     { "copytb",         HAS_ARG | OPT_INT | OPT_EXPERT,              { &copy_tb },
3397         "copy input stream time base when stream copying", "mode" },
3398     { "shortest",       OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3399                         OPT_OUTPUT,                                  { .off = OFFSET(shortest) },
3400         "finish encoding within shortest input" },
3401     { "bitexact",       OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3402                         OPT_OUTPUT | OPT_INPUT,                      { .off = OFFSET(bitexact) },
3403         "bitexact mode" },
3404     { "apad",           OPT_STRING | HAS_ARG | OPT_SPEC |
3405                         OPT_OUTPUT,                                  { .off = OFFSET(apad) },
3406         "audio pad", "" },
3407     { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,       { &dts_delta_threshold },
3408         "timestamp discontinuity delta threshold", "threshold" },
3409     { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,       { &dts_error_threshold },
3410         "timestamp error delta threshold", "threshold" },
3411     { "xerror",         OPT_BOOL | OPT_EXPERT,                       { &exit_on_error },
3412         "exit on error", "error" },
3413     { "abort_on",       HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_abort_on },
3414         "abort on the specified condition flags", "flags" },
3415     { "copyinkf",       OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3416                         OPT_OUTPUT,                                  { .off = OFFSET(copy_initial_nonkeyframes) },
3417         "copy initial non-keyframes" },
3418     { "copypriorss",    OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT,   { .off = OFFSET(copy_prior_start) },
3419         "copy or discard frames before start time" },
3420     { "frames",         OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
3421         "set the number of frames to output", "number" },
3422     { "tag",            OPT_STRING | HAS_ARG | OPT_SPEC |
3423                         OPT_EXPERT | OPT_OUTPUT | OPT_INPUT,         { .off = OFFSET(codec_tags) },
3424         "force codec tag/fourcc", "fourcc/tag" },
3425     { "q",              HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
3426                         OPT_SPEC | OPT_OUTPUT,                       { .off = OFFSET(qscale) },
3427         "use fixed quality scale (VBR)", "q" },
3428     { "qscale",         HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3429                         OPT_OUTPUT,                                  { .func_arg = opt_qscale },
3430         "use fixed quality scale (VBR)", "q" },
3431     { "profile",        HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
3432         "set profile", "profile" },
3433     { "filter",         HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
3434         "set stream filtergraph", "filter_graph" },
3435     { "filter_threads",  HAS_ARG | OPT_INT,                          { &filter_nbthreads },
3436         "number of non-complex filter threads" },
3437     { "filter_script",  HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
3438         "read stream filtergraph description from a file", "filename" },
3439     { "reinit_filter",  HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT,    { .off = OFFSET(reinit_filters) },
3440         "reinit filtergraph on input parameter changes", "" },
3441     { "filter_complex", HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_filter_complex },
3442         "create a complex filtergraph", "graph_description" },
3443     { "filter_complex_threads", HAS_ARG | OPT_INT,                   { &filter_complex_nbthreads },
3444         "number of threads for -filter_complex" },
3445     { "lavfi",          HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_filter_complex },
3446         "create a complex filtergraph", "graph_description" },
3447     { "filter_complex_script", HAS_ARG | OPT_EXPERT,                 { .func_arg = opt_filter_complex_script },
3448         "read complex filtergraph description from a file", "filename" },
3449     { "stats",          OPT_BOOL,                                    { &print_stats },
3450         "print progress report during encoding", },
3451     { "attach",         HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3452                         OPT_OUTPUT,                                  { .func_arg = opt_attach },
3453         "add an attachment to the output file", "filename" },
3454     { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
3455                          OPT_EXPERT | OPT_INPUT,                     { .off = OFFSET(dump_attachment) },
3456         "extract an attachment into a file", "filename" },
3457     { "stream_loop", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_INPUT |
3458                         OPT_OFFSET,                                  { .off = OFFSET(loop) }, "set number of times input stream shall be looped", "loop count" },
3459     { "debug_ts",       OPT_BOOL | OPT_EXPERT,                       { &debug_ts },
3460         "print timestamp debugging info" },
3461     { "max_error_rate",  HAS_ARG | OPT_FLOAT,                        { &max_error_rate },
3462         "maximum error rate", "ratio of errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success." },
3463     { "discard",        OPT_STRING | HAS_ARG | OPT_SPEC |
3464                         OPT_INPUT,                                   { .off = OFFSET(discard) },
3465         "discard", "" },
3466     { "disposition",    OPT_STRING | HAS_ARG | OPT_SPEC |
3467                         OPT_OUTPUT,                                  { .off = OFFSET(disposition) },
3468         "disposition", "" },
3469     { "thread_queue_size", HAS_ARG | OPT_INT | OPT_OFFSET | OPT_EXPERT | OPT_INPUT,
3470                                                                      { .off = OFFSET(thread_queue_size) },
3471         "set the maximum number of queued packets from the demuxer" },
3472     { "find_stream_info", OPT_BOOL | OPT_PERFILE | OPT_INPUT | OPT_EXPERT, { &find_stream_info },
3473         "read and decode the streams to fill missing information with heuristics" },
3474
3475     /* video options */
3476     { "vframes",      OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_video_frames },
3477         "set the number of video frames to output", "number" },
3478     { "r",            OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC |
3479                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_rates) },
3480         "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3481     { "s",            OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC |
3482                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_sizes) },
3483         "set frame size (WxH or abbreviation)", "size" },
3484     { "aspect",       OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC |
3485                       OPT_OUTPUT,                                                { .off = OFFSET(frame_aspect_ratios) },
3486         "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3487     { "pix_fmt",      OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
3488                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_pix_fmts) },
3489         "set pixel format", "format" },
3490     { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG,                      { &frame_bits_per_raw_sample },
3491         "set the number of bits per raw sample", "number" },
3492     { "intra",        OPT_VIDEO | OPT_BOOL | OPT_EXPERT,                         { &intra_only },
3493         "deprecated use -g 1" },
3494     { "vn",           OPT_VIDEO | OPT_BOOL  | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) },
3495         "disable video" },
3496     { "rc_override",  OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
3497                       OPT_OUTPUT,                                                { .off = OFFSET(rc_overrides) },
3498         "rate control override for specific intervals", "override" },
3499     { "vcodec",       OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_INPUT |
3500                       OPT_OUTPUT,                                                { .func_arg = opt_video_codec },
3501         "force video codec ('copy' to copy stream)", "codec" },
3502     { "sameq",        OPT_VIDEO | OPT_EXPERT ,                                   { .func_arg = opt_sameq },
3503         "Removed" },
3504     { "same_quant",   OPT_VIDEO | OPT_EXPERT ,                                   { .func_arg = opt_sameq },
3505         "Removed" },
3506     { "timecode",     OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT,            { .func_arg = opt_timecode },
3507         "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
3508     { "pass",         OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT,     { .off = OFFSET(pass) },
3509         "select the pass number (1 to 3)", "n" },
3510     { "passlogfile",  OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
3511                       OPT_OUTPUT,                                                { .off = OFFSET(passlogfiles) },
3512         "select two pass log file name prefix", "prefix" },
3513     { "deinterlace",  OPT_VIDEO | OPT_BOOL | OPT_EXPERT,                         { &do_deinterlace },
3514         "this option is deprecated, use the yadif filter instead" },
3515     { "psnr",         OPT_VIDEO | OPT_BOOL | OPT_EXPERT,                         { &do_psnr },
3516         "calculate PSNR of compressed frames" },
3517     { "vstats",       OPT_VIDEO | OPT_EXPERT ,                                   { .func_arg = opt_vstats },
3518         "dump video coding statistics to file" },
3519     { "vstats_file",  OPT_VIDEO | HAS_ARG | OPT_EXPERT ,                         { .func_arg = opt_vstats_file },
3520         "dump video coding statistics to file", "file" },
3521     { "vstats_version",  OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT ,            { &vstats_version },
3522         "Version of the vstats format to use."},
3523     { "vf",           OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_video_filters },
3524         "set video filters", "filter_graph" },
3525     { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
3526                       OPT_OUTPUT,                                                { .off = OFFSET(intra_matrices) },
3527         "specify intra matrix coeffs", "matrix" },
3528     { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
3529                       OPT_OUTPUT,                                                { .off = OFFSET(inter_matrices) },
3530         "specify inter matrix coeffs", "matrix" },
3531     { "chroma_intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
3532                       OPT_OUTPUT,                                                { .off = OFFSET(chroma_intra_matrices) },
3533         "specify intra matrix coeffs", "matrix" },
3534     { "top",          OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_INT| OPT_SPEC |
3535                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(top_field_first) },
3536         "top=1/bottom=0/auto=-1 field first", "" },
3537     { "vtag",         OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_PERFILE |
3538                       OPT_INPUT | OPT_OUTPUT,                                    { .func_arg = opt_old2new },
3539         "force video tag/fourcc", "fourcc/tag" },
3540     { "qphist",       OPT_VIDEO | OPT_BOOL | OPT_EXPERT ,                        { &qp_hist },
3541         "show QP histogram" },
3542     { "force_fps",    OPT_VIDEO | OPT_BOOL | OPT_EXPERT  | OPT_SPEC |
3543                       OPT_OUTPUT,                                                { .off = OFFSET(force_fps) },
3544         "force the selected framerate, disable the best supported framerate selection" },
3545     { "streamid",     OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3546                       OPT_OUTPUT,                                                { .func_arg = opt_streamid },
3547         "set the value of an outfile streamid", "streamIndex:value" },
3548     { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3549                           OPT_SPEC | OPT_OUTPUT,                                 { .off = OFFSET(forced_key_frames) },
3550         "force key frames at specified timestamps", "timestamps" },
3551     { "ab",           OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT,            { .func_arg = opt_bitrate },
3552         "audio bitrate (please use -b:a)", "bitrate" },
3553     { "b",            OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT,            { .func_arg = opt_bitrate },
3554         "video bitrate (please use -b:v)", "bitrate" },
3555     { "hwaccel",          OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3556                           OPT_SPEC | OPT_INPUT,                                  { .off = OFFSET(hwaccels) },
3557         "use HW accelerated decoding", "hwaccel name" },
3558     { "hwaccel_device",   OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3559                           OPT_SPEC | OPT_INPUT,                                  { .off = OFFSET(hwaccel_devices) },
3560         "select a device for HW acceleration", "devicename" },
3561     { "hwaccel_output_format", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3562                           OPT_SPEC | OPT_INPUT,                                  { .off = OFFSET(hwaccel_output_formats) },
3563         "select output format used with HW accelerated decoding", "format" },
3564 #if CONFIG_VIDEOTOOLBOX
3565     { "videotoolbox_pixfmt", HAS_ARG | OPT_STRING | OPT_EXPERT, { &videotoolbox_pixfmt}, "" },
3566 #endif
3567     { "hwaccels",         OPT_EXIT,                                              { .func_arg = show_hwaccels },
3568         "show available HW acceleration methods" },
3569     { "autorotate",       HAS_ARG | OPT_BOOL | OPT_SPEC |
3570                           OPT_EXPERT | OPT_INPUT,                                { .off = OFFSET(autorotate) },
3571         "automatically insert correct rotate filters" },
3572
3573     /* audio options */
3574     { "aframes",        OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_frames },
3575         "set the number of audio frames to output", "number" },
3576     { "aq",             OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_qscale },
3577         "set audio quality (codec-specific)", "quality", },
3578     { "ar",             OPT_AUDIO | HAS_ARG  | OPT_INT | OPT_SPEC |
3579                         OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(audio_sample_rate) },
3580         "set audio sampling rate (in Hz)", "rate" },
3581     { "ac",             OPT_AUDIO | HAS_ARG  | OPT_INT | OPT_SPEC |
3582                         OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(audio_channels) },
3583         "set number of audio channels", "channels" },
3584     { "an",             OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) },
3585         "disable audio" },
3586     { "acodec",         OPT_AUDIO | HAS_ARG  | OPT_PERFILE |
3587                         OPT_INPUT | OPT_OUTPUT,                                    { .func_arg = opt_audio_codec },
3588         "force audio codec ('copy' to copy stream)", "codec" },
3589     { "atag",           OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_PERFILE |
3590                         OPT_OUTPUT,                                                { .func_arg = opt_old2new },
3591         "force audio tag/fourcc", "fourcc/tag" },
3592     { "vol",            OPT_AUDIO | HAS_ARG  | OPT_INT,                            { &audio_volume },
3593         "change audio volume (256=normal)" , "volume" },
3594     { "sample_fmt",     OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_SPEC |
3595                         OPT_STRING | OPT_INPUT | OPT_OUTPUT,                       { .off = OFFSET(sample_fmts) },
3596         "set sample format", "format" },
3597     { "channel_layout", OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_PERFILE |
3598                         OPT_INPUT | OPT_OUTPUT,                                    { .func_arg = opt_channel_layout },
3599         "set channel layout", "layout" },
3600     { "af",             OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_filters },
3601         "set audio filters", "filter_graph" },
3602     { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
3603       "set the maximum number of channels to try to guess the channel layout" },
3604
3605     /* subtitle options */
3606     { "sn",     OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
3607         "disable subtitle" },
3608     { "scodec", OPT_SUBTITLE | HAS_ARG  | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
3609         "force subtitle codec ('copy' to copy stream)", "codec" },
3610     { "stag",   OPT_SUBTITLE | HAS_ARG  | OPT_EXPERT  | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
3611         , "force subtitle tag/fourcc", "fourcc/tag" },
3612     { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
3613         "fix subtitles duration" },
3614     { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
3615         "set canvas size (WxH or abbreviation)", "size" },
3616
3617     /* grab options */
3618     { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
3619         "deprecated, use -channel", "channel" },
3620     { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
3621         "deprecated, use -standard", "standard" },
3622     { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
3623
3624     /* muxer options */
3625     { "muxdelay",   OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
3626         "set the maximum demux-decode delay", "seconds" },
3627     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
3628         "set the initial demux-decode delay", "seconds" },
3629     { "sdp_file", HAS_ARG | OPT_EXPERT | OPT_OUTPUT, { .func_arg = opt_sdp_file },
3630         "specify a file in which to print sdp information", "file" },
3631
3632     { "time_base", HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(time_bases) },
3633         "set the desired time base hint for output stream (1:24, 1:48000 or 0.04166, 2.0833e-5)", "ratio" },
3634     { "enc_time_base", HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(enc_time_bases) },
3635         "set the desired time base for the encoder (1:24, 1:48000 or 0.04166, 2.0833e-5). "
3636         "two special values are defined - "
3637         "0 = use frame rate (video) or sample rate (audio),"
3638         "-1 = match source time base", "ratio" },
3639
3640     { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
3641         "A comma-separated list of bitstream filters", "bitstream_filters" },
3642     { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3643         "deprecated", "audio bitstream_filters" },
3644     { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3645         "deprecated", "video bitstream_filters" },
3646
3647     { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT,    { .func_arg = opt_preset },
3648         "set the audio options to the indicated preset", "preset" },
3649     { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT,    { .func_arg = opt_preset },
3650         "set the video options to the indicated preset", "preset" },
3651     { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3652         "set the subtitle options to the indicated preset", "preset" },
3653     { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT,                { .func_arg = opt_preset },
3654         "set options from indicated preset file", "filename" },
3655
3656     { "max_muxing_queue_size", HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(max_muxing_queue_size) },
3657         "maximum number of packets that can be buffered while waiting for all streams to initialize", "packets" },
3658
3659     /* data codec support */
3660     { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
3661         "force data codec ('copy' to copy stream)", "codec" },
3662     { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },
3663         "disable data" },
3664
3665 #if CONFIG_VAAPI
3666     { "vaapi_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vaapi_device },
3667         "set VAAPI hardware device (DRM path or X11 display name)", "device" },
3668 #endif
3669
3670 #if CONFIG_QSV
3671     { "qsv_device", HAS_ARG | OPT_STRING | OPT_EXPERT, { &qsv_device },
3672         "set QSV hardware device (DirectX adapter index, DRM path or X11 display name)", "device"},
3673 #endif
3674
3675     { "init_hw_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_init_hw_device },
3676         "initialise hardware device", "args" },
3677     { "filter_hw_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_hw_device },
3678         "set hardware device used when filtering", "device" },
3679
3680     { NULL, },
3681 };