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