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