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