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