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