575ce120dd0eed98d78ee3a016162d3c2dfd68f9
[ffmpeg.git] / avtools / avconv_opt.c
1 /*
2  * avconv option parsing
3  *
4  * This file is part of Libav.
5  *
6  * Libav 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  * Libav 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 Libav; 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 "avconv.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 "av2pass"
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 const HWAccel hwaccels[] = {
59 #if HAVE_VDPAU_X11
60     { "vdpau", hwaccel_decode_init, HWACCEL_VDPAU, AV_PIX_FMT_VDPAU,
61       AV_HWDEVICE_TYPE_VDPAU },
62 #endif
63 #if CONFIG_D3D11VA
64     { "d3d11va", hwaccel_decode_init, HWACCEL_D3D11VA, AV_PIX_FMT_D3D11,
65       AV_HWDEVICE_TYPE_D3D11VA },
66 #endif
67 #if CONFIG_DXVA2
68     { "dxva2", hwaccel_decode_init, HWACCEL_DXVA2, AV_PIX_FMT_DXVA2_VLD,
69       AV_HWDEVICE_TYPE_DXVA2 },
70 #endif
71 #if CONFIG_VDA
72     { "vda",   vda_init,   HWACCEL_VDA,   AV_PIX_FMT_VDA,
73       AV_HWDEVICE_TYPE_NONE },
74 #endif
75 #if CONFIG_LIBMFX
76     { "qsv",   qsv_init,   HWACCEL_QSV,   AV_PIX_FMT_QSV,
77       AV_HWDEVICE_TYPE_NONE },
78 #endif
79 #if CONFIG_VAAPI
80     { "vaapi", hwaccel_decode_init, HWACCEL_VAAPI, AV_PIX_FMT_VAAPI,
81       AV_HWDEVICE_TYPE_VAAPI },
82 #endif
83     { 0 },
84 };
85 int hwaccel_lax_profile_check = 0;
86 AVBufferRef *hw_device_ctx;
87 HWDevice *filter_hw_device;
88
89 char *vstats_filename;
90
91 float audio_drift_threshold = 0.1;
92 float dts_delta_threshold   = 10;
93
94 int audio_volume      = 256;
95 int audio_sync_method = 0;
96 int video_sync_method = VSYNC_AUTO;
97 int do_benchmark      = 0;
98 int do_hex_dump       = 0;
99 int do_pkt_dump       = 0;
100 int copy_ts           = 0;
101 int copy_tb           = 1;
102 int exit_on_error     = 0;
103 int print_stats       = 1;
104 int qp_hist           = 0;
105
106 static int file_overwrite     = 0;
107 static int file_skip          = 0;
108 static int video_discard      = 0;
109 static int intra_dc_precision = 8;
110 static int using_stdin        = 0;
111 static int input_sync;
112
113 static void uninit_options(OptionsContext *o)
114 {
115     const OptionDef *po = options;
116     int i;
117
118     /* all OPT_SPEC and OPT_STRING can be freed in generic way */
119     while (po->name) {
120         void *dst = (uint8_t*)o + po->u.off;
121
122         if (po->flags & OPT_SPEC) {
123             SpecifierOpt **so = dst;
124             int i, *count = (int*)(so + 1);
125             for (i = 0; i < *count; i++) {
126                 av_freep(&(*so)[i].specifier);
127                 if (po->flags & OPT_STRING)
128                     av_freep(&(*so)[i].u.str);
129             }
130             av_freep(so);
131             *count = 0;
132         } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
133             av_freep(dst);
134         po++;
135     }
136
137     for (i = 0; i < o->nb_stream_maps; i++)
138         av_freep(&o->stream_maps[i].linklabel);
139     av_freep(&o->stream_maps);
140     av_freep(&o->meta_data_maps);
141     av_freep(&o->streamid_map);
142 }
143
144 static void init_options(OptionsContext *o)
145 {
146     memset(o, 0, sizeof(*o));
147
148     o->mux_max_delay  = 0.7;
149     o->start_time     = AV_NOPTS_VALUE;
150     o->recording_time = INT64_MAX;
151     o->limit_filesize = UINT64_MAX;
152     o->chapters_input_file = INT_MAX;
153     o->accurate_seek  = 1;
154 }
155
156 /* return a copy of the input with the stream specifiers removed from the keys */
157 static AVDictionary *strip_specifiers(AVDictionary *dict)
158 {
159     AVDictionaryEntry *e = NULL;
160     AVDictionary    *ret = NULL;
161
162     while ((e = av_dict_get(dict, "", e, AV_DICT_IGNORE_SUFFIX))) {
163         char *p = strchr(e->key, ':');
164
165         if (p)
166             *p = 0;
167         av_dict_set(&ret, e->key, e->value, 0);
168         if (p)
169             *p = ':';
170     }
171     return ret;
172 }
173
174 static double parse_frame_aspect_ratio(const char *arg)
175 {
176     int x = 0, y = 0;
177     double ar = 0;
178     const char *p;
179     char *end;
180
181     p = strchr(arg, ':');
182     if (p) {
183         x = strtol(arg, &end, 10);
184         if (end == p)
185             y = strtol(end + 1, &end, 10);
186         if (x > 0 && y > 0)
187             ar = (double)x / (double)y;
188     } else
189         ar = strtod(arg, NULL);
190
191     if (!ar) {
192         av_log(NULL, AV_LOG_FATAL, "Incorrect aspect ratio specification.\n");
193         exit_program(1);
194     }
195     return ar;
196 }
197
198 static int show_hwaccels(void *optctx, const char *opt, const char *arg)
199 {
200     int i;
201
202     printf("Supported hardware acceleration:\n");
203     for (i = 0; hwaccels[i].name; i++) {
204         printf("%s\n", hwaccels[i].name);
205     }
206     printf("\n");
207     return 0;
208 }
209
210 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
211 {
212     OptionsContext *o = optctx;
213     return parse_option(o, "codec:a", arg, options);
214 }
215
216 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
217 {
218     OptionsContext *o = optctx;
219     return parse_option(o, "codec:v", arg, options);
220 }
221
222 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
223 {
224     OptionsContext *o = optctx;
225     return parse_option(o, "codec:s", arg, options);
226 }
227
228 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
229 {
230     OptionsContext *o = optctx;
231     return parse_option(o, "codec:d", arg, options);
232 }
233
234 static int opt_map(void *optctx, const char *opt, const char *arg)
235 {
236     OptionsContext *o = optctx;
237     StreamMap *m = NULL;
238     int i, negative = 0, file_idx;
239     int sync_file_idx = -1, sync_stream_idx;
240     char *p, *sync;
241     char *map;
242
243     if (*arg == '-') {
244         negative = 1;
245         arg++;
246     }
247     map = av_strdup(arg);
248     if (!map)
249         return AVERROR(ENOMEM);
250
251     /* parse sync stream first, just pick first matching stream */
252     if (sync = strchr(map, ',')) {
253         *sync = 0;
254         sync_file_idx = strtol(sync + 1, &sync, 0);
255         if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
256             av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
257             exit_program(1);
258         }
259         if (*sync)
260             sync++;
261         for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
262             if (check_stream_specifier(input_files[sync_file_idx]->ctx,
263                                        input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
264                 sync_stream_idx = i;
265                 break;
266             }
267         if (i == input_files[sync_file_idx]->nb_streams) {
268             av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
269                                        "match any streams.\n", arg);
270             exit_program(1);
271         }
272     }
273
274
275     if (map[0] == '[') {
276         /* this mapping refers to lavfi output */
277         const char *c = map + 1;
278         GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
279         m = &o->stream_maps[o->nb_stream_maps - 1];
280         m->linklabel = av_get_token(&c, "]");
281         if (!m->linklabel) {
282             av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
283             exit_program(1);
284         }
285     } else {
286         file_idx = strtol(map, &p, 0);
287         if (file_idx >= nb_input_files || file_idx < 0) {
288             av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
289             exit_program(1);
290         }
291         if (negative)
292             /* disable some already defined maps */
293             for (i = 0; i < o->nb_stream_maps; i++) {
294                 m = &o->stream_maps[i];
295                 if (file_idx == m->file_index &&
296                     check_stream_specifier(input_files[m->file_index]->ctx,
297                                            input_files[m->file_index]->ctx->streams[m->stream_index],
298                                            *p == ':' ? p + 1 : p) > 0)
299                     m->disabled = 1;
300             }
301         else
302             for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
303                 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
304                             *p == ':' ? p + 1 : p) <= 0)
305                     continue;
306                 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
307                 m = &o->stream_maps[o->nb_stream_maps - 1];
308
309                 m->file_index   = file_idx;
310                 m->stream_index = i;
311
312                 if (sync_file_idx >= 0) {
313                     m->sync_file_index   = sync_file_idx;
314                     m->sync_stream_index = sync_stream_idx;
315                 } else {
316                     m->sync_file_index   = file_idx;
317                     m->sync_stream_index = i;
318                 }
319             }
320     }
321
322     if (!m) {
323         av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
324         exit_program(1);
325     }
326
327     av_freep(&map);
328     return 0;
329 }
330
331 static int opt_attach(void *optctx, const char *opt, const char *arg)
332 {
333     OptionsContext *o = optctx;
334     GROW_ARRAY(o->attachments, o->nb_attachments);
335     o->attachments[o->nb_attachments - 1] = arg;
336     return 0;
337 }
338
339 #if CONFIG_VAAPI
340 static int opt_vaapi_device(void *optctx, const char *opt, const char *arg)
341 {
342     HWDevice *dev;
343     const char *prefix = "vaapi:";
344     char *tmp;
345     int err;
346     tmp = av_malloc(strlen(prefix) + strlen(arg) + 1);
347     if (!tmp)
348         return AVERROR(ENOMEM);
349     strcpy(tmp, prefix);
350     strcat(tmp, arg);
351     err = hw_device_init_from_string(tmp, &dev);
352     av_free(tmp);
353     if (err < 0)
354         return err;
355     hw_device_ctx = av_buffer_ref(dev->device_ref);
356     if (!hw_device_ctx)
357         return AVERROR(ENOMEM);
358     return 0;
359 }
360 #endif
361
362 static int opt_init_hw_device(void *optctx, const char *opt, const char *arg)
363 {
364     if (!strcmp(arg, "list")) {
365         enum AVHWDeviceType type = AV_HWDEVICE_TYPE_NONE;
366         printf("Supported hardware device types:\n");
367         while ((type = av_hwdevice_iterate_types(type)) !=
368                AV_HWDEVICE_TYPE_NONE)
369             printf("%s\n", av_hwdevice_get_type_name(type));
370         printf("\n");
371         exit_program(0);
372     } else {
373         return hw_device_init_from_string(arg, NULL);
374     }
375 }
376
377 static int opt_filter_hw_device(void *optctx, const char *opt, const char *arg)
378 {
379     if (filter_hw_device) {
380         av_log(NULL, AV_LOG_ERROR, "Only one filter device can be used.\n");
381         return AVERROR(EINVAL);
382     }
383     filter_hw_device = hw_device_get_by_name(arg);
384     if (!filter_hw_device) {
385         av_log(NULL, AV_LOG_ERROR, "Invalid filter device %s.\n", arg);
386         return AVERROR(EINVAL);
387     }
388     return 0;
389 }
390
391 /**
392  * Parse a metadata specifier passed as 'arg' parameter.
393  * @param arg  metadata string to parse
394  * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
395  * @param index for type c/p, chapter/program index is written here
396  * @param stream_spec for type s, the stream specifier is written here
397  */
398 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
399 {
400     if (*arg) {
401         *type = *arg;
402         switch (*arg) {
403         case 'g':
404             break;
405         case 's':
406             if (*(++arg) && *arg != ':') {
407                 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
408                 exit_program(1);
409             }
410             *stream_spec = *arg == ':' ? arg + 1 : "";
411             break;
412         case 'c':
413         case 'p':
414             if (*(++arg) == ':')
415                 *index = strtol(++arg, NULL, 0);
416             break;
417         default:
418             av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
419             exit_program(1);
420         }
421     } else
422         *type = 'g';
423 }
424
425 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
426 {
427     AVDictionary **meta_in = NULL;
428     AVDictionary **meta_out;
429     int i, ret = 0;
430     char type_in, type_out;
431     const char *istream_spec = NULL, *ostream_spec = NULL;
432     int idx_in = 0, idx_out = 0;
433
434     parse_meta_type(inspec,  &type_in,  &idx_in,  &istream_spec);
435     parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
436
437     if (type_in == 'g' || type_out == 'g')
438         o->metadata_global_manual = 1;
439     if (type_in == 's' || type_out == 's')
440         o->metadata_streams_manual = 1;
441     if (type_in == 'c' || type_out == 'c')
442         o->metadata_chapters_manual = 1;
443
444     /* ic is NULL when just disabling automatic mappings */
445     if (!ic)
446         return 0;
447
448 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
449     if ((index) < 0 || (index) >= (nb_elems)) {\
450         av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
451                 (desc), (index));\
452         exit_program(1);\
453     }
454
455 #define SET_DICT(type, meta, context, index)\
456         switch (type) {\
457         case 'g':\
458             meta = &context->metadata;\
459             break;\
460         case 'c':\
461             METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
462             meta = &context->chapters[index]->metadata;\
463             break;\
464         case 'p':\
465             METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
466             meta = &context->programs[index]->metadata;\
467             break;\
468         case 's':\
469             break; /* handled separately below */ \
470         default: av_assert0(0);\
471         }\
472
473     SET_DICT(type_in, meta_in, ic, idx_in);
474     SET_DICT(type_out, meta_out, oc, idx_out);
475
476     /* for input streams choose first matching stream */
477     if (type_in == 's') {
478         for (i = 0; i < ic->nb_streams; i++) {
479             if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
480                 meta_in = &ic->streams[i]->metadata;
481                 break;
482             } else if (ret < 0)
483                 exit_program(1);
484         }
485         if (!meta_in) {
486             av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match  any streams.\n", istream_spec);
487             exit_program(1);
488         }
489     }
490
491     if (type_out == 's') {
492         for (i = 0; i < oc->nb_streams; i++) {
493             if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
494                 meta_out = &oc->streams[i]->metadata;
495                 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
496             } else if (ret < 0)
497                 exit_program(1);
498         }
499     } else
500         av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
501
502     return 0;
503 }
504
505 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
506 {
507     const AVCodecDescriptor *desc;
508     const char *codec_string = encoder ? "encoder" : "decoder";
509     AVCodec *codec;
510
511     codec = encoder ?
512         avcodec_find_encoder_by_name(name) :
513         avcodec_find_decoder_by_name(name);
514
515     if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
516         codec = encoder ? avcodec_find_encoder(desc->id) :
517                           avcodec_find_decoder(desc->id);
518         if (codec)
519             av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
520                    codec_string, codec->name, desc->name);
521     }
522
523     if (!codec) {
524         av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
525         exit_program(1);
526     }
527     if (codec->type != type) {
528         av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
529         exit_program(1);
530     }
531     return codec;
532 }
533
534 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
535 {
536     char *codec_name = NULL;
537
538     MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
539     if (codec_name) {
540         AVCodec *codec = find_codec_or_die(codec_name, st->codecpar->codec_type, 0);
541         st->codecpar->codec_id = codec->id;
542         return codec;
543     } else
544         return avcodec_find_decoder(st->codecpar->codec_id);
545 }
546
547 /* Add all the streams from the given input file to the global
548  * list of input streams. */
549 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
550 {
551     int i, ret;
552
553     for (i = 0; i < ic->nb_streams; i++) {
554         AVStream *st = ic->streams[i];
555         AVCodecParameters *par = st->codecpar;
556         InputStream *ist = av_mallocz(sizeof(*ist));
557         char *framerate = NULL, *hwaccel = NULL, *hwaccel_device = NULL;
558         char *hwaccel_output_format = NULL;
559         char *codec_tag = NULL;
560         char *next;
561
562         if (!ist)
563             exit_program(1);
564
565         GROW_ARRAY(input_streams, nb_input_streams);
566         input_streams[nb_input_streams - 1] = ist;
567
568         ist->st = st;
569         ist->file_index = nb_input_files;
570         ist->discard = 1;
571         st->discard  = AVDISCARD_ALL;
572         ist->nb_samples = 0;
573         ist->min_pts = INT64_MAX;
574         ist->max_pts = INT64_MIN;
575
576         ist->ts_scale = 1.0;
577         MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
578
579         ist->autorotate = 1;
580         MATCH_PER_STREAM_OPT(autorotate, i, ist->autorotate, ic, st);
581
582         MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
583         if (codec_tag) {
584             uint32_t tag = strtol(codec_tag, &next, 0);
585             if (*next)
586                 tag = AV_RL32(codec_tag);
587             st->codecpar->codec_tag = tag;
588         }
589
590         ist->dec = choose_decoder(o, ic, st);
591         ist->decoder_opts = filter_codec_opts(o->g->codec_opts, par->codec_id, ic, st, ist->dec);
592
593         ist->dec_ctx = avcodec_alloc_context3(ist->dec);
594         if (!ist->dec_ctx) {
595             av_log(NULL, AV_LOG_ERROR, "Error allocating the decoder context.\n");
596             exit_program(1);
597         }
598
599         ret = avcodec_parameters_to_context(ist->dec_ctx, par);
600         if (ret < 0) {
601             av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
602             exit_program(1);
603         }
604
605         switch (par->codec_type) {
606         case AVMEDIA_TYPE_VIDEO:
607             MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
608             if (framerate && av_parse_video_rate(&ist->framerate,
609                                                  framerate) < 0) {
610                 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
611                        framerate);
612                 exit_program(1);
613             }
614
615             MATCH_PER_STREAM_OPT(hwaccels, str, hwaccel, ic, st);
616             if (hwaccel) {
617                 if (!strcmp(hwaccel, "none"))
618                     ist->hwaccel_id = HWACCEL_NONE;
619                 else if (!strcmp(hwaccel, "auto"))
620                     ist->hwaccel_id = HWACCEL_AUTO;
621                 else {
622                     int i;
623                     for (i = 0; hwaccels[i].name; i++) {
624                         if (!strcmp(hwaccels[i].name, hwaccel)) {
625                             ist->hwaccel_id = hwaccels[i].id;
626                             break;
627                         }
628                     }
629
630                     if (!ist->hwaccel_id) {
631                         av_log(NULL, AV_LOG_FATAL, "Unrecognized hwaccel: %s.\n",
632                                hwaccel);
633                         av_log(NULL, AV_LOG_FATAL, "Supported hwaccels: ");
634                         for (i = 0; hwaccels[i].name; i++)
635                             av_log(NULL, AV_LOG_FATAL, "%s ", hwaccels[i].name);
636                         av_log(NULL, AV_LOG_FATAL, "\n");
637                         exit_program(1);
638                     }
639                 }
640             }
641
642             MATCH_PER_STREAM_OPT(hwaccel_devices, str, hwaccel_device, ic, st);
643             if (hwaccel_device) {
644                 ist->hwaccel_device = av_strdup(hwaccel_device);
645                 if (!ist->hwaccel_device)
646                     exit_program(1);
647             }
648
649             MATCH_PER_STREAM_OPT(hwaccel_output_formats, str,
650                                  hwaccel_output_format, ic, st);
651             if (hwaccel_output_format) {
652                 ist->hwaccel_output_format = av_get_pix_fmt(hwaccel_output_format);
653                 if (ist->hwaccel_output_format == AV_PIX_FMT_NONE) {
654                     av_log(NULL, AV_LOG_FATAL, "Unrecognised hwaccel output "
655                            "format: %s", hwaccel_output_format);
656                 }
657             } else {
658                 ist->hwaccel_output_format = AV_PIX_FMT_NONE;
659             }
660
661             ist->hwaccel_pix_fmt = AV_PIX_FMT_NONE;
662
663             break;
664         case AVMEDIA_TYPE_AUDIO:
665             guess_input_channel_layout(ist);
666             break;
667         case AVMEDIA_TYPE_DATA:
668         case AVMEDIA_TYPE_SUBTITLE:
669         case AVMEDIA_TYPE_ATTACHMENT:
670         case AVMEDIA_TYPE_UNKNOWN:
671             break;
672         default:
673             abort();
674         }
675     }
676 }
677
678 static void assert_file_overwrite(const char *filename)
679 {
680     if (file_overwrite && file_skip) {
681         fprintf(stderr, "Error, both -y and -n supplied. Exiting.\n");
682         exit_program(1);
683     }
684
685     if (!file_overwrite &&
686         (!strchr(filename, ':') || filename[1] == ':' ||
687          av_strstart(filename, "file:", NULL))) {
688         if (avio_check(filename, 0) == 0) {
689             if (!using_stdin && !file_skip) {
690                 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
691                 fflush(stderr);
692                 if (!read_yesno()) {
693                     fprintf(stderr, "Not overwriting - exiting\n");
694                     exit_program(1);
695                 }
696             }
697             else {
698                 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
699                 exit_program(1);
700             }
701         }
702     }
703 }
704
705 static void dump_attachment(AVStream *st, const char *filename)
706 {
707     int ret;
708     AVIOContext *out = NULL;
709     AVDictionaryEntry *e;
710
711     if (!st->codecpar->extradata_size) {
712         av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
713                nb_input_files - 1, st->index);
714         return;
715     }
716     if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
717         filename = e->value;
718     if (!*filename) {
719         av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
720                "in stream #%d:%d.\n", nb_input_files - 1, st->index);
721         exit_program(1);
722     }
723
724     assert_file_overwrite(filename);
725
726     if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
727         av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
728                filename);
729         exit_program(1);
730     }
731
732     avio_write(out, st->codecpar->extradata, st->codecpar->extradata_size);
733     avio_flush(out);
734     avio_close(out);
735 }
736
737 static int open_input_file(OptionsContext *o, const char *filename)
738 {
739     InputFile *f;
740     AVFormatContext *ic;
741     AVInputFormat *file_iformat = NULL;
742     int err, i, ret;
743     int64_t timestamp;
744     uint8_t buf[128];
745     AVDictionary **opts;
746     AVDictionary *unused_opts = NULL;
747     AVDictionaryEntry *e = NULL;
748     int orig_nb_streams;                     // number of streams before avformat_find_stream_info
749
750     if (o->format) {
751         if (!(file_iformat = av_find_input_format(o->format))) {
752             av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
753             exit_program(1);
754         }
755     }
756
757     if (!strcmp(filename, "-"))
758         filename = "pipe:";
759
760     using_stdin |= !strncmp(filename, "pipe:", 5) ||
761                     !strcmp(filename, "/dev/stdin");
762
763     /* get default parameters from command line */
764     ic = avformat_alloc_context();
765     if (!ic) {
766         print_error(filename, AVERROR(ENOMEM));
767         exit_program(1);
768     }
769     if (o->nb_audio_sample_rate) {
770         snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
771         av_dict_set(&o->g->format_opts, "sample_rate", buf, 0);
772     }
773     if (o->nb_audio_channels) {
774         /* because we set audio_channels based on both the "ac" and
775          * "channel_layout" options, we need to check that the specified
776          * demuxer actually has the "channels" option before setting it */
777         if (file_iformat && file_iformat->priv_class &&
778             av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
779                         AV_OPT_SEARCH_FAKE_OBJ)) {
780             snprintf(buf, sizeof(buf), "%d",
781                      o->audio_channels[o->nb_audio_channels - 1].u.i);
782             av_dict_set(&o->g->format_opts, "channels", buf, 0);
783         }
784     }
785     if (o->nb_frame_rates) {
786         /* set the format-level framerate option;
787          * this is important for video grabbers, e.g. x11 */
788         if (file_iformat && file_iformat->priv_class &&
789             av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
790                         AV_OPT_SEARCH_FAKE_OBJ)) {
791             av_dict_set(&o->g->format_opts, "framerate",
792                         o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
793         }
794     }
795     if (o->nb_frame_sizes) {
796         av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
797     }
798     if (o->nb_frame_pix_fmts)
799         av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
800
801     ic->flags |= AVFMT_FLAG_NONBLOCK;
802     ic->interrupt_callback = int_cb;
803
804     /* open the input file with generic Libav function */
805     err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
806     if (err < 0) {
807         print_error(filename, err);
808         exit_program(1);
809     }
810     assert_avoptions(o->g->format_opts);
811
812     /* apply forced codec ids */
813     for (i = 0; i < ic->nb_streams; i++)
814         choose_decoder(o, ic, ic->streams[i]);
815
816     /* Set AVCodecContext options for avformat_find_stream_info */
817     opts = setup_find_stream_info_opts(ic, o->g->codec_opts);
818     orig_nb_streams = ic->nb_streams;
819
820     /* If not enough info to get the stream parameters, we decode the
821        first frames to get it. (used in mpeg case for example) */
822     ret = avformat_find_stream_info(ic, opts);
823     if (ret < 0) {
824         av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
825         avformat_close_input(&ic);
826         exit_program(1);
827     }
828
829     timestamp = (o->start_time == AV_NOPTS_VALUE) ? 0 : o->start_time;
830     /* add the stream start time */
831     if (ic->start_time != AV_NOPTS_VALUE)
832         timestamp += ic->start_time;
833
834     /* if seeking requested, we execute it */
835     if (o->start_time != AV_NOPTS_VALUE) {
836         ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
837         if (ret < 0) {
838             av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
839                    filename, (double)timestamp / AV_TIME_BASE);
840         }
841     }
842
843     /* update the current parameters so that they match the one of the input stream */
844     add_input_streams(o, ic);
845
846     /* dump the file content */
847     av_dump_format(ic, nb_input_files, filename, 0);
848
849     GROW_ARRAY(input_files, nb_input_files);
850     f = av_mallocz(sizeof(*f));
851     if (!f)
852         exit_program(1);
853     input_files[nb_input_files - 1] = f;
854
855     f->ctx        = ic;
856     f->ist_index  = nb_input_streams - ic->nb_streams;
857     f->start_time = o->start_time;
858     f->recording_time = o->recording_time;
859     f->ts_offset  = o->input_ts_offset - (copy_ts ? 0 : timestamp);
860     f->nb_streams = ic->nb_streams;
861     f->rate_emu   = o->rate_emu;
862     f->accurate_seek = o->accurate_seek;
863     f->loop = o->loop;
864     f->duration = 0;
865     f->time_base = (AVRational){ 1, 1 };
866
867     /* check if all codec options have been used */
868     unused_opts = strip_specifiers(o->g->codec_opts);
869     for (i = f->ist_index; i < nb_input_streams; i++) {
870         e = NULL;
871         while ((e = av_dict_get(input_streams[i]->decoder_opts, "", e,
872                                 AV_DICT_IGNORE_SUFFIX)))
873             av_dict_set(&unused_opts, e->key, NULL, 0);
874     }
875
876     e = NULL;
877     while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
878         const AVClass *class = avcodec_get_class();
879         const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
880                                              AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
881         if (!option)
882             continue;
883         if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) {
884             av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
885                    "input file #%d (%s) is not a decoding option.\n", e->key,
886                    option->help ? option->help : "", nb_input_files - 1,
887                    filename);
888             exit_program(1);
889         }
890
891         av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
892                "input file #%d (%s) has not been used for any stream. The most "
893                "likely reason is either wrong type (e.g. a video option with "
894                "no video streams) or that it is a private option of some decoder "
895                "which was not actually used for any stream.\n", e->key,
896                option->help ? option->help : "", nb_input_files - 1, filename);
897     }
898     av_dict_free(&unused_opts);
899
900     for (i = 0; i < o->nb_dump_attachment; i++) {
901         int j;
902
903         for (j = 0; j < ic->nb_streams; j++) {
904             AVStream *st = ic->streams[j];
905
906             if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
907                 dump_attachment(st, o->dump_attachment[i].u.str);
908         }
909     }
910
911     for (i = 0; i < orig_nb_streams; i++)
912         av_dict_free(&opts[i]);
913     av_freep(&opts);
914
915     return 0;
916 }
917
918 static uint8_t *get_line(AVIOContext *s)
919 {
920     AVIOContext *line;
921     uint8_t *buf;
922     char c;
923
924     if (avio_open_dyn_buf(&line) < 0) {
925         av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
926         exit_program(1);
927     }
928
929     while ((c = avio_r8(s)) && c != '\n')
930         avio_w8(line, c);
931     avio_w8(line, 0);
932     avio_close_dyn_buf(line, &buf);
933
934     return buf;
935 }
936
937 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
938 {
939     int i, ret = -1;
940     char filename[1000];
941     const char *base[3] = { getenv("AVCONV_DATADIR"),
942                             getenv("HOME"),
943                             AVCONV_DATADIR,
944                             };
945
946     for (i = 0; i < FF_ARRAY_ELEMS(base) && ret < 0; i++) {
947         if (!base[i])
948             continue;
949         if (codec_name) {
950             snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
951                      i != 1 ? "" : "/.avconv", codec_name, preset_name);
952             ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
953         }
954         if (ret < 0) {
955             snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
956                      i != 1 ? "" : "/.avconv", preset_name);
957             ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
958         }
959     }
960     return ret;
961 }
962
963 static int choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
964 {
965     enum AVMediaType type = ost->st->codecpar->codec_type;
966     char *codec_name = NULL;
967
968     if (type == AVMEDIA_TYPE_VIDEO || type == AVMEDIA_TYPE_AUDIO || type == AVMEDIA_TYPE_SUBTITLE) {
969         MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
970         if (!codec_name) {
971             ost->st->codecpar->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
972                                                          NULL, ost->st->codecpar->codec_type);
973             ost->enc = avcodec_find_encoder(ost->st->codecpar->codec_id);
974             if (!ost->enc) {
975                 av_log(NULL, AV_LOG_FATAL, "Automatic encoder selection failed for "
976                        "output stream #%d:%d. Default encoder for format %s is "
977                        "probably disabled. Please choose an encoder manually.\n",
978                        ost->file_index, ost->index, s->oformat->name);
979                 return AVERROR_ENCODER_NOT_FOUND;
980             }
981         } else if (!strcmp(codec_name, "copy"))
982             ost->stream_copy = 1;
983         else {
984             ost->enc = find_codec_or_die(codec_name, ost->st->codecpar->codec_type, 1);
985             ost->st->codecpar->codec_id = ost->enc->id;
986         }
987
988         ost->encoding_needed = !ost->stream_copy;
989     } else {
990         /* no encoding supported for other media types */
991         ost->stream_copy     = 1;
992         ost->encoding_needed = 0;
993     }
994
995     return 0;
996 }
997
998 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type)
999 {
1000     OutputStream *ost;
1001     AVStream *st = avformat_new_stream(oc, NULL);
1002     int idx      = oc->nb_streams - 1, ret = 0;
1003     const char *bsfs = NULL;
1004     char *next, *codec_tag = NULL;
1005     double qscale = -1;
1006     int bitrate = 0;
1007
1008     if (!st) {
1009         av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
1010         exit_program(1);
1011     }
1012
1013     if (oc->nb_streams - 1 < o->nb_streamid_map)
1014         st->id = o->streamid_map[oc->nb_streams - 1];
1015
1016     GROW_ARRAY(output_streams, nb_output_streams);
1017     if (!(ost = av_mallocz(sizeof(*ost))))
1018         exit_program(1);
1019     output_streams[nb_output_streams - 1] = ost;
1020
1021     ost->file_index = nb_output_files - 1;
1022     ost->index      = idx;
1023     ost->st         = st;
1024     st->codecpar->codec_type = type;
1025
1026     ret = choose_encoder(o, oc, ost);
1027     if (ret < 0) {
1028         av_log(NULL, AV_LOG_FATAL, "Error selecting an encoder for stream "
1029                "%d:%d\n", ost->file_index, ost->index);
1030         exit_program(1);
1031     }
1032
1033     ost->enc_ctx = avcodec_alloc_context3(ost->enc);
1034     if (!ost->enc_ctx) {
1035         av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding context.\n");
1036         exit_program(1);
1037     }
1038     ost->enc_ctx->codec_type = type;
1039
1040     if (ost->enc) {
1041         AVIOContext *s = NULL;
1042         char *buf = NULL, *arg = NULL, *preset = NULL;
1043
1044         ost->encoder_opts  = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
1045
1046         MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
1047         if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
1048             do  {
1049                 buf = get_line(s);
1050                 if (!buf[0] || buf[0] == '#') {
1051                     av_free(buf);
1052                     continue;
1053                 }
1054                 if (!(arg = strchr(buf, '='))) {
1055                     av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
1056                     exit_program(1);
1057                 }
1058                 *arg++ = 0;
1059                 av_dict_set(&ost->encoder_opts, buf, arg, AV_DICT_DONT_OVERWRITE);
1060                 av_free(buf);
1061             } while (!s->eof_reached);
1062             avio_close(s);
1063         }
1064         if (ret) {
1065             av_log(NULL, AV_LOG_FATAL,
1066                    "Preset %s specified for stream %d:%d, but could not be opened.\n",
1067                    preset, ost->file_index, ost->index);
1068             exit_program(1);
1069         }
1070     } else {
1071         ost->encoder_opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
1072     }
1073
1074     ost->max_frames = INT64_MAX;
1075     MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
1076
1077     MATCH_PER_STREAM_OPT(bitstream_filters, str, bsfs, oc, st);
1078     while (bsfs && *bsfs) {
1079         const AVBitStreamFilter *filter;
1080         const char *bsf, *bsf_options_str, *bsf_name;
1081         AVDictionary *bsf_options = NULL;
1082
1083         bsf = bsf_options_str = av_get_token(&bsfs, ",");
1084         if (!bsf)
1085             exit_program(1);
1086         bsf_name = av_get_token(&bsf_options_str, "=");
1087         if (!bsf_name)
1088             exit_program(1);
1089
1090         filter = av_bsf_get_by_name(bsf_name);
1091         if (!filter) {
1092             av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf_name);
1093             exit_program(1);
1094         }
1095         if (*bsf_options_str++) {
1096             ret = av_dict_parse_string(&bsf_options, bsf_options_str, "=", ":", 0);
1097             if (ret < 0) {
1098                 av_log(NULL, AV_LOG_ERROR, "Error parsing options for bitstream filter %s\n", bsf_name);
1099                 exit_program(1);
1100             }
1101         }
1102         av_freep(&bsf);
1103
1104         ost->bsf_ctx = av_realloc_array(ost->bsf_ctx,
1105                                         ost->nb_bitstream_filters + 1,
1106                                         sizeof(*ost->bsf_ctx));
1107         if (!ost->bsf_ctx)
1108             exit_program(1);
1109
1110         ret = av_bsf_alloc(filter, &ost->bsf_ctx[ost->nb_bitstream_filters]);
1111         if (ret < 0) {
1112             av_log(NULL, AV_LOG_ERROR, "Error allocating a bistream filter context\n");
1113             exit_program(1);
1114         }
1115         ost->nb_bitstream_filters++;
1116
1117         if (bsf_options) {
1118             ret = av_opt_set_dict(ost->bsf_ctx[ost->nb_bitstream_filters-1]->priv_data, &bsf_options);
1119             if (ret < 0) {
1120                 av_log(NULL, AV_LOG_ERROR, "Error setting options for bitstream filter %s\n", bsf_name);
1121                 exit_program(1);
1122             }
1123             assert_avoptions(bsf_options);
1124             av_dict_free(&bsf_options);
1125         }
1126         av_freep(&bsf_name);
1127
1128         if (*bsfs)
1129             bsfs++;
1130     }
1131
1132     MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1133     if (codec_tag) {
1134         uint32_t tag = strtol(codec_tag, &next, 0);
1135         if (*next)
1136             tag = AV_RL32(codec_tag);
1137         ost->enc_ctx->codec_tag = tag;
1138     }
1139
1140     MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1141     if (qscale >= 0) {
1142         ost->enc_ctx->flags |= AV_CODEC_FLAG_QSCALE;
1143         ost->enc_ctx->global_quality = FF_QP2LAMBDA * qscale;
1144     }
1145
1146     MATCH_PER_STREAM_OPT(bitrates, i, bitrate, oc, st);
1147     if (bitrate > 0) {
1148         if (ost->stream_copy)
1149             ost->bitrate_override = bitrate;
1150         else
1151             ost->enc_ctx->bit_rate = bitrate;
1152     }
1153
1154     ost->max_muxing_queue_size = 128;
1155     MATCH_PER_STREAM_OPT(max_muxing_queue_size, i, ost->max_muxing_queue_size, oc, st);
1156     ost->max_muxing_queue_size *= sizeof(AVPacket);
1157
1158     if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1159         ost->enc_ctx->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
1160
1161     av_opt_get_int(o->g->sws_opts, "sws_flags", 0, &ost->sws_flags);
1162
1163     av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1164
1165     ost->pix_fmts[0] = ost->pix_fmts[1] = AV_PIX_FMT_NONE;
1166     ost->last_mux_dts = AV_NOPTS_VALUE;
1167
1168     ost->muxing_queue = av_fifo_alloc(8 * sizeof(AVPacket));
1169     if (!ost->muxing_queue)
1170         exit_program(1);
1171
1172     return ost;
1173 }
1174
1175 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1176 {
1177     int i;
1178     const char *p = str;
1179     for (i = 0;; i++) {
1180         dest[i] = atoi(p);
1181         if (i == 63)
1182             break;
1183         p = strchr(p, ',');
1184         if (!p) {
1185             av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1186             exit_program(1);
1187         }
1188         p++;
1189     }
1190 }
1191
1192 /* read file contents into a string */
1193 static uint8_t *read_file(const char *filename)
1194 {
1195     AVIOContext *pb      = NULL;
1196     AVIOContext *dyn_buf = NULL;
1197     int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1198     uint8_t buf[1024], *str;
1199
1200     if (ret < 0) {
1201         av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1202         return NULL;
1203     }
1204
1205     ret = avio_open_dyn_buf(&dyn_buf);
1206     if (ret < 0) {
1207         avio_closep(&pb);
1208         return NULL;
1209     }
1210     while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1211         avio_write(dyn_buf, buf, ret);
1212     avio_w8(dyn_buf, 0);
1213     avio_closep(&pb);
1214
1215     ret = avio_close_dyn_buf(dyn_buf, &str);
1216     if (ret < 0)
1217         return NULL;
1218     return str;
1219 }
1220
1221 static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
1222                              OutputStream *ost)
1223 {
1224     AVStream *st = ost->st;
1225     char *filter = NULL, *filter_script = NULL;
1226
1227     MATCH_PER_STREAM_OPT(filter_scripts, str, filter_script, oc, st);
1228     MATCH_PER_STREAM_OPT(filters, str, filter, oc, st);
1229
1230     if (filter_script && filter) {
1231         av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1232                "output stream #%d:%d.\n", nb_output_files, st->index);
1233         exit_program(1);
1234     }
1235
1236     if (filter_script)
1237         return read_file(filter_script);
1238     else if (filter)
1239         return av_strdup(filter);
1240
1241     return av_strdup(st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ?
1242                      "null" : "anull");
1243 }
1244
1245 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc)
1246 {
1247     AVStream *st;
1248     OutputStream *ost;
1249     AVCodecContext *video_enc;
1250     char *frame_aspect_ratio = NULL;
1251
1252     ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO);
1253     st  = ost->st;
1254     video_enc = ost->enc_ctx;
1255
1256     MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1257     if (frame_aspect_ratio)
1258         ost->frame_aspect_ratio = parse_frame_aspect_ratio(frame_aspect_ratio);
1259
1260     if (!ost->stream_copy) {
1261         const char *p = NULL;
1262         char *frame_rate = NULL, *frame_size = NULL;
1263         char *frame_pix_fmt = NULL;
1264         char *intra_matrix = NULL, *inter_matrix = NULL;
1265         int do_pass = 0;
1266         int i;
1267
1268         MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1269         if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1270             av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1271             exit_program(1);
1272         }
1273
1274         MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1275         if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1276             av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1277             exit_program(1);
1278         }
1279
1280         MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1281         if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1282             av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1283             exit_program(1);
1284         }
1285         st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1286
1287         MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1288         if (intra_matrix) {
1289             if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1290                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1291                 exit_program(1);
1292             }
1293             parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1294         }
1295         MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1296         if (inter_matrix) {
1297             if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1298                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1299                 exit_program(1);
1300             }
1301             parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1302         }
1303
1304         MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1305         for (i = 0; p; i++) {
1306             int start, end, q;
1307             int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1308             if (e != 3) {
1309                 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1310                 exit_program(1);
1311             }
1312             video_enc->rc_override =
1313                 av_realloc(video_enc->rc_override,
1314                            sizeof(RcOverride) * (i + 1));
1315             if (!video_enc->rc_override) {
1316                 av_log(NULL, AV_LOG_FATAL, "Could not (re)allocate memory for rc_override.\n");
1317                 exit_program(1);
1318             }
1319             video_enc->rc_override[i].start_frame = start;
1320             video_enc->rc_override[i].end_frame   = end;
1321             if (q > 0) {
1322                 video_enc->rc_override[i].qscale         = q;
1323                 video_enc->rc_override[i].quality_factor = 1.0;
1324             }
1325             else {
1326                 video_enc->rc_override[i].qscale         = 0;
1327                 video_enc->rc_override[i].quality_factor = -q/100.0;
1328             }
1329             p = strchr(p, '/');
1330             if (p) p++;
1331         }
1332         video_enc->rc_override_count = i;
1333         video_enc->intra_dc_precision = intra_dc_precision - 8;
1334
1335         /* two pass mode */
1336         MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1337         if (do_pass) {
1338             if (do_pass == 1) {
1339                 video_enc->flags |= AV_CODEC_FLAG_PASS1;
1340             } else {
1341                 video_enc->flags |= AV_CODEC_FLAG_PASS2;
1342             }
1343         }
1344
1345         MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1346         if (ost->logfile_prefix &&
1347             !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1348             exit_program(1);
1349
1350         if (do_pass) {
1351             char logfilename[1024];
1352             FILE *f;
1353
1354             snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1355                      ost->logfile_prefix ? ost->logfile_prefix :
1356                                            DEFAULT_PASS_LOGFILENAME_PREFIX,
1357                      i);
1358             if (!strcmp(ost->enc->name, "libx264")) {
1359                 av_dict_set(&ost->encoder_opts, "stats", logfilename, AV_DICT_DONT_OVERWRITE);
1360             } else {
1361                 if (video_enc->flags & AV_CODEC_FLAG_PASS1) {
1362                     f = fopen(logfilename, "wb");
1363                     if (!f) {
1364                         av_log(NULL, AV_LOG_FATAL, "Cannot write log file '%s' for pass-1 encoding: %s\n",
1365                                logfilename, strerror(errno));
1366                         exit_program(1);
1367                     }
1368                     ost->logfile = f;
1369                 } else {
1370                     char  *logbuffer = read_file(logfilename);
1371
1372                     if (!logbuffer) {
1373                         av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
1374                                logfilename);
1375                         exit_program(1);
1376                     }
1377                     video_enc->stats_in = logbuffer;
1378                 }
1379             }
1380         }
1381
1382         MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1383         if (ost->forced_keyframes)
1384             ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1385
1386         MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1387
1388         ost->top_field_first = -1;
1389         MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1390
1391
1392         ost->avfilter = get_ost_filters(o, oc, ost);
1393         if (!ost->avfilter)
1394             exit_program(1);
1395     } else {
1396         MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1397     }
1398
1399     return ost;
1400 }
1401
1402 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc)
1403 {
1404     AVStream *st;
1405     OutputStream *ost;
1406     AVCodecContext *audio_enc;
1407
1408     ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO);
1409     st  = ost->st;
1410
1411     audio_enc = ost->enc_ctx;
1412     audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1413
1414     if (!ost->stream_copy) {
1415         char *sample_fmt = NULL;
1416
1417         MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1418
1419         MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1420         if (sample_fmt &&
1421             (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1422             av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1423             exit_program(1);
1424         }
1425
1426         MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1427
1428         ost->avfilter = get_ost_filters(o, oc, ost);
1429         if (!ost->avfilter)
1430             exit_program(1);
1431     }
1432
1433     return ost;
1434 }
1435
1436 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc)
1437 {
1438     OutputStream *ost;
1439
1440     ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA);
1441     if (!ost->stream_copy) {
1442         av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1443         exit_program(1);
1444     }
1445
1446     return ost;
1447 }
1448
1449 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc)
1450 {
1451     OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT);
1452     ost->stream_copy = 1;
1453     ost->finished    = 1;
1454     return ost;
1455 }
1456
1457 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc)
1458 {
1459     OutputStream *ost;
1460     AVCodecContext *subtitle_enc;
1461
1462     ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE);
1463     subtitle_enc = ost->enc_ctx;
1464
1465     subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1466
1467     return ost;
1468 }
1469
1470 /* arg format is "output-stream-index:streamid-value". */
1471 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1472 {
1473     OptionsContext *o = optctx;
1474     int idx;
1475     char *p;
1476     char idx_str[16];
1477
1478     av_strlcpy(idx_str, arg, sizeof(idx_str));
1479     p = strchr(idx_str, ':');
1480     if (!p) {
1481         av_log(NULL, AV_LOG_FATAL,
1482                "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1483                arg, opt);
1484         exit_program(1);
1485     }
1486     *p++ = '\0';
1487     idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, INT_MAX);
1488     o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1489     o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1490     return 0;
1491 }
1492
1493 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1494 {
1495     AVFormatContext *is = ifile->ctx;
1496     AVFormatContext *os = ofile->ctx;
1497     AVChapter **tmp;
1498     int i;
1499
1500     tmp = av_realloc(os->chapters, sizeof(*os->chapters) * (is->nb_chapters + os->nb_chapters));
1501     if (!tmp)
1502         return AVERROR(ENOMEM);
1503     os->chapters = tmp;
1504
1505     for (i = 0; i < is->nb_chapters; i++) {
1506         AVChapter *in_ch = is->chapters[i], *out_ch;
1507         int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
1508         int64_t ts_off   = av_rescale_q(start_time - ifile->ts_offset,
1509                                        AV_TIME_BASE_Q, in_ch->time_base);
1510         int64_t rt       = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1511                            av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1512
1513
1514         if (in_ch->end < ts_off)
1515             continue;
1516         if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1517             break;
1518
1519         out_ch = av_mallocz(sizeof(AVChapter));
1520         if (!out_ch)
1521             return AVERROR(ENOMEM);
1522
1523         out_ch->id        = in_ch->id;
1524         out_ch->time_base = in_ch->time_base;
1525         out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
1526         out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
1527
1528         if (copy_metadata)
1529             av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1530
1531         os->chapters[os->nb_chapters++] = out_ch;
1532     }
1533     return 0;
1534 }
1535
1536 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1537                                AVFormatContext *oc)
1538 {
1539     OutputStream *ost;
1540
1541     switch (ofilter->type) {
1542     case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
1543     case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
1544     default:
1545         av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1546                "currently.\n");
1547         exit_program(1);
1548     }
1549
1550     ost->source_index = -1;
1551     ost->filter       = ofilter;
1552
1553     ofilter->ost      = ost;
1554     ofilter->format   = -1;
1555
1556     if (ost->stream_copy) {
1557         av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1558                "which is fed from a complex filtergraph. Filtering and streamcopy "
1559                "cannot be used together.\n", ost->file_index, ost->index);
1560         exit_program(1);
1561     }
1562
1563     avfilter_inout_free(&ofilter->out_tmp);
1564 }
1565
1566 static int init_complex_filters(void)
1567 {
1568     int i, ret = 0;
1569
1570     for (i = 0; i < nb_filtergraphs; i++) {
1571         ret = init_complex_filtergraph(filtergraphs[i]);
1572         if (ret < 0)
1573             return ret;
1574     }
1575     return 0;
1576 }
1577
1578 static int open_output_file(OptionsContext *o, const char *filename)
1579 {
1580     AVFormatContext *oc;
1581     int i, j, err;
1582     AVOutputFormat *file_oformat;
1583     OutputFile *of;
1584     OutputStream *ost;
1585     InputStream  *ist;
1586     AVDictionary *unused_opts = NULL;
1587     AVDictionaryEntry *e = NULL;
1588
1589     GROW_ARRAY(output_files, nb_output_files);
1590     of = av_mallocz(sizeof(*of));
1591     if (!of)
1592         exit_program(1);
1593     output_files[nb_output_files - 1] = of;
1594
1595     of->ost_index      = nb_output_streams;
1596     of->recording_time = o->recording_time;
1597     of->start_time     = o->start_time;
1598     of->limit_filesize = o->limit_filesize;
1599     of->shortest       = o->shortest;
1600     av_dict_copy(&of->opts, o->g->format_opts, 0);
1601
1602     if (!strcmp(filename, "-"))
1603         filename = "pipe:";
1604
1605     oc = avformat_alloc_context();
1606     if (!oc) {
1607         print_error(filename, AVERROR(ENOMEM));
1608         exit_program(1);
1609     }
1610     of->ctx = oc;
1611     if (o->recording_time != INT64_MAX)
1612         oc->duration = o->recording_time;
1613
1614     if (o->format) {
1615         file_oformat = av_guess_format(o->format, NULL, NULL);
1616         if (!file_oformat) {
1617             av_log(NULL, AV_LOG_FATAL, "Requested output format '%s' is not a suitable output format\n", o->format);
1618             exit_program(1);
1619         }
1620     } else {
1621         file_oformat = av_guess_format(NULL, filename, NULL);
1622         if (!file_oformat) {
1623             av_log(NULL, AV_LOG_FATAL, "Unable to find a suitable output format for '%s'\n",
1624                    filename);
1625             exit_program(1);
1626         }
1627     }
1628
1629     oc->oformat = file_oformat;
1630     oc->interrupt_callback = int_cb;
1631     av_strlcpy(oc->filename, filename, sizeof(oc->filename));
1632
1633     /* create streams for all unlabeled output pads */
1634     for (i = 0; i < nb_filtergraphs; i++) {
1635         FilterGraph *fg = filtergraphs[i];
1636         for (j = 0; j < fg->nb_outputs; j++) {
1637             OutputFilter *ofilter = fg->outputs[j];
1638
1639             if (!ofilter->out_tmp || ofilter->out_tmp->name)
1640                 continue;
1641
1642             switch (ofilter->type) {
1643             case AVMEDIA_TYPE_VIDEO:    o->video_disable    = 1; break;
1644             case AVMEDIA_TYPE_AUDIO:    o->audio_disable    = 1; break;
1645             case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1646             }
1647             init_output_filter(ofilter, o, oc);
1648         }
1649     }
1650
1651     if (!o->nb_stream_maps) {
1652         /* pick the "best" stream of each type */
1653 #define NEW_STREAM(type, index)\
1654         if (index >= 0) {\
1655             ost = new_ ## type ## _stream(o, oc);\
1656             ost->source_index = index;\
1657             ost->sync_ist     = input_streams[index];\
1658             input_streams[index]->discard = 0;\
1659             input_streams[index]->st->discard = AVDISCARD_NONE;\
1660         }
1661
1662         /* video: highest resolution */
1663         if (!o->video_disable && oc->oformat->video_codec != AV_CODEC_ID_NONE) {
1664             int area = 0, idx = -1;
1665             for (i = 0; i < nb_input_streams; i++) {
1666                 ist = input_streams[i];
1667                 if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
1668                     ist->st->codecpar->width * ist->st->codecpar->height > area) {
1669                     area = ist->st->codecpar->width * ist->st->codecpar->height;
1670                     idx = i;
1671                 }
1672             }
1673             NEW_STREAM(video, idx);
1674         }
1675
1676         /* audio: most channels */
1677         if (!o->audio_disable && oc->oformat->audio_codec != AV_CODEC_ID_NONE) {
1678             int channels = 0, idx = -1;
1679             for (i = 0; i < nb_input_streams; i++) {
1680                 ist = input_streams[i];
1681                 if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
1682                     ist->st->codecpar->channels > channels) {
1683                     channels = ist->st->codecpar->channels;
1684                     idx = i;
1685                 }
1686             }
1687             NEW_STREAM(audio, idx);
1688         }
1689
1690         /* subtitles: pick first */
1691         if (!o->subtitle_disable && oc->oformat->subtitle_codec != AV_CODEC_ID_NONE) {
1692             for (i = 0; i < nb_input_streams; i++)
1693                 if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1694                     NEW_STREAM(subtitle, i);
1695                     break;
1696                 }
1697         }
1698         /* do something with data? */
1699     } else {
1700         for (i = 0; i < o->nb_stream_maps; i++) {
1701             StreamMap *map = &o->stream_maps[i];
1702
1703             if (map->disabled)
1704                 continue;
1705
1706             if (map->linklabel) {
1707                 FilterGraph *fg;
1708                 OutputFilter *ofilter = NULL;
1709                 int j, k;
1710
1711                 for (j = 0; j < nb_filtergraphs; j++) {
1712                     fg = filtergraphs[j];
1713                     for (k = 0; k < fg->nb_outputs; k++) {
1714                         AVFilterInOut *out = fg->outputs[k]->out_tmp;
1715                         if (out && !strcmp(out->name, map->linklabel)) {
1716                             ofilter = fg->outputs[k];
1717                             goto loop_end;
1718                         }
1719                     }
1720                 }
1721 loop_end:
1722                 if (!ofilter) {
1723                     av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1724                            "in any defined filter graph.\n", map->linklabel);
1725                     exit_program(1);
1726                 }
1727                 init_output_filter(ofilter, o, oc);
1728             } else {
1729                 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
1730                 switch (ist->st->codecpar->codec_type) {
1731                 case AVMEDIA_TYPE_VIDEO:    ost = new_video_stream(o, oc);    break;
1732                 case AVMEDIA_TYPE_AUDIO:    ost = new_audio_stream(o, oc);    break;
1733                 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(o, oc); break;
1734                 case AVMEDIA_TYPE_DATA:     ost = new_data_stream(o, oc);     break;
1735                 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc); break;
1736                 default:
1737                     av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
1738                            map->file_index, map->stream_index);
1739                     exit_program(1);
1740                 }
1741
1742                 ost->source_index = input_files[map->file_index]->ist_index + map->stream_index;
1743                 ost->sync_ist     = input_streams[input_files[map->sync_file_index]->ist_index +
1744                                                map->sync_stream_index];
1745                 ist->discard = 0;
1746                 ist->st->discard = AVDISCARD_NONE;
1747             }
1748         }
1749     }
1750
1751     /* handle attached files */
1752     for (i = 0; i < o->nb_attachments; i++) {
1753         AVIOContext *pb;
1754         uint8_t *attachment;
1755         const char *p;
1756         int64_t len;
1757
1758         if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
1759             av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
1760                    o->attachments[i]);
1761             exit_program(1);
1762         }
1763         if ((len = avio_size(pb)) <= 0) {
1764             av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
1765                    o->attachments[i]);
1766             exit_program(1);
1767         }
1768         if (!(attachment = av_malloc(len))) {
1769             av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
1770                    o->attachments[i]);
1771             exit_program(1);
1772         }
1773         avio_read(pb, attachment, len);
1774
1775         ost = new_attachment_stream(o, oc);
1776         ost->stream_copy               = 0;
1777         ost->source_index              = -1;
1778         ost->attachment_filename       = o->attachments[i];
1779         ost->st->codecpar->extradata      = attachment;
1780         ost->st->codecpar->extradata_size = len;
1781
1782         p = strrchr(o->attachments[i], '/');
1783         av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
1784         avio_close(pb);
1785     }
1786
1787     if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
1788         av_dump_format(oc, nb_output_files - 1, oc->filename, 1);
1789         av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", nb_output_files - 1);
1790         exit_program(1);
1791     }
1792
1793     /* check if all codec options have been used */
1794     unused_opts = strip_specifiers(o->g->codec_opts);
1795     for (i = of->ost_index; i < nb_output_streams; i++) {
1796         e = NULL;
1797         while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
1798                                 AV_DICT_IGNORE_SUFFIX)))
1799             av_dict_set(&unused_opts, e->key, NULL, 0);
1800     }
1801
1802     e = NULL;
1803     while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
1804         const AVClass *class = avcodec_get_class();
1805         const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
1806                                              AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1807         if (!option)
1808             continue;
1809         if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
1810             av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
1811                    "output file #%d (%s) is not an encoding option.\n", e->key,
1812                    option->help ? option->help : "", nb_output_files - 1,
1813                    filename);
1814             exit_program(1);
1815         }
1816
1817         av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
1818                "output file #%d (%s) has not been used for any stream. The most "
1819                "likely reason is either wrong type (e.g. a video option with "
1820                "no video streams) or that it is a private option of some encoder "
1821                "which was not actually used for any stream.\n", e->key,
1822                option->help ? option->help : "", nb_output_files - 1, filename);
1823     }
1824     av_dict_free(&unused_opts);
1825
1826     /* set the decoding_needed flags and create simple filtergraphs */
1827     for (i = of->ost_index; i < nb_output_streams; i++) {
1828         OutputStream *ost = output_streams[i];
1829
1830         if (ost->encoding_needed && ost->source_index >= 0) {
1831             InputStream *ist = input_streams[ost->source_index];
1832             ist->decoding_needed = 1;
1833
1834             if (ost->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
1835                 ost->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
1836                 err = init_simple_filtergraph(ist, ost);
1837                 if (err < 0) {
1838                     av_log(NULL, AV_LOG_ERROR,
1839                            "Error initializing a simple filtergraph between streams "
1840                            "%d:%d->%d:%d\n", ist->file_index, ost->source_index,
1841                            nb_output_files - 1, ost->st->index);
1842                     exit_program(1);
1843                 }
1844             }
1845         }
1846
1847         /*
1848          * We want CFR output if and only if one of those is true:
1849          * 1) user specified output framerate with -r
1850          * 2) user specified -vsync cfr
1851          * 3) output format is CFR and the user didn't force vsync to
1852          *    something else than CFR
1853          *
1854          * in such a case, set ost->frame_rate
1855          */
1856         if (ost->encoding_needed && ost->enc_ctx->codec_type == AVMEDIA_TYPE_VIDEO) {
1857             int format_cfr = !(oc->oformat->flags & (AVFMT_NOTIMESTAMPS | AVFMT_VARIABLE_FPS));
1858             int need_cfr = !!ost->frame_rate.num;
1859
1860             if (video_sync_method == VSYNC_CFR ||
1861                 (video_sync_method == VSYNC_AUTO && format_cfr))
1862                 need_cfr = 1;
1863
1864             if (need_cfr && !ost->frame_rate.num) {
1865                 InputStream *ist = ost->source_index >= 0 ? input_streams[ost->source_index] : NULL;
1866
1867                 if (ist && ist->framerate.num)
1868                     ost->frame_rate = ist->framerate;
1869                 else if (ist && ist->st->avg_frame_rate.num)
1870                     ost->frame_rate = ist->st->avg_frame_rate;
1871                 else {
1872                     av_log(NULL, AV_LOG_WARNING, "Constant framerate requested "
1873                            "for the output stream #%d:%d, but no information "
1874                            "about the input framerate is available. Falling "
1875                            "back to a default value of 25fps. Use the -r option "
1876                            "if you want a different framerate.\n",
1877                            ost->file_index, ost->index);
1878                     ost->frame_rate = (AVRational){ 25, 1 };
1879                 }
1880             }
1881
1882             if (need_cfr && ost->enc->supported_framerates && !ost->force_fps) {
1883                 int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
1884                 ost->frame_rate = ost->enc->supported_framerates[idx];
1885             }
1886         }
1887
1888         /* set the filter output constraints */
1889         if (ost->filter) {
1890             OutputFilter *f = ost->filter;
1891             int count;
1892             switch (ost->enc_ctx->codec_type) {
1893             case AVMEDIA_TYPE_VIDEO:
1894                 f->frame_rate = ost->frame_rate;
1895                 f->width      = ost->enc_ctx->width;
1896                 f->height     = ost->enc_ctx->height;
1897                 if (ost->enc_ctx->pix_fmt != AV_PIX_FMT_NONE) {
1898                     f->format = ost->enc_ctx->pix_fmt;
1899                 } else if (ost->enc->pix_fmts) {
1900                     count = 0;
1901                     while (ost->enc->pix_fmts[count] != AV_PIX_FMT_NONE)
1902                         count++;
1903                     f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
1904                     if (!f->formats)
1905                         exit_program(1);
1906                     memcpy(f->formats, ost->enc->pix_fmts, (count + 1) * sizeof(*f->formats));
1907                 }
1908                 break;
1909             case AVMEDIA_TYPE_AUDIO:
1910                 if (ost->enc_ctx->sample_fmt != AV_SAMPLE_FMT_NONE) {
1911                     f->format = ost->enc_ctx->sample_fmt;
1912                 } else if (ost->enc->sample_fmts) {
1913                     count = 0;
1914                     while (ost->enc->sample_fmts[count] != AV_SAMPLE_FMT_NONE)
1915                         count++;
1916                     f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
1917                     if (!f->formats)
1918                         exit_program(1);
1919                     memcpy(f->formats, ost->enc->sample_fmts, (count + 1) * sizeof(*f->formats));
1920                 }
1921                 if (ost->enc_ctx->sample_rate) {
1922                     f->sample_rate = ost->enc_ctx->sample_rate;
1923                 } else if (ost->enc->supported_samplerates) {
1924                     count = 0;
1925                     while (ost->enc->supported_samplerates[count])
1926                         count++;
1927                     f->sample_rates = av_mallocz_array(count + 1, sizeof(*f->sample_rates));
1928                     if (!f->sample_rates)
1929                         exit_program(1);
1930                     memcpy(f->sample_rates, ost->enc->supported_samplerates,
1931                            (count + 1) * sizeof(*f->sample_rates));
1932                 }
1933                 if (ost->enc_ctx->channels) {
1934                     f->channel_layout = av_get_default_channel_layout(ost->enc_ctx->channels);
1935                 } else if (ost->enc->channel_layouts) {
1936                     count = 0;
1937                     while (ost->enc->channel_layouts[count])
1938                         count++;
1939                     f->channel_layouts = av_mallocz_array(count + 1, sizeof(*f->channel_layouts));
1940                     if (!f->channel_layouts)
1941                         exit_program(1);
1942                     memcpy(f->channel_layouts, ost->enc->channel_layouts,
1943                            (count + 1) * sizeof(*f->channel_layouts));
1944                 }
1945                 break;
1946             }
1947         }
1948
1949     }
1950
1951     /* check filename in case of an image number is expected */
1952     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
1953         if (!av_filename_number_test(oc->filename)) {
1954             print_error(oc->filename, AVERROR(EINVAL));
1955             exit_program(1);
1956         }
1957     }
1958
1959     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
1960         /* test if it already exists to avoid losing precious files */
1961         assert_file_overwrite(filename);
1962
1963         /* open the file */
1964         if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
1965                               &oc->interrupt_callback,
1966                               &of->opts)) < 0) {
1967             print_error(filename, err);
1968             exit_program(1);
1969         }
1970     }
1971
1972     if (o->mux_preload) {
1973         uint8_t buf[64];
1974         snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
1975         av_dict_set(&of->opts, "preload", buf, 0);
1976     }
1977     oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
1978     oc->flags |= AVFMT_FLAG_NONBLOCK;
1979
1980     /* copy metadata */
1981     for (i = 0; i < o->nb_metadata_map; i++) {
1982         char *p;
1983         int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
1984
1985         if (in_file_index >= nb_input_files) {
1986             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
1987             exit_program(1);
1988         }
1989         copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
1990                       in_file_index >= 0 ?
1991                       input_files[in_file_index]->ctx : NULL, o);
1992     }
1993
1994     /* copy chapters */
1995     if (o->chapters_input_file >= nb_input_files) {
1996         if (o->chapters_input_file == INT_MAX) {
1997             /* copy chapters from the first input file that has them*/
1998             o->chapters_input_file = -1;
1999             for (i = 0; i < nb_input_files; i++)
2000                 if (input_files[i]->ctx->nb_chapters) {
2001                     o->chapters_input_file = i;
2002                     break;
2003                 }
2004         } else {
2005             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
2006                    o->chapters_input_file);
2007             exit_program(1);
2008         }
2009     }
2010     if (o->chapters_input_file >= 0)
2011         copy_chapters(input_files[o->chapters_input_file], of,
2012                       !o->metadata_chapters_manual);
2013
2014     /* copy global metadata by default */
2015     if (!o->metadata_global_manual && nb_input_files)
2016         av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
2017                      AV_DICT_DONT_OVERWRITE);
2018     if (!o->metadata_streams_manual)
2019         for (i = of->ost_index; i < nb_output_streams; i++) {
2020             InputStream *ist;
2021             if (output_streams[i]->source_index < 0)         /* this is true e.g. for attached files */
2022                 continue;
2023             ist = input_streams[output_streams[i]->source_index];
2024             av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
2025         }
2026
2027     /* process manually set metadata */
2028     for (i = 0; i < o->nb_metadata; i++) {
2029         AVDictionary **m;
2030         char type, *val;
2031         const char *stream_spec;
2032         int index = 0, j, ret;
2033
2034         val = strchr(o->metadata[i].u.str, '=');
2035         if (!val) {
2036             av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
2037                    o->metadata[i].u.str);
2038             exit_program(1);
2039         }
2040         *val++ = 0;
2041
2042         parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
2043         if (type == 's') {
2044             for (j = 0; j < oc->nb_streams; j++) {
2045                 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2046                     av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2047                 } else if (ret < 0)
2048                     exit_program(1);
2049             }
2050         }
2051         else {
2052             switch (type) {
2053             case 'g':
2054                 m = &oc->metadata;
2055                 break;
2056             case 'c':
2057                 if (index < 0 || index >= oc->nb_chapters) {
2058                     av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2059                     exit_program(1);
2060                 }
2061                 m = &oc->chapters[index]->metadata;
2062                 break;
2063             default:
2064                 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2065                 exit_program(1);
2066             }
2067             av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2068         }
2069     }
2070
2071     return 0;
2072 }
2073
2074 static int opt_target(void *optctx, const char *opt, const char *arg)
2075 {
2076     OptionsContext *o = optctx;
2077     enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2078     static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2079
2080     if (!strncmp(arg, "pal-", 4)) {
2081         norm = PAL;
2082         arg += 4;
2083     } else if (!strncmp(arg, "ntsc-", 5)) {
2084         norm = NTSC;
2085         arg += 5;
2086     } else if (!strncmp(arg, "film-", 5)) {
2087         norm = FILM;
2088         arg += 5;
2089     } else {
2090         /* Try to determine PAL/NTSC by peeking in the input files */
2091         if (nb_input_files) {
2092             int i, j, fr;
2093             for (j = 0; j < nb_input_files; j++) {
2094                 for (i = 0; i < input_files[j]->nb_streams; i++) {
2095                     AVStream *st = input_files[j]->ctx->streams[i];
2096                     if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO)
2097                         continue;
2098                     fr = st->time_base.den * 1000 / st->time_base.num;
2099                     if (fr == 25000) {
2100                         norm = PAL;
2101                         break;
2102                     } else if ((fr == 29970) || (fr == 23976)) {
2103                         norm = NTSC;
2104                         break;
2105                     }
2106                 }
2107                 if (norm != UNKNOWN)
2108                     break;
2109             }
2110         }
2111         if (norm != UNKNOWN)
2112             av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2113     }
2114
2115     if (norm == UNKNOWN) {
2116         av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2117         av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2118         av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2119         exit_program(1);
2120     }
2121
2122     if (!strcmp(arg, "vcd")) {
2123         opt_video_codec(o, "c:v", "mpeg1video");
2124         opt_audio_codec(o, "c:a", "mp2");
2125         parse_option(o, "f", "vcd", options);
2126
2127         parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2128         parse_option(o, "r", frame_rates[norm], options);
2129         opt_default(NULL, "g", norm == PAL ? "15" : "18");
2130
2131         opt_default(NULL, "b", "1150000");
2132         opt_default(NULL, "maxrate", "1150000");
2133         opt_default(NULL, "minrate", "1150000");
2134         opt_default(NULL, "bufsize", "327680"); // 40*1024*8;
2135
2136         opt_default(NULL, "b:a", "224000");
2137         parse_option(o, "ar", "44100", options);
2138         parse_option(o, "ac", "2", options);
2139
2140         opt_default(NULL, "packetsize", "2324");
2141         opt_default(NULL, "muxrate", "3528"); // 2352 * 75 / 50;
2142
2143         /* We have to offset the PTS, so that it is consistent with the SCR.
2144            SCR starts at 36000, but the first two packs contain only padding
2145            and the first pack from the other stream, respectively, may also have
2146            been written before.
2147            So the real data starts at SCR 36000+3*1200. */
2148         o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2149     } else if (!strcmp(arg, "svcd")) {
2150
2151         opt_video_codec(o, "c:v", "mpeg2video");
2152         opt_audio_codec(o, "c:a", "mp2");
2153         parse_option(o, "f", "svcd", options);
2154
2155         parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2156         parse_option(o, "r", frame_rates[norm], options);
2157         opt_default(NULL, "g", norm == PAL ? "15" : "18");
2158
2159         opt_default(NULL, "b", "2040000");
2160         opt_default(NULL, "maxrate", "2516000");
2161         opt_default(NULL, "minrate", "0"); // 1145000;
2162         opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
2163         opt_default(NULL, "scan_offset", "1");
2164
2165
2166         opt_default(NULL, "b:a", "224000");
2167         parse_option(o, "ar", "44100", options);
2168
2169         opt_default(NULL, "packetsize", "2324");
2170
2171     } else if (!strcmp(arg, "dvd")) {
2172
2173         opt_video_codec(o, "c:v", "mpeg2video");
2174         opt_audio_codec(o, "c:a", "ac3");
2175         parse_option(o, "f", "dvd", options);
2176
2177         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2178         parse_option(o, "r", frame_rates[norm], options);
2179         opt_default(NULL, "g", norm == PAL ? "15" : "18");
2180
2181         opt_default(NULL, "b", "6000000");
2182         opt_default(NULL, "maxrate", "9000000");
2183         opt_default(NULL, "minrate", "0"); // 1500000;
2184         opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
2185
2186         opt_default(NULL, "packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
2187         opt_default(NULL, "muxrate", "25200"); // from mplex project: data_rate = 1260000. mux_rate = data_rate / 50
2188
2189         opt_default(NULL, "b:a", "448000");
2190         parse_option(o, "ar", "48000", options);
2191
2192     } else if (!strncmp(arg, "dv", 2)) {
2193
2194         parse_option(o, "f", "dv", options);
2195
2196         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2197         parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2198                           norm == PAL ? "yuv420p" : "yuv411p", options);
2199         parse_option(o, "r", frame_rates[norm], options);
2200
2201         parse_option(o, "ar", "48000", options);
2202         parse_option(o, "ac", "2", options);
2203
2204     } else {
2205         av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2206         return AVERROR(EINVAL);
2207     }
2208
2209     av_dict_copy(&o->g->codec_opts,  codec_opts, 0);
2210     av_dict_copy(&o->g->format_opts, format_opts, 0);
2211
2212     return 0;
2213 }
2214
2215 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2216 {
2217     av_free (vstats_filename);
2218     vstats_filename = av_strdup (arg);
2219     return 0;
2220 }
2221
2222 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2223 {
2224     char filename[40];
2225     time_t today2 = time(NULL);
2226     struct tm *today = localtime(&today2);
2227
2228     if (!today) { // maybe tomorrow
2229         av_log(NULL, AV_LOG_FATAL, "Unable to get current time.\n");
2230         exit_program(1);
2231     }
2232
2233     snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2234              today->tm_sec);
2235     return opt_vstats_file(NULL, opt, filename);
2236 }
2237
2238 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2239 {
2240     OptionsContext *o = optctx;
2241     return parse_option(o, "frames:v", arg, options);
2242 }
2243
2244 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2245 {
2246     OptionsContext *o = optctx;
2247     return parse_option(o, "frames:a", arg, options);
2248 }
2249
2250 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2251 {
2252     OptionsContext *o = optctx;
2253     return parse_option(o, "frames:d", arg, options);
2254 }
2255
2256 static int opt_video_tag(void *optctx, const char *opt, const char *arg)
2257 {
2258     OptionsContext *o = optctx;
2259     return parse_option(o, "tag:v", arg, options);
2260 }
2261
2262 static int opt_audio_tag(void *optctx, const char *opt, const char *arg)
2263 {
2264     OptionsContext *o = optctx;
2265     return parse_option(o, "tag:a", arg, options);
2266 }
2267
2268 static int opt_subtitle_tag(void *optctx, const char *opt, const char *arg)
2269 {
2270     OptionsContext *o = optctx;
2271     return parse_option(o, "tag:s", arg, options);
2272 }
2273
2274 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2275 {
2276     OptionsContext *o = optctx;
2277     return parse_option(o, "filter:v", arg, options);
2278 }
2279
2280 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2281 {
2282     OptionsContext *o = optctx;
2283     return parse_option(o, "filter:a", arg, options);
2284 }
2285
2286 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2287 {
2288     if      (!av_strcasecmp(arg, "cfr"))         video_sync_method = VSYNC_CFR;
2289     else if (!av_strcasecmp(arg, "vfr"))         video_sync_method = VSYNC_VFR;
2290     else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2291
2292     if (video_sync_method == VSYNC_AUTO)
2293         video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
2294     return 0;
2295 }
2296
2297 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2298 {
2299     OptionsContext *o = optctx;
2300     char layout_str[32];
2301     char *stream_str;
2302     char *ac_str;
2303     int ret, channels, ac_str_size;
2304     uint64_t layout;
2305
2306     layout = av_get_channel_layout(arg);
2307     if (!layout) {
2308         av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2309         return AVERROR(EINVAL);
2310     }
2311     snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2312     ret = opt_default(NULL, opt, layout_str);
2313     if (ret < 0)
2314         return ret;
2315
2316     /* set 'ac' option based on channel layout */
2317     channels = av_get_channel_layout_nb_channels(layout);
2318     snprintf(layout_str, sizeof(layout_str), "%d", channels);
2319     stream_str = strchr(opt, ':');
2320     ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2321     ac_str = av_mallocz(ac_str_size);
2322     if (!ac_str)
2323         return AVERROR(ENOMEM);
2324     av_strlcpy(ac_str, "ac", 3);
2325     if (stream_str)
2326         av_strlcat(ac_str, stream_str, ac_str_size);
2327     ret = parse_option(o, ac_str, layout_str, options);
2328     av_free(ac_str);
2329
2330     return ret;
2331 }
2332
2333 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2334 {
2335     OptionsContext *o = optctx;
2336     return parse_option(o, "q:a", arg, options);
2337 }
2338
2339 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2340 {
2341     GROW_ARRAY(filtergraphs, nb_filtergraphs);
2342     if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2343         return AVERROR(ENOMEM);
2344     filtergraphs[nb_filtergraphs - 1]->index      = nb_filtergraphs - 1;
2345     filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
2346     if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
2347         return AVERROR(ENOMEM);
2348     return 0;
2349 }
2350
2351 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
2352 {
2353     uint8_t *graph_desc = read_file(arg);
2354     if (!graph_desc)
2355         return AVERROR(EINVAL);
2356
2357     GROW_ARRAY(filtergraphs, nb_filtergraphs);
2358     if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2359         return AVERROR(ENOMEM);
2360     filtergraphs[nb_filtergraphs - 1]->index      = nb_filtergraphs - 1;
2361     filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
2362     return 0;
2363 }
2364
2365 void show_help_default(const char *opt, const char *arg)
2366 {
2367     /* per-file options have at least one of those set */
2368     const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2369     int show_advanced = 0, show_avoptions = 0;
2370
2371     if (opt && *opt) {
2372         if (!strcmp(opt, "long"))
2373             show_advanced = 1;
2374         else if (!strcmp(opt, "full"))
2375             show_advanced = show_avoptions = 1;
2376         else
2377             av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2378     }
2379
2380     show_usage();
2381
2382     printf("Getting help:\n"
2383            "    -h      -- print basic options\n"
2384            "    -h long -- print more options\n"
2385            "    -h full -- print all options (including all format and codec specific options, very long)\n"
2386            "    -h type=name -- print all options for the named decoder/encoder/demuxer/muxer/filter\n"
2387            "    See man %s for detailed description of the options.\n"
2388            "\n", program_name);
2389
2390     show_help_options(options, "Print help / information / capabilities:",
2391                       OPT_EXIT, 0, 0);
2392
2393     show_help_options(options, "Global options (affect whole program "
2394                       "instead of just one file:",
2395                       0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2396     if (show_advanced)
2397         show_help_options(options, "Advanced global options:", OPT_EXPERT,
2398                           per_file | OPT_EXIT, 0);
2399
2400     show_help_options(options, "Per-file main options:", 0,
2401                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
2402                       OPT_EXIT, per_file);
2403     if (show_advanced)
2404         show_help_options(options, "Advanced per-file options:",
2405                           OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2406
2407     show_help_options(options, "Video options:",
2408                       OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
2409     if (show_advanced)
2410         show_help_options(options, "Advanced Video options:",
2411                           OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2412
2413     show_help_options(options, "Audio options:",
2414                       OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2415     if (show_advanced)
2416         show_help_options(options, "Advanced Audio options:",
2417                           OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2418     show_help_options(options, "Subtitle options:",
2419                       OPT_SUBTITLE, 0, 0);
2420     printf("\n");
2421
2422     if (show_avoptions) {
2423         int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2424         show_help_children(avcodec_get_class(), flags);
2425         show_help_children(avformat_get_class(), flags);
2426         show_help_children(sws_get_class(), flags);
2427         show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM);
2428     }
2429 }
2430
2431 void show_usage(void)
2432 {
2433     printf("Hyper fast Audio and Video encoder\n");
2434     printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2435     printf("\n");
2436 }
2437
2438 enum OptGroup {
2439     GROUP_OUTFILE,
2440     GROUP_INFILE,
2441 };
2442
2443 static const OptionGroupDef groups[] = {
2444     [GROUP_OUTFILE] = { "output file",  NULL, OPT_OUTPUT },
2445     [GROUP_INFILE]  = { "input file",   "i",  OPT_INPUT },
2446 };
2447
2448 static int open_files(OptionGroupList *l, const char *inout,
2449                       int (*open_file)(OptionsContext*, const char*))
2450 {
2451     int i, ret;
2452
2453     for (i = 0; i < l->nb_groups; i++) {
2454         OptionGroup *g = &l->groups[i];
2455         OptionsContext o;
2456
2457         init_options(&o);
2458         o.g = g;
2459
2460         ret = parse_optgroup(&o, g);
2461         if (ret < 0) {
2462             av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
2463                    "%s.\n", inout, g->arg);
2464             return ret;
2465         }
2466
2467         av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
2468         ret = open_file(&o, g->arg);
2469         uninit_options(&o);
2470         if (ret < 0) {
2471             av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
2472                    inout, g->arg);
2473             return ret;
2474         }
2475         av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
2476     }
2477
2478     return 0;
2479 }
2480
2481 int avconv_parse_options(int argc, char **argv)
2482 {
2483     OptionParseContext octx;
2484     uint8_t error[128];
2485     int ret;
2486
2487     memset(&octx, 0, sizeof(octx));
2488
2489     /* split the commandline into an internal representation */
2490     ret = split_commandline(&octx, argc, argv, options, groups,
2491                             FF_ARRAY_ELEMS(groups));
2492     if (ret < 0) {
2493         av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
2494         goto fail;
2495     }
2496
2497     /* apply global options */
2498     ret = parse_optgroup(NULL, &octx.global_opts);
2499     if (ret < 0) {
2500         av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
2501         goto fail;
2502     }
2503
2504     /* open input files */
2505     ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
2506     if (ret < 0) {
2507         av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
2508         goto fail;
2509     }
2510
2511     /* create the complex filtergraphs */
2512     ret = init_complex_filters();
2513     if (ret < 0) {
2514         av_log(NULL, AV_LOG_FATAL, "Error initializing complex filters.\n");
2515         goto fail;
2516     }
2517
2518     /* open output files */
2519     ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
2520     if (ret < 0) {
2521         av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
2522         goto fail;
2523     }
2524
2525 fail:
2526     uninit_parse_context(&octx);
2527     if (ret < 0) {
2528         av_strerror(ret, error, sizeof(error));
2529         av_log(NULL, AV_LOG_FATAL, "%s\n", error);
2530     }
2531     return ret;
2532 }
2533
2534 #define OFFSET(x) offsetof(OptionsContext, x)
2535 const OptionDef options[] = {
2536     /* main options */
2537     CMDUTILS_COMMON_OPTIONS
2538     { "f",              HAS_ARG | OPT_STRING | OPT_OFFSET |
2539                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(format) },
2540         "force format", "fmt" },
2541     { "y",              OPT_BOOL,                                    {              &file_overwrite },
2542         "overwrite output files" },
2543     { "n",              OPT_BOOL,                                    {              &file_skip },
2544         "never overwrite output files" },
2545     { "c",              HAS_ARG | OPT_STRING | OPT_SPEC |
2546                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(codec_names) },
2547         "codec name", "codec" },
2548     { "codec",          HAS_ARG | OPT_STRING | OPT_SPEC |
2549                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(codec_names) },
2550         "codec name", "codec" },
2551     { "pre",            HAS_ARG | OPT_STRING | OPT_SPEC |
2552                         OPT_OUTPUT,                                  { .off       = OFFSET(presets) },
2553         "preset name", "preset" },
2554     { "map",            HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2555                         OPT_OUTPUT,                                  { .func_arg = opt_map },
2556         "set input stream mapping",
2557         "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
2558     { "map_metadata",   HAS_ARG | OPT_STRING | OPT_SPEC |
2559                         OPT_OUTPUT,                                  { .off       = OFFSET(metadata_map) },
2560         "set metadata information of outfile from infile",
2561         "outfile[,metadata]:infile[,metadata]" },
2562     { "map_chapters",   HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
2563                         OPT_OUTPUT,                                  { .off = OFFSET(chapters_input_file) },
2564         "set chapters mapping", "input_file_index" },
2565     { "t",              HAS_ARG | OPT_TIME | OPT_OFFSET |
2566                         OPT_INPUT | OPT_OUTPUT,                      { .off = OFFSET(recording_time) },
2567         "record or transcode \"duration\" seconds of audio/video",
2568         "duration" },
2569     { "fs",             HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
2570         "set the limit file size in bytes", "limit_size" },
2571     { "ss",             HAS_ARG | OPT_TIME | OPT_OFFSET |
2572                         OPT_INPUT | OPT_OUTPUT,                      { .off = OFFSET(start_time) },
2573         "set the start time offset", "time_off" },
2574     { "accurate_seek",  OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
2575                         OPT_INPUT,                                   { .off = OFFSET(accurate_seek) },
2576         "enable/disable accurate seeking with -ss" },
2577     { "itsoffset",      HAS_ARG | OPT_TIME | OPT_OFFSET |
2578                         OPT_EXPERT | OPT_INPUT,                      { .off = OFFSET(input_ts_offset) },
2579         "set the input ts offset", "time_off" },
2580     { "itsscale",       HAS_ARG | OPT_DOUBLE | OPT_SPEC |
2581                         OPT_EXPERT | OPT_INPUT,                      { .off = OFFSET(ts_scale) },
2582         "set the input ts scale", "scale" },
2583     { "metadata",       HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
2584         "add metadata", "string=string" },
2585     { "dframes",        HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2586                         OPT_OUTPUT,                                  { .func_arg = opt_data_frames },
2587         "set the number of data frames to record", "number" },
2588     { "benchmark",      OPT_BOOL | OPT_EXPERT,                       { &do_benchmark },
2589         "add timings for benchmarking" },
2590     { "timelimit",      HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_timelimit },
2591         "set max runtime in seconds", "limit" },
2592     { "dump",           OPT_BOOL | OPT_EXPERT,                       { &do_pkt_dump },
2593         "dump each input packet" },
2594     { "hex",            OPT_BOOL | OPT_EXPERT,                       { &do_hex_dump },
2595         "when dumping packets, also dump the payload" },
2596     { "re",             OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2597                         OPT_INPUT,                                   { .off = OFFSET(rate_emu) },
2598         "read input at native frame rate", "" },
2599     { "target",         HAS_ARG | OPT_PERFILE | OPT_OUTPUT,          { .func_arg = opt_target },
2600         "specify target file type (\"vcd\", \"svcd\", \"dvd\","
2601         " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2602     { "vsync",          HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_vsync },
2603         "video sync method", "" },
2604     { "async",          HAS_ARG | OPT_INT | OPT_EXPERT,              { &audio_sync_method },
2605         "audio sync method", "" },
2606     { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,          { &audio_drift_threshold },
2607         "audio drift threshold", "threshold" },
2608     { "copyts",         OPT_BOOL | OPT_EXPERT,                       { &copy_ts },
2609         "copy timestamps" },
2610     { "copytb",         OPT_BOOL | OPT_EXPERT,                       { &copy_tb },
2611         "copy input stream time base when stream copying" },
2612     { "shortest",       OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2613                         OPT_OUTPUT,                                  { .off = OFFSET(shortest) },
2614         "finish encoding within shortest input" },
2615     { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,       { &dts_delta_threshold },
2616         "timestamp discontinuity delta threshold", "threshold" },
2617     { "xerror",         OPT_BOOL | OPT_EXPERT,                       { &exit_on_error },
2618         "exit on error", "error" },
2619     { "copyinkf",       OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2620                         OPT_OUTPUT,                                  { .off = OFFSET(copy_initial_nonkeyframes) },
2621         "copy initial non-keyframes" },
2622     { "frames",         OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
2623         "set the number of frames to record", "number" },
2624     { "tag",            OPT_STRING | HAS_ARG | OPT_SPEC |
2625                         OPT_EXPERT | OPT_OUTPUT | OPT_INPUT,         { .off = OFFSET(codec_tags) },
2626         "force codec tag/fourcc", "fourcc/tag" },
2627     { "q",              HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
2628                         OPT_SPEC | OPT_OUTPUT,                       { .off = OFFSET(qscale) },
2629         "use fixed quality scale (VBR)", "q" },
2630     { "qscale",         HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
2631                         OPT_SPEC | OPT_OUTPUT,                       { .off = OFFSET(qscale) },
2632         "use fixed quality scale (VBR)", "q" },
2633     { "b",              HAS_ARG | OPT_INT | OPT_SPEC | OPT_OUTPUT,    { .off = OFFSET(bitrates) },
2634         "set stream bitrate in bits/second", "bitrate" },
2635     { "filter",         HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
2636         "set stream filterchain", "filter_list" },
2637     { "filter_script",  HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
2638         "read stream filtergraph description from a file", "filename" },
2639     { "filter_complex", HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_filter_complex },
2640         "create a complex filtergraph", "graph_description" },
2641     { "filter_complex_script", HAS_ARG | OPT_EXPERT,                 { .func_arg = opt_filter_complex_script },
2642         "read complex filtergraph description from a file", "filename" },
2643     { "stats",          OPT_BOOL,                                    { &print_stats },
2644         "print progress report during encoding", },
2645     { "attach",         HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2646                         OPT_OUTPUT,                                  { .func_arg = opt_attach },
2647         "add an attachment to the output file", "filename" },
2648     { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
2649                          OPT_EXPERT | OPT_INPUT,                     { .off = OFFSET(dump_attachment) },
2650         "extract an attachment into a file", "filename" },
2651     { "loop", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_INPUT |
2652                         OPT_OFFSET,                                  { .off = OFFSET(loop) }, "set number of times input stream shall be looped", "loop count" },
2653
2654     /* video options */
2655     { "vframes",      OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_video_frames },
2656         "set the number of video frames to record", "number" },
2657     { "r",            OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC |
2658                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_rates) },
2659         "set frame rate (Hz value, fraction or abbreviation)", "rate" },
2660     { "s",            OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC |
2661                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_sizes) },
2662         "set frame size (WxH or abbreviation)", "size" },
2663     { "aspect",       OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC |
2664                       OPT_OUTPUT,                                                { .off = OFFSET(frame_aspect_ratios) },
2665         "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
2666     { "pix_fmt",      OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
2667                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_pix_fmts) },
2668         "set pixel format", "format" },
2669     { "vn",           OPT_VIDEO | OPT_BOOL  | OPT_OFFSET | OPT_OUTPUT,           { .off = OFFSET(video_disable) },
2670         "disable video" },
2671     { "vdt",          OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT ,               { &video_discard },
2672         "discard threshold", "n" },
2673     { "rc_override",  OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
2674                       OPT_OUTPUT,                                                { .off = OFFSET(rc_overrides) },
2675         "rate control override for specific intervals", "override" },
2676     { "vcodec",       OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_INPUT |
2677                       OPT_OUTPUT,                                                { .func_arg = opt_video_codec },
2678         "force video codec ('copy' to copy stream)", "codec" },
2679     { "pass",         OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT,     { .off = OFFSET(pass) },
2680         "select the pass number (1 or 2)", "n" },
2681     { "passlogfile",  OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
2682                       OPT_OUTPUT,                                                { .off = OFFSET(passlogfiles) },
2683         "select two pass log file name prefix", "prefix" },
2684     { "vstats",       OPT_VIDEO | OPT_EXPERT ,                                   { .func_arg = &opt_vstats },
2685         "dump video coding statistics to file" },
2686     { "vstats_file",  OPT_VIDEO | HAS_ARG | OPT_EXPERT ,                         { .func_arg = opt_vstats_file },
2687         "dump video coding statistics to file", "file" },
2688     { "vf",           OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_video_filters },
2689         "video filters", "filter list" },
2690     { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
2691                       OPT_OUTPUT,                                                { .off = OFFSET(intra_matrices) },
2692         "specify intra matrix coeffs", "matrix" },
2693     { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
2694                       OPT_OUTPUT,                                                { .off = OFFSET(inter_matrices) },
2695         "specify inter matrix coeffs", "matrix" },
2696     { "top",          OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_INT| OPT_SPEC |
2697                       OPT_OUTPUT,                                                { .off = OFFSET(top_field_first) },
2698         "top=1/bottom=0/auto=-1 field first", "" },
2699     { "dc",           OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT ,               { &intra_dc_precision },
2700         "intra_dc_precision", "precision" },
2701     { "vtag",         OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_PERFILE |
2702                       OPT_OUTPUT,                                                { .func_arg = opt_video_tag },
2703         "force video tag/fourcc", "fourcc/tag" },
2704     { "qphist",       OPT_VIDEO | OPT_BOOL | OPT_EXPERT ,                        { &qp_hist },
2705         "show QP histogram" },
2706     { "force_fps",    OPT_VIDEO | OPT_BOOL | OPT_EXPERT  | OPT_SPEC |
2707                       OPT_OUTPUT,                                                { .off = OFFSET(force_fps) },
2708         "force the selected framerate, disable the best supported framerate selection" },
2709     { "streamid",     OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2710                       OPT_OUTPUT,                                                { .func_arg = opt_streamid },
2711         "set the value of an outfile streamid", "streamIndex:value" },
2712     { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2713                           OPT_SPEC | OPT_OUTPUT,                                 { .off = OFFSET(forced_key_frames) },
2714         "force key frames at specified timestamps", "timestamps" },
2715     { "hwaccel",          OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2716                           OPT_SPEC | OPT_INPUT,                                  { .off = OFFSET(hwaccels) },
2717         "use HW accelerated decoding", "hwaccel name" },
2718     { "hwaccel_device",   OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2719                           OPT_SPEC | OPT_INPUT,                                  { .off = OFFSET(hwaccel_devices) },
2720         "select a device for HW acceleration", "devicename" },
2721     { "hwaccel_output_format", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2722                           OPT_SPEC | OPT_INPUT,                                  { .off = OFFSET(hwaccel_output_formats) },
2723         "select output format used with HW accelerated decoding", "format" },
2724
2725     { "hwaccels",         OPT_EXIT,                                              { .func_arg = show_hwaccels },
2726         "show available HW acceleration methods" },
2727     { "autorotate",       HAS_ARG | OPT_BOOL | OPT_SPEC |
2728                           OPT_EXPERT | OPT_INPUT,                                { .off = OFFSET(autorotate) },
2729         "automatically insert correct rotate filters" },
2730     { "hwaccel_lax_profile_check", OPT_BOOL | OPT_EXPERT,                        { &hwaccel_lax_profile_check},
2731         "attempt to decode anyway if HW accelerated decoder's supported profiles do not exactly match the stream" },
2732
2733     /* audio options */
2734     { "aframes",        OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_frames },
2735         "set the number of audio frames to record", "number" },
2736     { "aq",             OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_qscale },
2737         "set audio quality (codec-specific)", "quality", },
2738     { "ar",             OPT_AUDIO | HAS_ARG  | OPT_INT | OPT_SPEC |
2739                         OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(audio_sample_rate) },
2740         "set audio sampling rate (in Hz)", "rate" },
2741     { "ac",             OPT_AUDIO | HAS_ARG  | OPT_INT | OPT_SPEC |
2742                         OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(audio_channels) },
2743         "set number of audio channels", "channels" },
2744     { "an",             OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_OUTPUT,            { .off = OFFSET(audio_disable) },
2745         "disable audio" },
2746     { "acodec",         OPT_AUDIO | HAS_ARG  | OPT_PERFILE |
2747                         OPT_INPUT | OPT_OUTPUT,                                    { .func_arg = opt_audio_codec },
2748         "force audio codec ('copy' to copy stream)", "codec" },
2749     { "atag",           OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_PERFILE |
2750                         OPT_OUTPUT,                                                { .func_arg = opt_audio_tag },
2751         "force audio tag/fourcc", "fourcc/tag" },
2752     { "vol",            OPT_AUDIO | HAS_ARG  | OPT_INT,                            { &audio_volume },
2753         "change audio volume (256=normal)" , "volume" },
2754     { "sample_fmt",     OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_SPEC |
2755                         OPT_STRING | OPT_INPUT | OPT_OUTPUT,                       { .off = OFFSET(sample_fmts) },
2756         "set sample format", "format" },
2757     { "channel_layout", OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_PERFILE |
2758                         OPT_INPUT | OPT_OUTPUT,                                    { .func_arg = opt_channel_layout },
2759         "set channel layout", "layout" },
2760     { "af",             OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_filters },
2761         "audio filters", "filter list" },
2762
2763     /* subtitle options */
2764     { "sn",     OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
2765         "disable subtitle" },
2766     { "scodec", OPT_SUBTITLE | HAS_ARG  | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
2767         "force subtitle codec ('copy' to copy stream)", "codec" },
2768     { "stag",   OPT_SUBTITLE | HAS_ARG  | OPT_EXPERT  | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_subtitle_tag }
2769         , "force subtitle tag/fourcc", "fourcc/tag" },
2770
2771     /* grab options */
2772     { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
2773
2774     /* muxer options */
2775     { "muxdelay",   OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
2776         "set the maximum demux-decode delay", "seconds" },
2777     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
2778         "set the initial demux-decode delay", "seconds" },
2779
2780     { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
2781         "A comma-separated list of bitstream filters", "bitstream_filters" },
2782
2783     { "max_muxing_queue_size", HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(max_muxing_queue_size) },
2784         "maximum number of packets that can be buffered while waiting for all streams to initialize", "packets" },
2785
2786     /* data codec support */
2787     { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
2788         "force data codec ('copy' to copy stream)", "codec" },
2789
2790 #if CONFIG_VAAPI
2791     { "vaapi_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vaapi_device },
2792         "set VAAPI hardware device (DRM path or X11 display name)", "device" },
2793 #endif
2794
2795     { "init_hw_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_init_hw_device },
2796         "initialise hardware device", "args" },
2797     { "filter_hw_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_hw_device },
2798         "set hardware device used when filtering", "device" },
2799
2800     { NULL, },
2801 };