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