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