4505a8e6a92d92032d089ff7badf1dbfc7842b1e
[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     GROW_ARRAY(output_files, nb_output_files);
1422     of = av_mallocz(sizeof(*of));
1423     if (!of)
1424         exit_program(1);
1425     output_files[nb_output_files - 1] = of;
1426
1427     of->ost_index      = nb_output_streams;
1428     of->recording_time = o->recording_time;
1429     of->start_time     = o->start_time;
1430     of->limit_filesize = o->limit_filesize;
1431     of->shortest       = o->shortest;
1432     av_dict_copy(&of->opts, o->g->format_opts, 0);
1433
1434     if (!strcmp(filename, "-"))
1435         filename = "pipe:";
1436
1437     oc = avformat_alloc_context();
1438     if (!oc) {
1439         print_error(filename, AVERROR(ENOMEM));
1440         exit_program(1);
1441     }
1442     of->ctx = oc;
1443     if (o->recording_time != INT64_MAX)
1444         oc->duration = o->recording_time;
1445
1446     if (o->format) {
1447         file_oformat = av_guess_format(o->format, NULL, NULL);
1448         if (!file_oformat) {
1449             av_log(NULL, AV_LOG_FATAL, "Requested output format '%s' is not a suitable output format\n", o->format);
1450             exit_program(1);
1451         }
1452     } else {
1453         file_oformat = av_guess_format(NULL, filename, NULL);
1454         if (!file_oformat) {
1455             av_log(NULL, AV_LOG_FATAL, "Unable to find a suitable output format for '%s'\n",
1456                    filename);
1457             exit_program(1);
1458         }
1459     }
1460
1461     oc->oformat = file_oformat;
1462     oc->interrupt_callback = int_cb;
1463     av_strlcpy(oc->filename, filename, sizeof(oc->filename));
1464
1465     /* create streams for all unlabeled output pads */
1466     for (i = 0; i < nb_filtergraphs; i++) {
1467         FilterGraph *fg = filtergraphs[i];
1468         for (j = 0; j < fg->nb_outputs; j++) {
1469             OutputFilter *ofilter = fg->outputs[j];
1470
1471             if (!ofilter->out_tmp || ofilter->out_tmp->name)
1472                 continue;
1473
1474             switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1475                                           ofilter->out_tmp->pad_idx)) {
1476             case AVMEDIA_TYPE_VIDEO:    o->video_disable    = 1; break;
1477             case AVMEDIA_TYPE_AUDIO:    o->audio_disable    = 1; break;
1478             case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1479             }
1480             init_output_filter(ofilter, o, oc);
1481         }
1482     }
1483
1484     if (!o->nb_stream_maps) {
1485         /* pick the "best" stream of each type */
1486 #define NEW_STREAM(type, index)\
1487         if (index >= 0) {\
1488             ost = new_ ## type ## _stream(o, oc);\
1489             ost->source_index = index;\
1490             ost->sync_ist     = input_streams[index];\
1491             input_streams[index]->discard = 0;\
1492             input_streams[index]->st->discard = AVDISCARD_NONE;\
1493         }
1494
1495         /* video: highest resolution */
1496         if (!o->video_disable && oc->oformat->video_codec != AV_CODEC_ID_NONE) {
1497             int area = 0, idx = -1;
1498             for (i = 0; i < nb_input_streams; i++) {
1499                 ist = input_streams[i];
1500                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1501                     ist->st->codec->width * ist->st->codec->height > area) {
1502                     area = ist->st->codec->width * ist->st->codec->height;
1503                     idx = i;
1504                 }
1505             }
1506             NEW_STREAM(video, idx);
1507         }
1508
1509         /* audio: most channels */
1510         if (!o->audio_disable && oc->oformat->audio_codec != AV_CODEC_ID_NONE) {
1511             int channels = 0, idx = -1;
1512             for (i = 0; i < nb_input_streams; i++) {
1513                 ist = input_streams[i];
1514                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1515                     ist->st->codec->channels > channels) {
1516                     channels = ist->st->codec->channels;
1517                     idx = i;
1518                 }
1519             }
1520             NEW_STREAM(audio, idx);
1521         }
1522
1523         /* subtitles: pick first */
1524         if (!o->subtitle_disable && oc->oformat->subtitle_codec != AV_CODEC_ID_NONE) {
1525             for (i = 0; i < nb_input_streams; i++)
1526                 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1527                     NEW_STREAM(subtitle, i);
1528                     break;
1529                 }
1530         }
1531         /* do something with data? */
1532     } else {
1533         for (i = 0; i < o->nb_stream_maps; i++) {
1534             StreamMap *map = &o->stream_maps[i];
1535
1536             if (map->disabled)
1537                 continue;
1538
1539             if (map->linklabel) {
1540                 FilterGraph *fg;
1541                 OutputFilter *ofilter = NULL;
1542                 int j, k;
1543
1544                 for (j = 0; j < nb_filtergraphs; j++) {
1545                     fg = filtergraphs[j];
1546                     for (k = 0; k < fg->nb_outputs; k++) {
1547                         AVFilterInOut *out = fg->outputs[k]->out_tmp;
1548                         if (out && !strcmp(out->name, map->linklabel)) {
1549                             ofilter = fg->outputs[k];
1550                             goto loop_end;
1551                         }
1552                     }
1553                 }
1554 loop_end:
1555                 if (!ofilter) {
1556                     av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1557                            "in any defined filter graph.\n", map->linklabel);
1558                     exit_program(1);
1559                 }
1560                 init_output_filter(ofilter, o, oc);
1561             } else {
1562                 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
1563                 switch (ist->st->codec->codec_type) {
1564                 case AVMEDIA_TYPE_VIDEO:    ost = new_video_stream(o, oc);    break;
1565                 case AVMEDIA_TYPE_AUDIO:    ost = new_audio_stream(o, oc);    break;
1566                 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(o, oc); break;
1567                 case AVMEDIA_TYPE_DATA:     ost = new_data_stream(o, oc);     break;
1568                 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc); break;
1569                 default:
1570                     av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
1571                            map->file_index, map->stream_index);
1572                     exit_program(1);
1573                 }
1574
1575                 ost->source_index = input_files[map->file_index]->ist_index + map->stream_index;
1576                 ost->sync_ist     = input_streams[input_files[map->sync_file_index]->ist_index +
1577                                                map->sync_stream_index];
1578                 ist->discard = 0;
1579                 ist->st->discard = AVDISCARD_NONE;
1580             }
1581         }
1582     }
1583
1584     /* handle attached files */
1585     for (i = 0; i < o->nb_attachments; i++) {
1586         AVIOContext *pb;
1587         uint8_t *attachment;
1588         const char *p;
1589         int64_t len;
1590
1591         if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
1592             av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
1593                    o->attachments[i]);
1594             exit_program(1);
1595         }
1596         if ((len = avio_size(pb)) <= 0) {
1597             av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
1598                    o->attachments[i]);
1599             exit_program(1);
1600         }
1601         if (!(attachment = av_malloc(len))) {
1602             av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
1603                    o->attachments[i]);
1604             exit_program(1);
1605         }
1606         avio_read(pb, attachment, len);
1607
1608         ost = new_attachment_stream(o, oc);
1609         ost->stream_copy               = 0;
1610         ost->source_index              = -1;
1611         ost->attachment_filename       = o->attachments[i];
1612         ost->st->codec->extradata      = attachment;
1613         ost->st->codec->extradata_size = len;
1614
1615         p = strrchr(o->attachments[i], '/');
1616         av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
1617         avio_close(pb);
1618     }
1619
1620     if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
1621         av_dump_format(oc, nb_output_files - 1, oc->filename, 1);
1622         av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", nb_output_files - 1);
1623         exit_program(1);
1624     }
1625
1626     /* check if all codec options have been used */
1627     unused_opts = strip_specifiers(o->g->codec_opts);
1628     for (i = of->ost_index; i < nb_output_streams; i++) {
1629         e = NULL;
1630         while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
1631                                 AV_DICT_IGNORE_SUFFIX)))
1632             av_dict_set(&unused_opts, e->key, NULL, 0);
1633     }
1634
1635     e = NULL;
1636     while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
1637         const AVClass *class = avcodec_get_class();
1638         const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
1639                                              AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1640         if (!option)
1641             continue;
1642         if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
1643             av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
1644                    "output file #%d (%s) is not an encoding option.\n", e->key,
1645                    option->help ? option->help : "", nb_output_files - 1,
1646                    filename);
1647             exit_program(1);
1648         }
1649
1650         av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
1651                "output file #%d (%s) has not been used for any stream. The most "
1652                "likely reason is either wrong type (e.g. a video option with "
1653                "no video streams) or that it is a private option of some encoder "
1654                "which was not actually used for any stream.\n", e->key,
1655                option->help ? option->help : "", nb_output_files - 1, filename);
1656     }
1657     av_dict_free(&unused_opts);
1658
1659     /* set the encoding/decoding_needed flags */
1660     for (i = of->ost_index; i < nb_output_streams; i++) {
1661         OutputStream *ost = output_streams[i];
1662
1663         ost->encoding_needed = !ost->stream_copy;
1664         if (ost->encoding_needed && ost->source_index >= 0) {
1665             InputStream *ist = input_streams[ost->source_index];
1666             ist->decoding_needed = 1;
1667         }
1668     }
1669
1670     /* check filename in case of an image number is expected */
1671     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
1672         if (!av_filename_number_test(oc->filename)) {
1673             print_error(oc->filename, AVERROR(EINVAL));
1674             exit_program(1);
1675         }
1676     }
1677
1678     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
1679         /* test if it already exists to avoid losing precious files */
1680         assert_file_overwrite(filename);
1681
1682         /* open the file */
1683         if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
1684                               &oc->interrupt_callback,
1685                               &of->opts)) < 0) {
1686             print_error(filename, err);
1687             exit_program(1);
1688         }
1689     }
1690
1691     if (o->mux_preload) {
1692         uint8_t buf[64];
1693         snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
1694         av_dict_set(&of->opts, "preload", buf, 0);
1695     }
1696     oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
1697     oc->flags |= AVFMT_FLAG_NONBLOCK;
1698
1699     /* copy metadata */
1700     for (i = 0; i < o->nb_metadata_map; i++) {
1701         char *p;
1702         int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
1703
1704         if (in_file_index >= nb_input_files) {
1705             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
1706             exit_program(1);
1707         }
1708         copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
1709                       in_file_index >= 0 ?
1710                       input_files[in_file_index]->ctx : NULL, o);
1711     }
1712
1713     /* copy chapters */
1714     if (o->chapters_input_file >= nb_input_files) {
1715         if (o->chapters_input_file == INT_MAX) {
1716             /* copy chapters from the first input file that has them*/
1717             o->chapters_input_file = -1;
1718             for (i = 0; i < nb_input_files; i++)
1719                 if (input_files[i]->ctx->nb_chapters) {
1720                     o->chapters_input_file = i;
1721                     break;
1722                 }
1723         } else {
1724             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
1725                    o->chapters_input_file);
1726             exit_program(1);
1727         }
1728     }
1729     if (o->chapters_input_file >= 0)
1730         copy_chapters(input_files[o->chapters_input_file], of,
1731                       !o->metadata_chapters_manual);
1732
1733     /* copy global metadata by default */
1734     if (!o->metadata_global_manual && nb_input_files)
1735         av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
1736                      AV_DICT_DONT_OVERWRITE);
1737     if (!o->metadata_streams_manual)
1738         for (i = of->ost_index; i < nb_output_streams; i++) {
1739             InputStream *ist;
1740             if (output_streams[i]->source_index < 0)         /* this is true e.g. for attached files */
1741                 continue;
1742             ist = input_streams[output_streams[i]->source_index];
1743             av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
1744         }
1745
1746     /* process manually set metadata */
1747     for (i = 0; i < o->nb_metadata; i++) {
1748         AVDictionary **m;
1749         char type, *val;
1750         const char *stream_spec;
1751         int index = 0, j, ret;
1752
1753         val = strchr(o->metadata[i].u.str, '=');
1754         if (!val) {
1755             av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
1756                    o->metadata[i].u.str);
1757             exit_program(1);
1758         }
1759         *val++ = 0;
1760
1761         parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
1762         if (type == 's') {
1763             for (j = 0; j < oc->nb_streams; j++) {
1764                 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
1765                     av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
1766                 } else if (ret < 0)
1767                     exit_program(1);
1768             }
1769         }
1770         else {
1771             switch (type) {
1772             case 'g':
1773                 m = &oc->metadata;
1774                 break;
1775             case 'c':
1776                 if (index < 0 || index >= oc->nb_chapters) {
1777                     av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
1778                     exit_program(1);
1779                 }
1780                 m = &oc->chapters[index]->metadata;
1781                 break;
1782             default:
1783                 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
1784                 exit_program(1);
1785             }
1786             av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
1787         }
1788     }
1789
1790     return 0;
1791 }
1792
1793 static int opt_target(void *optctx, const char *opt, const char *arg)
1794 {
1795     OptionsContext *o = optctx;
1796     enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
1797     static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
1798
1799     if (!strncmp(arg, "pal-", 4)) {
1800         norm = PAL;
1801         arg += 4;
1802     } else if (!strncmp(arg, "ntsc-", 5)) {
1803         norm = NTSC;
1804         arg += 5;
1805     } else if (!strncmp(arg, "film-", 5)) {
1806         norm = FILM;
1807         arg += 5;
1808     } else {
1809         /* Try to determine PAL/NTSC by peeking in the input files */
1810         if (nb_input_files) {
1811             int i, j, fr;
1812             for (j = 0; j < nb_input_files; j++) {
1813                 for (i = 0; i < input_files[j]->nb_streams; i++) {
1814                     AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
1815                     if (c->codec_type != AVMEDIA_TYPE_VIDEO ||
1816                         !c->time_base.num)
1817                         continue;
1818                     fr = c->time_base.den * 1000 / c->time_base.num;
1819                     if (fr == 25000) {
1820                         norm = PAL;
1821                         break;
1822                     } else if ((fr == 29970) || (fr == 23976)) {
1823                         norm = NTSC;
1824                         break;
1825                     }
1826                 }
1827                 if (norm != UNKNOWN)
1828                     break;
1829             }
1830         }
1831         if (norm != UNKNOWN)
1832             av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
1833     }
1834
1835     if (norm == UNKNOWN) {
1836         av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
1837         av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
1838         av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
1839         exit_program(1);
1840     }
1841
1842     if (!strcmp(arg, "vcd")) {
1843         opt_video_codec(o, "c:v", "mpeg1video");
1844         opt_audio_codec(o, "c:a", "mp2");
1845         parse_option(o, "f", "vcd", options);
1846
1847         parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
1848         parse_option(o, "r", frame_rates[norm], options);
1849         opt_default(NULL, "g", norm == PAL ? "15" : "18");
1850
1851         opt_default(NULL, "b", "1150000");
1852         opt_default(NULL, "maxrate", "1150000");
1853         opt_default(NULL, "minrate", "1150000");
1854         opt_default(NULL, "bufsize", "327680"); // 40*1024*8;
1855
1856         opt_default(NULL, "b:a", "224000");
1857         parse_option(o, "ar", "44100", options);
1858         parse_option(o, "ac", "2", options);
1859
1860         opt_default(NULL, "packetsize", "2324");
1861         opt_default(NULL, "muxrate", "3528"); // 2352 * 75 / 50;
1862
1863         /* We have to offset the PTS, so that it is consistent with the SCR.
1864            SCR starts at 36000, but the first two packs contain only padding
1865            and the first pack from the other stream, respectively, may also have
1866            been written before.
1867            So the real data starts at SCR 36000+3*1200. */
1868         o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
1869     } else if (!strcmp(arg, "svcd")) {
1870
1871         opt_video_codec(o, "c:v", "mpeg2video");
1872         opt_audio_codec(o, "c:a", "mp2");
1873         parse_option(o, "f", "svcd", options);
1874
1875         parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
1876         parse_option(o, "r", frame_rates[norm], options);
1877         opt_default(NULL, "g", norm == PAL ? "15" : "18");
1878
1879         opt_default(NULL, "b", "2040000");
1880         opt_default(NULL, "maxrate", "2516000");
1881         opt_default(NULL, "minrate", "0"); // 1145000;
1882         opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
1883         opt_default(NULL, "scan_offset", "1");
1884
1885
1886         opt_default(NULL, "b:a", "224000");
1887         parse_option(o, "ar", "44100", options);
1888
1889         opt_default(NULL, "packetsize", "2324");
1890
1891     } else if (!strcmp(arg, "dvd")) {
1892
1893         opt_video_codec(o, "c:v", "mpeg2video");
1894         opt_audio_codec(o, "c:a", "ac3");
1895         parse_option(o, "f", "dvd", options);
1896
1897         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1898         parse_option(o, "r", frame_rates[norm], options);
1899         opt_default(NULL, "g", norm == PAL ? "15" : "18");
1900
1901         opt_default(NULL, "b", "6000000");
1902         opt_default(NULL, "maxrate", "9000000");
1903         opt_default(NULL, "minrate", "0"); // 1500000;
1904         opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
1905
1906         opt_default(NULL, "packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
1907         opt_default(NULL, "muxrate", "25200"); // from mplex project: data_rate = 1260000. mux_rate = data_rate / 50
1908
1909         opt_default(NULL, "b:a", "448000");
1910         parse_option(o, "ar", "48000", options);
1911
1912     } else if (!strncmp(arg, "dv", 2)) {
1913
1914         parse_option(o, "f", "dv", options);
1915
1916         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1917         parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
1918                           norm == PAL ? "yuv420p" : "yuv411p", options);
1919         parse_option(o, "r", frame_rates[norm], options);
1920
1921         parse_option(o, "ar", "48000", options);
1922         parse_option(o, "ac", "2", options);
1923
1924     } else {
1925         av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
1926         return AVERROR(EINVAL);
1927     }
1928
1929     av_dict_copy(&o->g->codec_opts,  codec_opts, 0);
1930     av_dict_copy(&o->g->format_opts, format_opts, 0);
1931
1932     return 0;
1933 }
1934
1935 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
1936 {
1937     av_free (vstats_filename);
1938     vstats_filename = av_strdup (arg);
1939     return 0;
1940 }
1941
1942 static int opt_vstats(void *optctx, const char *opt, const char *arg)
1943 {
1944     char filename[40];
1945     time_t today2 = time(NULL);
1946     struct tm *today = localtime(&today2);
1947
1948     if (!today) { // maybe tomorrow
1949         av_log(NULL, AV_LOG_FATAL, "Unable to get current time.\n");
1950         exit_program(1);
1951     }
1952
1953     snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
1954              today->tm_sec);
1955     return opt_vstats_file(NULL, opt, filename);
1956 }
1957
1958 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
1959 {
1960     OptionsContext *o = optctx;
1961     return parse_option(o, "frames:v", arg, options);
1962 }
1963
1964 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
1965 {
1966     OptionsContext *o = optctx;
1967     return parse_option(o, "frames:a", arg, options);
1968 }
1969
1970 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
1971 {
1972     OptionsContext *o = optctx;
1973     return parse_option(o, "frames:d", arg, options);
1974 }
1975
1976 static int opt_video_tag(void *optctx, const char *opt, const char *arg)
1977 {
1978     OptionsContext *o = optctx;
1979     return parse_option(o, "tag:v", arg, options);
1980 }
1981
1982 static int opt_audio_tag(void *optctx, const char *opt, const char *arg)
1983 {
1984     OptionsContext *o = optctx;
1985     return parse_option(o, "tag:a", arg, options);
1986 }
1987
1988 static int opt_subtitle_tag(void *optctx, const char *opt, const char *arg)
1989 {
1990     OptionsContext *o = optctx;
1991     return parse_option(o, "tag:s", arg, options);
1992 }
1993
1994 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
1995 {
1996     OptionsContext *o = optctx;
1997     return parse_option(o, "filter:v", arg, options);
1998 }
1999
2000 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2001 {
2002     OptionsContext *o = optctx;
2003     return parse_option(o, "filter:a", arg, options);
2004 }
2005
2006 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2007 {
2008     if      (!av_strcasecmp(arg, "cfr"))         video_sync_method = VSYNC_CFR;
2009     else if (!av_strcasecmp(arg, "vfr"))         video_sync_method = VSYNC_VFR;
2010     else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2011
2012     if (video_sync_method == VSYNC_AUTO)
2013         video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
2014     return 0;
2015 }
2016
2017 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2018 {
2019     OptionsContext *o = optctx;
2020     char layout_str[32];
2021     char *stream_str;
2022     char *ac_str;
2023     int ret, channels, ac_str_size;
2024     uint64_t layout;
2025
2026     layout = av_get_channel_layout(arg);
2027     if (!layout) {
2028         av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2029         return AVERROR(EINVAL);
2030     }
2031     snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2032     ret = opt_default(NULL, opt, layout_str);
2033     if (ret < 0)
2034         return ret;
2035
2036     /* set 'ac' option based on channel layout */
2037     channels = av_get_channel_layout_nb_channels(layout);
2038     snprintf(layout_str, sizeof(layout_str), "%d", channels);
2039     stream_str = strchr(opt, ':');
2040     ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2041     ac_str = av_mallocz(ac_str_size);
2042     if (!ac_str)
2043         return AVERROR(ENOMEM);
2044     av_strlcpy(ac_str, "ac", 3);
2045     if (stream_str)
2046         av_strlcat(ac_str, stream_str, ac_str_size);
2047     ret = parse_option(o, ac_str, layout_str, options);
2048     av_free(ac_str);
2049
2050     return ret;
2051 }
2052
2053 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2054 {
2055     OptionsContext *o = optctx;
2056     return parse_option(o, "q:a", arg, options);
2057 }
2058
2059 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2060 {
2061     GROW_ARRAY(filtergraphs, nb_filtergraphs);
2062     if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2063         return AVERROR(ENOMEM);
2064     filtergraphs[nb_filtergraphs - 1]->index      = nb_filtergraphs - 1;
2065     filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
2066     if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
2067         return AVERROR(ENOMEM);
2068     return 0;
2069 }
2070
2071 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
2072 {
2073     uint8_t *graph_desc = read_file(arg);
2074     if (!graph_desc)
2075         return AVERROR(EINVAL);
2076
2077     GROW_ARRAY(filtergraphs, nb_filtergraphs);
2078     if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2079         return AVERROR(ENOMEM);
2080     filtergraphs[nb_filtergraphs - 1]->index      = nb_filtergraphs - 1;
2081     filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
2082     return 0;
2083 }
2084
2085 void show_help_default(const char *opt, const char *arg)
2086 {
2087     /* per-file options have at least one of those set */
2088     const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2089     int show_advanced = 0, show_avoptions = 0;
2090
2091     if (opt && *opt) {
2092         if (!strcmp(opt, "long"))
2093             show_advanced = 1;
2094         else if (!strcmp(opt, "full"))
2095             show_advanced = show_avoptions = 1;
2096         else
2097             av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2098     }
2099
2100     show_usage();
2101
2102     printf("Getting help:\n"
2103            "    -h      -- print basic options\n"
2104            "    -h long -- print more options\n"
2105            "    -h full -- print all options (including all format and codec specific options, very long)\n"
2106            "    See man %s for detailed description of the options.\n"
2107            "\n", program_name);
2108
2109     show_help_options(options, "Print help / information / capabilities:",
2110                       OPT_EXIT, 0, 0);
2111
2112     show_help_options(options, "Global options (affect whole program "
2113                       "instead of just one file:",
2114                       0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2115     if (show_advanced)
2116         show_help_options(options, "Advanced global options:", OPT_EXPERT,
2117                           per_file | OPT_EXIT, 0);
2118
2119     show_help_options(options, "Per-file main options:", 0,
2120                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
2121                       OPT_EXIT, per_file);
2122     if (show_advanced)
2123         show_help_options(options, "Advanced per-file options:",
2124                           OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2125
2126     show_help_options(options, "Video options:",
2127                       OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
2128     if (show_advanced)
2129         show_help_options(options, "Advanced Video options:",
2130                           OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2131
2132     show_help_options(options, "Audio options:",
2133                       OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2134     if (show_advanced)
2135         show_help_options(options, "Advanced Audio options:",
2136                           OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2137     show_help_options(options, "Subtitle options:",
2138                       OPT_SUBTITLE, 0, 0);
2139     printf("\n");
2140
2141     if (show_avoptions) {
2142         int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2143         show_help_children(avcodec_get_class(), flags);
2144         show_help_children(avformat_get_class(), flags);
2145         show_help_children(sws_get_class(), flags);
2146         show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM);
2147     }
2148 }
2149
2150 void show_usage(void)
2151 {
2152     printf("Hyper fast Audio and Video encoder\n");
2153     printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2154     printf("\n");
2155 }
2156
2157 enum OptGroup {
2158     GROUP_OUTFILE,
2159     GROUP_INFILE,
2160 };
2161
2162 static const OptionGroupDef groups[] = {
2163     [GROUP_OUTFILE] = { "output file",  NULL, OPT_OUTPUT },
2164     [GROUP_INFILE]  = { "input file",   "i",  OPT_INPUT },
2165 };
2166
2167 static int open_files(OptionGroupList *l, const char *inout,
2168                       int (*open_file)(OptionsContext*, const char*))
2169 {
2170     int i, ret;
2171
2172     for (i = 0; i < l->nb_groups; i++) {
2173         OptionGroup *g = &l->groups[i];
2174         OptionsContext o;
2175
2176         init_options(&o);
2177         o.g = g;
2178
2179         ret = parse_optgroup(&o, g);
2180         if (ret < 0) {
2181             av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
2182                    "%s.\n", inout, g->arg);
2183             return ret;
2184         }
2185
2186         av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
2187         ret = open_file(&o, g->arg);
2188         uninit_options(&o);
2189         if (ret < 0) {
2190             av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
2191                    inout, g->arg);
2192             return ret;
2193         }
2194         av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
2195     }
2196
2197     return 0;
2198 }
2199
2200 int avconv_parse_options(int argc, char **argv)
2201 {
2202     OptionParseContext octx;
2203     uint8_t error[128];
2204     int ret;
2205
2206     memset(&octx, 0, sizeof(octx));
2207
2208     /* split the commandline into an internal representation */
2209     ret = split_commandline(&octx, argc, argv, options, groups,
2210                             FF_ARRAY_ELEMS(groups));
2211     if (ret < 0) {
2212         av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
2213         goto fail;
2214     }
2215
2216     /* apply global options */
2217     ret = parse_optgroup(NULL, &octx.global_opts);
2218     if (ret < 0) {
2219         av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
2220         goto fail;
2221     }
2222
2223     /* open input files */
2224     ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
2225     if (ret < 0) {
2226         av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
2227         goto fail;
2228     }
2229
2230     /* create the complex filtergraphs */
2231     ret = configure_complex_filters();
2232     if (ret < 0) {
2233         av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
2234         goto fail;
2235     }
2236
2237     /* open output files */
2238     ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
2239     if (ret < 0) {
2240         av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
2241         goto fail;
2242     }
2243
2244 fail:
2245     uninit_parse_context(&octx);
2246     if (ret < 0) {
2247         av_strerror(ret, error, sizeof(error));
2248         av_log(NULL, AV_LOG_FATAL, "%s\n", error);
2249     }
2250     return ret;
2251 }
2252
2253 #define OFFSET(x) offsetof(OptionsContext, x)
2254 const OptionDef options[] = {
2255     /* main options */
2256 #include "cmdutils_common_opts.h"
2257     { "f",              HAS_ARG | OPT_STRING | OPT_OFFSET |
2258                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(format) },
2259         "force format", "fmt" },
2260     { "y",              OPT_BOOL,                                    {              &file_overwrite },
2261         "overwrite output files" },
2262     { "n",              OPT_BOOL,                                    {              &file_skip },
2263         "never overwrite output files" },
2264     { "c",              HAS_ARG | OPT_STRING | OPT_SPEC |
2265                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(codec_names) },
2266         "codec name", "codec" },
2267     { "codec",          HAS_ARG | OPT_STRING | OPT_SPEC |
2268                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(codec_names) },
2269         "codec name", "codec" },
2270     { "pre",            HAS_ARG | OPT_STRING | OPT_SPEC |
2271                         OPT_OUTPUT,                                  { .off       = OFFSET(presets) },
2272         "preset name", "preset" },
2273     { "map",            HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2274                         OPT_OUTPUT,                                  { .func_arg = opt_map },
2275         "set input stream mapping",
2276         "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
2277     { "map_metadata",   HAS_ARG | OPT_STRING | OPT_SPEC |
2278                         OPT_OUTPUT,                                  { .off       = OFFSET(metadata_map) },
2279         "set metadata information of outfile from infile",
2280         "outfile[,metadata]:infile[,metadata]" },
2281     { "map_chapters",   HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
2282                         OPT_OUTPUT,                                  { .off = OFFSET(chapters_input_file) },
2283         "set chapters mapping", "input_file_index" },
2284     { "t",              HAS_ARG | OPT_TIME | OPT_OFFSET |
2285                         OPT_INPUT | OPT_OUTPUT,                      { .off = OFFSET(recording_time) },
2286         "record or transcode \"duration\" seconds of audio/video",
2287         "duration" },
2288     { "fs",             HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
2289         "set the limit file size in bytes", "limit_size" },
2290     { "ss",             HAS_ARG | OPT_TIME | OPT_OFFSET |
2291                         OPT_INPUT | OPT_OUTPUT,                      { .off = OFFSET(start_time) },
2292         "set the start time offset", "time_off" },
2293     { "accurate_seek",  OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
2294                         OPT_INPUT,                                   { .off = OFFSET(accurate_seek) },
2295         "enable/disable accurate seeking with -ss" },
2296     { "itsoffset",      HAS_ARG | OPT_TIME | OPT_OFFSET |
2297                         OPT_EXPERT | OPT_INPUT,                      { .off = OFFSET(input_ts_offset) },
2298         "set the input ts offset", "time_off" },
2299     { "itsscale",       HAS_ARG | OPT_DOUBLE | OPT_SPEC |
2300                         OPT_EXPERT | OPT_INPUT,                      { .off = OFFSET(ts_scale) },
2301         "set the input ts scale", "scale" },
2302     { "metadata",       HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
2303         "add metadata", "string=string" },
2304     { "dframes",        HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2305                         OPT_OUTPUT,                                  { .func_arg = opt_data_frames },
2306         "set the number of data frames to record", "number" },
2307     { "benchmark",      OPT_BOOL | OPT_EXPERT,                       { &do_benchmark },
2308         "add timings for benchmarking" },
2309     { "timelimit",      HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_timelimit },
2310         "set max runtime in seconds", "limit" },
2311     { "dump",           OPT_BOOL | OPT_EXPERT,                       { &do_pkt_dump },
2312         "dump each input packet" },
2313     { "hex",            OPT_BOOL | OPT_EXPERT,                       { &do_hex_dump },
2314         "when dumping packets, also dump the payload" },
2315     { "re",             OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2316                         OPT_INPUT,                                   { .off = OFFSET(rate_emu) },
2317         "read input at native frame rate", "" },
2318     { "target",         HAS_ARG | OPT_PERFILE | OPT_OUTPUT,          { .func_arg = opt_target },
2319         "specify target file type (\"vcd\", \"svcd\", \"dvd\","
2320         " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2321     { "vsync",          HAS_ARG | OPT_EXPERT,                        { opt_vsync },
2322         "video sync method", "" },
2323     { "async",          HAS_ARG | OPT_INT | OPT_EXPERT,              { &audio_sync_method },
2324         "audio sync method", "" },
2325     { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,          { &audio_drift_threshold },
2326         "audio drift threshold", "threshold" },
2327     { "copyts",         OPT_BOOL | OPT_EXPERT,                       { &copy_ts },
2328         "copy timestamps" },
2329     { "copytb",         OPT_BOOL | OPT_EXPERT,                       { &copy_tb },
2330         "copy input stream time base when stream copying" },
2331     { "shortest",       OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2332                         OPT_OUTPUT,                                  { .off = OFFSET(shortest) },
2333         "finish encoding within shortest input" },
2334     { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,       { &dts_delta_threshold },
2335         "timestamp discontinuity delta threshold", "threshold" },
2336     { "xerror",         OPT_BOOL | OPT_EXPERT,                       { &exit_on_error },
2337         "exit on error", "error" },
2338     { "copyinkf",       OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2339                         OPT_OUTPUT,                                  { .off = OFFSET(copy_initial_nonkeyframes) },
2340         "copy initial non-keyframes" },
2341     { "frames",         OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
2342         "set the number of frames to record", "number" },
2343     { "tag",            OPT_STRING | HAS_ARG | OPT_SPEC |
2344                         OPT_EXPERT | OPT_OUTPUT | OPT_INPUT,         { .off = OFFSET(codec_tags) },
2345         "force codec tag/fourcc", "fourcc/tag" },
2346     { "q",              HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
2347                         OPT_SPEC | OPT_OUTPUT,                       { .off = OFFSET(qscale) },
2348         "use fixed quality scale (VBR)", "q" },
2349     { "qscale",         HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
2350                         OPT_SPEC | OPT_OUTPUT,                       { .off = OFFSET(qscale) },
2351         "use fixed quality scale (VBR)", "q" },
2352     { "filter",         HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
2353         "set stream filterchain", "filter_list" },
2354     { "filter_script",  HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
2355         "read stream filtergraph description from a file", "filename" },
2356     { "filter_complex", HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_filter_complex },
2357         "create a complex filtergraph", "graph_description" },
2358     { "filter_complex_script", HAS_ARG | OPT_EXPERT,                 { .func_arg = opt_filter_complex_script },
2359         "read complex filtergraph description from a file", "filename" },
2360     { "stats",          OPT_BOOL,                                    { &print_stats },
2361         "print progress report during encoding", },
2362     { "attach",         HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2363                         OPT_OUTPUT,                                  { .func_arg = opt_attach },
2364         "add an attachment to the output file", "filename" },
2365     { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
2366                          OPT_EXPERT | OPT_INPUT,                     { .off = OFFSET(dump_attachment) },
2367         "extract an attachment into a file", "filename" },
2368
2369     /* video options */
2370     { "vframes",      OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_video_frames },
2371         "set the number of video frames to record", "number" },
2372     { "r",            OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC |
2373                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_rates) },
2374         "set frame rate (Hz value, fraction or abbreviation)", "rate" },
2375     { "s",            OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC |
2376                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_sizes) },
2377         "set frame size (WxH or abbreviation)", "size" },
2378     { "aspect",       OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC |
2379                       OPT_OUTPUT,                                                { .off = OFFSET(frame_aspect_ratios) },
2380         "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
2381     { "pix_fmt",      OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
2382                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_pix_fmts) },
2383         "set pixel format", "format" },
2384     { "vn",           OPT_VIDEO | OPT_BOOL  | OPT_OFFSET | OPT_OUTPUT,           { .off = OFFSET(video_disable) },
2385         "disable video" },
2386     { "vdt",          OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT ,               { &video_discard },
2387         "discard threshold", "n" },
2388     { "rc_override",  OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
2389                       OPT_OUTPUT,                                                { .off = OFFSET(rc_overrides) },
2390         "rate control override for specific intervals", "override" },
2391     { "vcodec",       OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_INPUT |
2392                       OPT_OUTPUT,                                                { .func_arg = opt_video_codec },
2393         "force video codec ('copy' to copy stream)", "codec" },
2394     { "pass",         OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT,     { .off = OFFSET(pass) },
2395         "select the pass number (1 or 2)", "n" },
2396     { "passlogfile",  OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
2397                       OPT_OUTPUT,                                                { .off = OFFSET(passlogfiles) },
2398         "select two pass log file name prefix", "prefix" },
2399     { "vstats",       OPT_VIDEO | OPT_EXPERT ,                                   { &opt_vstats },
2400         "dump video coding statistics to file" },
2401     { "vstats_file",  OPT_VIDEO | HAS_ARG | OPT_EXPERT ,                         { opt_vstats_file },
2402         "dump video coding statistics to file", "file" },
2403     { "vf",           OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_video_filters },
2404         "video filters", "filter list" },
2405     { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
2406                       OPT_OUTPUT,                                                { .off = OFFSET(intra_matrices) },
2407         "specify intra matrix coeffs", "matrix" },
2408     { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
2409                       OPT_OUTPUT,                                                { .off = OFFSET(inter_matrices) },
2410         "specify inter matrix coeffs", "matrix" },
2411     { "top",          OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_INT| OPT_SPEC |
2412                       OPT_OUTPUT,                                                { .off = OFFSET(top_field_first) },
2413         "top=1/bottom=0/auto=-1 field first", "" },
2414     { "dc",           OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT ,               { &intra_dc_precision },
2415         "intra_dc_precision", "precision" },
2416     { "vtag",         OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_PERFILE |
2417                       OPT_OUTPUT,                                                { .func_arg = opt_video_tag },
2418         "force video tag/fourcc", "fourcc/tag" },
2419     { "qphist",       OPT_VIDEO | OPT_BOOL | OPT_EXPERT ,                        { &qp_hist },
2420         "show QP histogram" },
2421     { "force_fps",    OPT_VIDEO | OPT_BOOL | OPT_EXPERT  | OPT_SPEC |
2422                       OPT_OUTPUT,                                                { .off = OFFSET(force_fps) },
2423         "force the selected framerate, disable the best supported framerate selection" },
2424     { "streamid",     OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2425                       OPT_OUTPUT,                                                { .func_arg = opt_streamid },
2426         "set the value of an outfile streamid", "streamIndex:value" },
2427     { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2428                           OPT_SPEC | OPT_OUTPUT,                                 { .off = OFFSET(forced_key_frames) },
2429         "force key frames at specified timestamps", "timestamps" },
2430     { "hwaccel",          OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2431                           OPT_SPEC | OPT_INPUT,                                  { .off = OFFSET(hwaccels) },
2432         "use HW accelerated decoding", "hwaccel name" },
2433     { "hwaccel_device",   OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2434                           OPT_SPEC | OPT_INPUT,                                  { .off = OFFSET(hwaccel_devices) },
2435         "select a device for HW acceleration" "devicename" },
2436     { "autorotate",       HAS_ARG | OPT_BOOL | OPT_SPEC |
2437                           OPT_EXPERT | OPT_INPUT,                                { .off = OFFSET(autorotate) },
2438         "automatically insert correct rotate filters" },
2439
2440     /* audio options */
2441     { "aframes",        OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_frames },
2442         "set the number of audio frames to record", "number" },
2443     { "aq",             OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_qscale },
2444         "set audio quality (codec-specific)", "quality", },
2445     { "ar",             OPT_AUDIO | HAS_ARG  | OPT_INT | OPT_SPEC |
2446                         OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(audio_sample_rate) },
2447         "set audio sampling rate (in Hz)", "rate" },
2448     { "ac",             OPT_AUDIO | HAS_ARG  | OPT_INT | OPT_SPEC |
2449                         OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(audio_channels) },
2450         "set number of audio channels", "channels" },
2451     { "an",             OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_OUTPUT,            { .off = OFFSET(audio_disable) },
2452         "disable audio" },
2453     { "acodec",         OPT_AUDIO | HAS_ARG  | OPT_PERFILE |
2454                         OPT_INPUT | OPT_OUTPUT,                                    { .func_arg = opt_audio_codec },
2455         "force audio codec ('copy' to copy stream)", "codec" },
2456     { "atag",           OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_PERFILE |
2457                         OPT_OUTPUT,                                                { .func_arg = opt_audio_tag },
2458         "force audio tag/fourcc", "fourcc/tag" },
2459     { "vol",            OPT_AUDIO | HAS_ARG  | OPT_INT,                            { &audio_volume },
2460         "change audio volume (256=normal)" , "volume" },
2461     { "sample_fmt",     OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_SPEC |
2462                         OPT_STRING | OPT_INPUT | OPT_OUTPUT,                       { .off = OFFSET(sample_fmts) },
2463         "set sample format", "format" },
2464     { "channel_layout", OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_PERFILE |
2465                         OPT_INPUT | OPT_OUTPUT,                                    { .func_arg = opt_channel_layout },
2466         "set channel layout", "layout" },
2467     { "af",             OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_filters },
2468         "audio filters", "filter list" },
2469
2470     /* subtitle options */
2471     { "sn",     OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
2472         "disable subtitle" },
2473     { "scodec", OPT_SUBTITLE | HAS_ARG  | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
2474         "force subtitle codec ('copy' to copy stream)", "codec" },
2475     { "stag",   OPT_SUBTITLE | HAS_ARG  | OPT_EXPERT  | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_subtitle_tag }
2476         , "force subtitle tag/fourcc", "fourcc/tag" },
2477
2478     /* grab options */
2479     { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
2480
2481     /* muxer options */
2482     { "muxdelay",   OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
2483         "set the maximum demux-decode delay", "seconds" },
2484     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
2485         "set the initial demux-decode delay", "seconds" },
2486
2487     { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
2488         "A comma-separated list of bitstream filters", "bitstream_filters" },
2489
2490     /* data codec support */
2491     { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
2492         "force data codec ('copy' to copy stream)", "codec" },
2493
2494     { NULL, },
2495 };