avconv: do not send non-monotonous DTS to the muxers.
[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     ost->last_mux_dts = AV_NOPTS_VALUE;
908
909     return ost;
910 }
911
912 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
913 {
914     int i;
915     const char *p = str;
916     for (i = 0;; i++) {
917         dest[i] = atoi(p);
918         if (i == 63)
919             break;
920         p = strchr(p, ',');
921         if (!p) {
922             av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
923             exit(1);
924         }
925         p++;
926     }
927 }
928
929 /* read file contents into a string */
930 static uint8_t *read_file(const char *filename)
931 {
932     AVIOContext *pb      = NULL;
933     AVIOContext *dyn_buf = NULL;
934     int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
935     uint8_t buf[1024], *str;
936
937     if (ret < 0) {
938         av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
939         return NULL;
940     }
941
942     ret = avio_open_dyn_buf(&dyn_buf);
943     if (ret < 0) {
944         avio_closep(&pb);
945         return NULL;
946     }
947     while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
948         avio_write(dyn_buf, buf, ret);
949     avio_w8(dyn_buf, 0);
950     avio_closep(&pb);
951
952     ret = avio_close_dyn_buf(dyn_buf, &str);
953     if (ret < 0)
954         return NULL;
955     return str;
956 }
957
958 static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
959                              OutputStream *ost)
960 {
961     AVStream *st = ost->st;
962     char *filter = NULL, *filter_script = NULL;
963
964     MATCH_PER_STREAM_OPT(filter_scripts, str, filter_script, oc, st);
965     MATCH_PER_STREAM_OPT(filters, str, filter, oc, st);
966
967     if (filter_script && filter) {
968         av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
969                "output stream #%d:%d.\n", nb_output_files, st->index);
970         exit(1);
971     }
972
973     if (filter_script)
974         return read_file(filter_script);
975     else if (filter)
976         return av_strdup(filter);
977
978     return av_strdup(st->codec->codec_type == AVMEDIA_TYPE_VIDEO ?
979                      "null" : "anull");
980 }
981
982 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc)
983 {
984     AVStream *st;
985     OutputStream *ost;
986     AVCodecContext *video_enc;
987
988     ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO);
989     st  = ost->st;
990     video_enc = st->codec;
991
992     if (!ost->stream_copy) {
993         const char *p = NULL;
994         char *frame_rate = NULL, *frame_size = NULL;
995         char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
996         char *intra_matrix = NULL, *inter_matrix = NULL;
997         int do_pass = 0;
998         int i;
999
1000         MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1001         if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1002             av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1003             exit(1);
1004         }
1005
1006         MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1007         if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1008             av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1009             exit(1);
1010         }
1011
1012         MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1013         if (frame_aspect_ratio)
1014             ost->frame_aspect_ratio = parse_frame_aspect_ratio(frame_aspect_ratio);
1015
1016         MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1017         if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1018             av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1019             exit(1);
1020         }
1021         st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1022
1023         MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1024         if (intra_matrix) {
1025             if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1026                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1027                 exit(1);
1028             }
1029             parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1030         }
1031         MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1032         if (inter_matrix) {
1033             if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1034                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1035                 exit(1);
1036             }
1037             parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1038         }
1039
1040         MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1041         for (i = 0; p; i++) {
1042             int start, end, q;
1043             int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1044             if (e != 3) {
1045                 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1046                 exit(1);
1047             }
1048             video_enc->rc_override =
1049                 av_realloc(video_enc->rc_override,
1050                            sizeof(RcOverride) * (i + 1));
1051             video_enc->rc_override[i].start_frame = start;
1052             video_enc->rc_override[i].end_frame   = end;
1053             if (q > 0) {
1054                 video_enc->rc_override[i].qscale         = q;
1055                 video_enc->rc_override[i].quality_factor = 1.0;
1056             }
1057             else {
1058                 video_enc->rc_override[i].qscale         = 0;
1059                 video_enc->rc_override[i].quality_factor = -q/100.0;
1060             }
1061             p = strchr(p, '/');
1062             if (p) p++;
1063         }
1064         video_enc->rc_override_count = i;
1065         video_enc->intra_dc_precision = intra_dc_precision - 8;
1066
1067         /* two pass mode */
1068         MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1069         if (do_pass) {
1070             if (do_pass == 1) {
1071                 video_enc->flags |= CODEC_FLAG_PASS1;
1072             } else {
1073                 video_enc->flags |= CODEC_FLAG_PASS2;
1074             }
1075         }
1076
1077         MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1078         if (ost->logfile_prefix &&
1079             !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1080             exit(1);
1081
1082         MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1083         if (ost->forced_keyframes)
1084             ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1085
1086         MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1087
1088         ost->top_field_first = -1;
1089         MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1090
1091
1092         ost->avfilter = get_ost_filters(o, oc, ost);
1093         if (!ost->avfilter)
1094             exit(1);
1095     } else {
1096         MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1097     }
1098
1099     return ost;
1100 }
1101
1102 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc)
1103 {
1104     AVStream *st;
1105     OutputStream *ost;
1106     AVCodecContext *audio_enc;
1107
1108     ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO);
1109     st  = ost->st;
1110
1111     audio_enc = st->codec;
1112     audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1113
1114     if (!ost->stream_copy) {
1115         char *sample_fmt = NULL;
1116
1117         MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1118
1119         MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1120         if (sample_fmt &&
1121             (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1122             av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1123             exit(1);
1124         }
1125
1126         MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1127
1128         ost->avfilter = get_ost_filters(o, oc, ost);
1129         if (!ost->avfilter)
1130             exit(1);
1131     }
1132
1133     return ost;
1134 }
1135
1136 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc)
1137 {
1138     OutputStream *ost;
1139
1140     ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA);
1141     if (!ost->stream_copy) {
1142         av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1143         exit(1);
1144     }
1145
1146     return ost;
1147 }
1148
1149 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc)
1150 {
1151     OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT);
1152     ost->stream_copy = 1;
1153     ost->finished    = 1;
1154     return ost;
1155 }
1156
1157 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc)
1158 {
1159     AVStream *st;
1160     OutputStream *ost;
1161     AVCodecContext *subtitle_enc;
1162
1163     ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE);
1164     st  = ost->st;
1165     subtitle_enc = st->codec;
1166
1167     subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1168
1169     return ost;
1170 }
1171
1172 /* arg format is "output-stream-index:streamid-value". */
1173 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1174 {
1175     OptionsContext *o = optctx;
1176     int idx;
1177     char *p;
1178     char idx_str[16];
1179
1180     av_strlcpy(idx_str, arg, sizeof(idx_str));
1181     p = strchr(idx_str, ':');
1182     if (!p) {
1183         av_log(NULL, AV_LOG_FATAL,
1184                "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1185                arg, opt);
1186         exit(1);
1187     }
1188     *p++ = '\0';
1189     idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, INT_MAX);
1190     o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1191     o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1192     return 0;
1193 }
1194
1195 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1196 {
1197     AVFormatContext *is = ifile->ctx;
1198     AVFormatContext *os = ofile->ctx;
1199     AVChapter **tmp;
1200     int i;
1201
1202     tmp = av_realloc(os->chapters, sizeof(*os->chapters) * (is->nb_chapters + os->nb_chapters));
1203     if (!tmp)
1204         return AVERROR(ENOMEM);
1205     os->chapters = tmp;
1206
1207     for (i = 0; i < is->nb_chapters; i++) {
1208         AVChapter *in_ch = is->chapters[i], *out_ch;
1209         int64_t ts_off   = av_rescale_q(ofile->start_time - ifile->ts_offset,
1210                                        AV_TIME_BASE_Q, in_ch->time_base);
1211         int64_t rt       = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1212                            av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1213
1214
1215         if (in_ch->end < ts_off)
1216             continue;
1217         if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1218             break;
1219
1220         out_ch = av_mallocz(sizeof(AVChapter));
1221         if (!out_ch)
1222             return AVERROR(ENOMEM);
1223
1224         out_ch->id        = in_ch->id;
1225         out_ch->time_base = in_ch->time_base;
1226         out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
1227         out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
1228
1229         if (copy_metadata)
1230             av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1231
1232         os->chapters[os->nb_chapters++] = out_ch;
1233     }
1234     return 0;
1235 }
1236
1237 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1238                                AVFormatContext *oc)
1239 {
1240     OutputStream *ost;
1241
1242     switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1243                                   ofilter->out_tmp->pad_idx)) {
1244     case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
1245     case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
1246     default:
1247         av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1248                "currently.\n");
1249         exit(1);
1250     }
1251
1252     ost->source_index = -1;
1253     ost->filter       = ofilter;
1254
1255     ofilter->ost      = ost;
1256
1257     if (ost->stream_copy) {
1258         av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1259                "which is fed from a complex filtergraph. Filtering and streamcopy "
1260                "cannot be used together.\n", ost->file_index, ost->index);
1261         exit(1);
1262     }
1263
1264     if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
1265         av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
1266         exit(1);
1267     }
1268     avfilter_inout_free(&ofilter->out_tmp);
1269 }
1270
1271 static int configure_complex_filters(void)
1272 {
1273     int i, ret = 0;
1274
1275     for (i = 0; i < nb_filtergraphs; i++)
1276         if (!filtergraphs[i]->graph &&
1277             (ret = configure_filtergraph(filtergraphs[i])) < 0)
1278             return ret;
1279     return 0;
1280 }
1281
1282 static int open_output_file(OptionsContext *o, const char *filename)
1283 {
1284     AVFormatContext *oc;
1285     int i, j, err;
1286     AVOutputFormat *file_oformat;
1287     OutputFile *of;
1288     OutputStream *ost;
1289     InputStream  *ist;
1290     AVDictionary *unused_opts = NULL;
1291     AVDictionaryEntry *e = NULL;
1292
1293     if (configure_complex_filters() < 0) {
1294         av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
1295         exit(1);
1296     }
1297
1298     GROW_ARRAY(output_files, nb_output_files);
1299     of = av_mallocz(sizeof(*of));
1300     if (!of)
1301         exit(1);
1302     output_files[nb_output_files - 1] = of;
1303
1304     of->ost_index      = nb_output_streams;
1305     of->recording_time = o->recording_time;
1306     of->start_time     = o->start_time;
1307     of->limit_filesize = o->limit_filesize;
1308     of->shortest       = o->shortest;
1309     av_dict_copy(&of->opts, o->g->format_opts, 0);
1310
1311     if (!strcmp(filename, "-"))
1312         filename = "pipe:";
1313
1314     oc = avformat_alloc_context();
1315     if (!oc) {
1316         print_error(filename, AVERROR(ENOMEM));
1317         exit(1);
1318     }
1319     of->ctx = oc;
1320     if (o->recording_time != INT64_MAX)
1321         oc->duration = o->recording_time;
1322
1323     if (o->format) {
1324         file_oformat = av_guess_format(o->format, NULL, NULL);
1325         if (!file_oformat) {
1326             av_log(NULL, AV_LOG_FATAL, "Requested output format '%s' is not a suitable output format\n", o->format);
1327             exit(1);
1328         }
1329     } else {
1330         file_oformat = av_guess_format(NULL, filename, NULL);
1331         if (!file_oformat) {
1332             av_log(NULL, AV_LOG_FATAL, "Unable to find a suitable output format for '%s'\n",
1333                    filename);
1334             exit(1);
1335         }
1336     }
1337
1338     oc->oformat = file_oformat;
1339     oc->interrupt_callback = int_cb;
1340     av_strlcpy(oc->filename, filename, sizeof(oc->filename));
1341
1342     /* create streams for all unlabeled output pads */
1343     for (i = 0; i < nb_filtergraphs; i++) {
1344         FilterGraph *fg = filtergraphs[i];
1345         for (j = 0; j < fg->nb_outputs; j++) {
1346             OutputFilter *ofilter = fg->outputs[j];
1347
1348             if (!ofilter->out_tmp || ofilter->out_tmp->name)
1349                 continue;
1350
1351             switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1352                                           ofilter->out_tmp->pad_idx)) {
1353             case AVMEDIA_TYPE_VIDEO:    o->video_disable    = 1; break;
1354             case AVMEDIA_TYPE_AUDIO:    o->audio_disable    = 1; break;
1355             case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1356             }
1357             init_output_filter(ofilter, o, oc);
1358         }
1359     }
1360
1361     if (!o->nb_stream_maps) {
1362         /* pick the "best" stream of each type */
1363 #define NEW_STREAM(type, index)\
1364         if (index >= 0) {\
1365             ost = new_ ## type ## _stream(o, oc);\
1366             ost->source_index = index;\
1367             ost->sync_ist     = input_streams[index];\
1368             input_streams[index]->discard = 0;\
1369             input_streams[index]->st->discard = AVDISCARD_NONE;\
1370         }
1371
1372         /* video: highest resolution */
1373         if (!o->video_disable && oc->oformat->video_codec != AV_CODEC_ID_NONE) {
1374             int area = 0, idx = -1;
1375             for (i = 0; i < nb_input_streams; i++) {
1376                 ist = input_streams[i];
1377                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1378                     ist->st->codec->width * ist->st->codec->height > area) {
1379                     area = ist->st->codec->width * ist->st->codec->height;
1380                     idx = i;
1381                 }
1382             }
1383             NEW_STREAM(video, idx);
1384         }
1385
1386         /* audio: most channels */
1387         if (!o->audio_disable && oc->oformat->audio_codec != AV_CODEC_ID_NONE) {
1388             int channels = 0, idx = -1;
1389             for (i = 0; i < nb_input_streams; i++) {
1390                 ist = input_streams[i];
1391                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1392                     ist->st->codec->channels > channels) {
1393                     channels = ist->st->codec->channels;
1394                     idx = i;
1395                 }
1396             }
1397             NEW_STREAM(audio, idx);
1398         }
1399
1400         /* subtitles: pick first */
1401         if (!o->subtitle_disable && oc->oformat->subtitle_codec != AV_CODEC_ID_NONE) {
1402             for (i = 0; i < nb_input_streams; i++)
1403                 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1404                     NEW_STREAM(subtitle, i);
1405                     break;
1406                 }
1407         }
1408         /* do something with data? */
1409     } else {
1410         for (i = 0; i < o->nb_stream_maps; i++) {
1411             StreamMap *map = &o->stream_maps[i];
1412
1413             if (map->disabled)
1414                 continue;
1415
1416             if (map->linklabel) {
1417                 FilterGraph *fg;
1418                 OutputFilter *ofilter = NULL;
1419                 int j, k;
1420
1421                 for (j = 0; j < nb_filtergraphs; j++) {
1422                     fg = filtergraphs[j];
1423                     for (k = 0; k < fg->nb_outputs; k++) {
1424                         AVFilterInOut *out = fg->outputs[k]->out_tmp;
1425                         if (out && !strcmp(out->name, map->linklabel)) {
1426                             ofilter = fg->outputs[k];
1427                             goto loop_end;
1428                         }
1429                     }
1430                 }
1431 loop_end:
1432                 if (!ofilter) {
1433                     av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1434                            "in any defined filter graph.\n", map->linklabel);
1435                     exit(1);
1436                 }
1437                 init_output_filter(ofilter, o, oc);
1438             } else {
1439                 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
1440                 switch (ist->st->codec->codec_type) {
1441                 case AVMEDIA_TYPE_VIDEO:    ost = new_video_stream(o, oc);    break;
1442                 case AVMEDIA_TYPE_AUDIO:    ost = new_audio_stream(o, oc);    break;
1443                 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(o, oc); break;
1444                 case AVMEDIA_TYPE_DATA:     ost = new_data_stream(o, oc);     break;
1445                 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc); break;
1446                 default:
1447                     av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
1448                            map->file_index, map->stream_index);
1449                     exit(1);
1450                 }
1451
1452                 ost->source_index = input_files[map->file_index]->ist_index + map->stream_index;
1453                 ost->sync_ist     = input_streams[input_files[map->sync_file_index]->ist_index +
1454                                                map->sync_stream_index];
1455                 ist->discard = 0;
1456                 ist->st->discard = AVDISCARD_NONE;
1457             }
1458         }
1459     }
1460
1461     /* handle attached files */
1462     for (i = 0; i < o->nb_attachments; i++) {
1463         AVIOContext *pb;
1464         uint8_t *attachment;
1465         const char *p;
1466         int64_t len;
1467
1468         if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
1469             av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
1470                    o->attachments[i]);
1471             exit(1);
1472         }
1473         if ((len = avio_size(pb)) <= 0) {
1474             av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
1475                    o->attachments[i]);
1476             exit(1);
1477         }
1478         if (!(attachment = av_malloc(len))) {
1479             av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
1480                    o->attachments[i]);
1481             exit(1);
1482         }
1483         avio_read(pb, attachment, len);
1484
1485         ost = new_attachment_stream(o, oc);
1486         ost->stream_copy               = 0;
1487         ost->source_index              = -1;
1488         ost->attachment_filename       = o->attachments[i];
1489         ost->st->codec->extradata      = attachment;
1490         ost->st->codec->extradata_size = len;
1491
1492         p = strrchr(o->attachments[i], '/');
1493         av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
1494         avio_close(pb);
1495     }
1496
1497     /* check if all codec options have been used */
1498     unused_opts = strip_specifiers(o->g->codec_opts);
1499     for (i = of->ost_index; i < nb_output_streams; i++) {
1500         e = NULL;
1501         while ((e = av_dict_get(output_streams[i]->opts, "", e,
1502                                 AV_DICT_IGNORE_SUFFIX)))
1503             av_dict_set(&unused_opts, e->key, NULL, 0);
1504     }
1505
1506     e = NULL;
1507     while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
1508         const AVClass *class = avcodec_get_class();
1509         const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
1510                                              AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1511         if (!option)
1512             continue;
1513         if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
1514             av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
1515                    "output file #%d (%s) is not an encoding option.\n", e->key,
1516                    option->help ? option->help : "", nb_output_files - 1,
1517                    filename);
1518             exit(1);
1519         }
1520
1521         av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
1522                "output file #%d (%s) has not been used for any stream. The most "
1523                "likely reason is either wrong type (e.g. a video option with "
1524                "no video streams) or that it is a private option of some encoder "
1525                "which was not actually used for any stream.\n", e->key,
1526                option->help ? option->help : "", nb_output_files - 1, filename);
1527     }
1528     av_dict_free(&unused_opts);
1529
1530     /* check filename in case of an image number is expected */
1531     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
1532         if (!av_filename_number_test(oc->filename)) {
1533             print_error(oc->filename, AVERROR(EINVAL));
1534             exit(1);
1535         }
1536     }
1537
1538     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
1539         /* test if it already exists to avoid losing precious files */
1540         assert_file_overwrite(filename);
1541
1542         /* open the file */
1543         if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
1544                               &oc->interrupt_callback,
1545                               &of->opts)) < 0) {
1546             print_error(filename, err);
1547             exit(1);
1548         }
1549     }
1550
1551     if (o->mux_preload) {
1552         uint8_t buf[64];
1553         snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
1554         av_dict_set(&of->opts, "preload", buf, 0);
1555     }
1556     oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
1557     oc->flags |= AVFMT_FLAG_NONBLOCK;
1558
1559     /* copy metadata */
1560     for (i = 0; i < o->nb_metadata_map; i++) {
1561         char *p;
1562         int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
1563
1564         if (in_file_index >= nb_input_files) {
1565             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
1566             exit(1);
1567         }
1568         copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
1569                       in_file_index >= 0 ?
1570                       input_files[in_file_index]->ctx : NULL, o);
1571     }
1572
1573     /* copy chapters */
1574     if (o->chapters_input_file >= nb_input_files) {
1575         if (o->chapters_input_file == INT_MAX) {
1576             /* copy chapters from the first input file that has them*/
1577             o->chapters_input_file = -1;
1578             for (i = 0; i < nb_input_files; i++)
1579                 if (input_files[i]->ctx->nb_chapters) {
1580                     o->chapters_input_file = i;
1581                     break;
1582                 }
1583         } else {
1584             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
1585                    o->chapters_input_file);
1586             exit(1);
1587         }
1588     }
1589     if (o->chapters_input_file >= 0)
1590         copy_chapters(input_files[o->chapters_input_file], of,
1591                       !o->metadata_chapters_manual);
1592
1593     /* copy global metadata by default */
1594     if (!o->metadata_global_manual && nb_input_files)
1595         av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
1596                      AV_DICT_DONT_OVERWRITE);
1597     if (!o->metadata_streams_manual)
1598         for (i = of->ost_index; i < nb_output_streams; i++) {
1599             InputStream *ist;
1600             if (output_streams[i]->source_index < 0)         /* this is true e.g. for attached files */
1601                 continue;
1602             ist = input_streams[output_streams[i]->source_index];
1603             av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
1604         }
1605
1606     /* process manually set metadata */
1607     for (i = 0; i < o->nb_metadata; i++) {
1608         AVDictionary **m;
1609         char type, *val;
1610         const char *stream_spec;
1611         int index = 0, j, ret;
1612
1613         val = strchr(o->metadata[i].u.str, '=');
1614         if (!val) {
1615             av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
1616                    o->metadata[i].u.str);
1617             exit(1);
1618         }
1619         *val++ = 0;
1620
1621         parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
1622         if (type == 's') {
1623             for (j = 0; j < oc->nb_streams; j++) {
1624                 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
1625                     av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
1626                 } else if (ret < 0)
1627                     exit(1);
1628             }
1629         }
1630         else {
1631             switch (type) {
1632             case 'g':
1633                 m = &oc->metadata;
1634                 break;
1635             case 'c':
1636                 if (index < 0 || index >= oc->nb_chapters) {
1637                     av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
1638                     exit(1);
1639                 }
1640                 m = &oc->chapters[index]->metadata;
1641                 break;
1642             default:
1643                 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
1644                 exit(1);
1645             }
1646             av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
1647         }
1648     }
1649
1650     return 0;
1651 }
1652
1653 static int opt_target(void *optctx, const char *opt, const char *arg)
1654 {
1655     OptionsContext *o = optctx;
1656     enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
1657     static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
1658
1659     if (!strncmp(arg, "pal-", 4)) {
1660         norm = PAL;
1661         arg += 4;
1662     } else if (!strncmp(arg, "ntsc-", 5)) {
1663         norm = NTSC;
1664         arg += 5;
1665     } else if (!strncmp(arg, "film-", 5)) {
1666         norm = FILM;
1667         arg += 5;
1668     } else {
1669         /* Try to determine PAL/NTSC by peeking in the input files */
1670         if (nb_input_files) {
1671             int i, j, fr;
1672             for (j = 0; j < nb_input_files; j++) {
1673                 for (i = 0; i < input_files[j]->nb_streams; i++) {
1674                     AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
1675                     if (c->codec_type != AVMEDIA_TYPE_VIDEO)
1676                         continue;
1677                     fr = c->time_base.den * 1000 / c->time_base.num;
1678                     if (fr == 25000) {
1679                         norm = PAL;
1680                         break;
1681                     } else if ((fr == 29970) || (fr == 23976)) {
1682                         norm = NTSC;
1683                         break;
1684                     }
1685                 }
1686                 if (norm != UNKNOWN)
1687                     break;
1688             }
1689         }
1690         if (norm != UNKNOWN)
1691             av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
1692     }
1693
1694     if (norm == UNKNOWN) {
1695         av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
1696         av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
1697         av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
1698         exit(1);
1699     }
1700
1701     if (!strcmp(arg, "vcd")) {
1702         opt_video_codec(o, "c:v", "mpeg1video");
1703         opt_audio_codec(o, "c:a", "mp2");
1704         parse_option(o, "f", "vcd", options);
1705
1706         parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
1707         parse_option(o, "r", frame_rates[norm], options);
1708         opt_default(NULL, "g", norm == PAL ? "15" : "18");
1709
1710         opt_default(NULL, "b", "1150000");
1711         opt_default(NULL, "maxrate", "1150000");
1712         opt_default(NULL, "minrate", "1150000");
1713         opt_default(NULL, "bufsize", "327680"); // 40*1024*8;
1714
1715         opt_default(NULL, "b:a", "224000");
1716         parse_option(o, "ar", "44100", options);
1717         parse_option(o, "ac", "2", options);
1718
1719         opt_default(NULL, "packetsize", "2324");
1720         opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
1721
1722         /* We have to offset the PTS, so that it is consistent with the SCR.
1723            SCR starts at 36000, but the first two packs contain only padding
1724            and the first pack from the other stream, respectively, may also have
1725            been written before.
1726            So the real data starts at SCR 36000+3*1200. */
1727         o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
1728     } else if (!strcmp(arg, "svcd")) {
1729
1730         opt_video_codec(o, "c:v", "mpeg2video");
1731         opt_audio_codec(o, "c:a", "mp2");
1732         parse_option(o, "f", "svcd", options);
1733
1734         parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
1735         parse_option(o, "r", frame_rates[norm], options);
1736         opt_default(NULL, "g", norm == PAL ? "15" : "18");
1737
1738         opt_default(NULL, "b", "2040000");
1739         opt_default(NULL, "maxrate", "2516000");
1740         opt_default(NULL, "minrate", "0"); // 1145000;
1741         opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
1742         opt_default(NULL, "flags", "+scan_offset");
1743
1744
1745         opt_default(NULL, "b:a", "224000");
1746         parse_option(o, "ar", "44100", options);
1747
1748         opt_default(NULL, "packetsize", "2324");
1749
1750     } else if (!strcmp(arg, "dvd")) {
1751
1752         opt_video_codec(o, "c:v", "mpeg2video");
1753         opt_audio_codec(o, "c:a", "ac3");
1754         parse_option(o, "f", "dvd", options);
1755
1756         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1757         parse_option(o, "r", frame_rates[norm], options);
1758         opt_default(NULL, "g", norm == PAL ? "15" : "18");
1759
1760         opt_default(NULL, "b", "6000000");
1761         opt_default(NULL, "maxrate", "9000000");
1762         opt_default(NULL, "minrate", "0"); // 1500000;
1763         opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
1764
1765         opt_default(NULL, "packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
1766         opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
1767
1768         opt_default(NULL, "b:a", "448000");
1769         parse_option(o, "ar", "48000", options);
1770
1771     } else if (!strncmp(arg, "dv", 2)) {
1772
1773         parse_option(o, "f", "dv", options);
1774
1775         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1776         parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
1777                           norm == PAL ? "yuv420p" : "yuv411p", options);
1778         parse_option(o, "r", frame_rates[norm], options);
1779
1780         parse_option(o, "ar", "48000", options);
1781         parse_option(o, "ac", "2", options);
1782
1783     } else {
1784         av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
1785         return AVERROR(EINVAL);
1786     }
1787     return 0;
1788 }
1789
1790 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
1791 {
1792     av_free (vstats_filename);
1793     vstats_filename = av_strdup (arg);
1794     return 0;
1795 }
1796
1797 static int opt_vstats(void *optctx, const char *opt, const char *arg)
1798 {
1799     char filename[40];
1800     time_t today2 = time(NULL);
1801     struct tm *today = localtime(&today2);
1802
1803     snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
1804              today->tm_sec);
1805     return opt_vstats_file(NULL, opt, filename);
1806 }
1807
1808 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
1809 {
1810     OptionsContext *o = optctx;
1811     return parse_option(o, "frames:v", arg, options);
1812 }
1813
1814 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
1815 {
1816     OptionsContext *o = optctx;
1817     return parse_option(o, "frames:a", arg, options);
1818 }
1819
1820 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
1821 {
1822     OptionsContext *o = optctx;
1823     return parse_option(o, "frames:d", arg, options);
1824 }
1825
1826 static int opt_video_tag(void *optctx, const char *opt, const char *arg)
1827 {
1828     OptionsContext *o = optctx;
1829     return parse_option(o, "tag:v", arg, options);
1830 }
1831
1832 static int opt_audio_tag(void *optctx, const char *opt, const char *arg)
1833 {
1834     OptionsContext *o = optctx;
1835     return parse_option(o, "tag:a", arg, options);
1836 }
1837
1838 static int opt_subtitle_tag(void *optctx, const char *opt, const char *arg)
1839 {
1840     OptionsContext *o = optctx;
1841     return parse_option(o, "tag:s", arg, options);
1842 }
1843
1844 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
1845 {
1846     OptionsContext *o = optctx;
1847     return parse_option(o, "filter:v", arg, options);
1848 }
1849
1850 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
1851 {
1852     OptionsContext *o = optctx;
1853     return parse_option(o, "filter:a", arg, options);
1854 }
1855
1856 static int opt_vsync(void *optctx, const char *opt, const char *arg)
1857 {
1858     if      (!av_strcasecmp(arg, "cfr"))         video_sync_method = VSYNC_CFR;
1859     else if (!av_strcasecmp(arg, "vfr"))         video_sync_method = VSYNC_VFR;
1860     else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
1861
1862     if (video_sync_method == VSYNC_AUTO)
1863         video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
1864     return 0;
1865 }
1866
1867 #if FF_API_DEINTERLACE
1868 static int opt_deinterlace(void *optctx, const char *opt, const char *arg)
1869 {
1870     av_log(NULL, AV_LOG_WARNING, "-%s is deprecated, use -filter:v yadif instead\n", opt);
1871     do_deinterlace = 1;
1872     return 0;
1873 }
1874 #endif
1875
1876 int opt_cpuflags(void *optctx, const char *opt, const char *arg)
1877 {
1878     int flags = av_parse_cpu_flags(arg);
1879
1880     if (flags < 0)
1881         return flags;
1882
1883     av_set_cpu_flags_mask(flags);
1884     return 0;
1885 }
1886
1887 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
1888 {
1889     OptionsContext *o = optctx;
1890     char layout_str[32];
1891     char *stream_str;
1892     char *ac_str;
1893     int ret, channels, ac_str_size;
1894     uint64_t layout;
1895
1896     layout = av_get_channel_layout(arg);
1897     if (!layout) {
1898         av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
1899         return AVERROR(EINVAL);
1900     }
1901     snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
1902     ret = opt_default(NULL, opt, layout_str);
1903     if (ret < 0)
1904         return ret;
1905
1906     /* set 'ac' option based on channel layout */
1907     channels = av_get_channel_layout_nb_channels(layout);
1908     snprintf(layout_str, sizeof(layout_str), "%d", channels);
1909     stream_str = strchr(opt, ':');
1910     ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
1911     ac_str = av_mallocz(ac_str_size);
1912     if (!ac_str)
1913         return AVERROR(ENOMEM);
1914     av_strlcpy(ac_str, "ac", 3);
1915     if (stream_str)
1916         av_strlcat(ac_str, stream_str, ac_str_size);
1917     ret = parse_option(o, ac_str, layout_str, options);
1918     av_free(ac_str);
1919
1920     return ret;
1921 }
1922
1923 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
1924 {
1925     OptionsContext *o = optctx;
1926     return parse_option(o, "q:a", arg, options);
1927 }
1928
1929 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
1930 {
1931     GROW_ARRAY(filtergraphs, nb_filtergraphs);
1932     if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
1933         return AVERROR(ENOMEM);
1934     filtergraphs[nb_filtergraphs - 1]->index      = nb_filtergraphs - 1;
1935     filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
1936     if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
1937         return AVERROR(ENOMEM);
1938     return 0;
1939 }
1940
1941 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
1942 {
1943     uint8_t *graph_desc = read_file(arg);
1944     if (!graph_desc)
1945         return AVERROR(EINVAL);
1946
1947     GROW_ARRAY(filtergraphs, nb_filtergraphs);
1948     if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
1949         return AVERROR(ENOMEM);
1950     filtergraphs[nb_filtergraphs - 1]->index      = nb_filtergraphs - 1;
1951     filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
1952     return 0;
1953 }
1954
1955 void show_help_default(const char *opt, const char *arg)
1956 {
1957     /* per-file options have at least one of those set */
1958     const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
1959     int show_advanced = 0, show_avoptions = 0;
1960
1961     if (opt && *opt) {
1962         if (!strcmp(opt, "long"))
1963             show_advanced = 1;
1964         else if (!strcmp(opt, "full"))
1965             show_advanced = show_avoptions = 1;
1966         else
1967             av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
1968     }
1969
1970     show_usage();
1971
1972     printf("Getting help:\n"
1973            "    -h      -- print basic options\n"
1974            "    -h long -- print more options\n"
1975            "    -h full -- print all options (including all format and codec specific options, very long)\n"
1976            "    See man %s for detailed description of the options.\n"
1977            "\n", program_name);
1978
1979     show_help_options(options, "Print help / information / capabilities:",
1980                       OPT_EXIT, 0, 0);
1981
1982     show_help_options(options, "Global options (affect whole program "
1983                       "instead of just one file:",
1984                       0, per_file | OPT_EXIT | OPT_EXPERT, 0);
1985     if (show_advanced)
1986         show_help_options(options, "Advanced global options:", OPT_EXPERT,
1987                           per_file | OPT_EXIT, 0);
1988
1989     show_help_options(options, "Per-file main options:", 0,
1990                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
1991                       OPT_EXIT, per_file);
1992     if (show_advanced)
1993         show_help_options(options, "Advanced per-file options:",
1994                           OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
1995
1996     show_help_options(options, "Video options:",
1997                       OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
1998     if (show_advanced)
1999         show_help_options(options, "Advanced Video options:",
2000                           OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2001
2002     show_help_options(options, "Audio options:",
2003                       OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2004     if (show_advanced)
2005         show_help_options(options, "Advanced Audio options:",
2006                           OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2007     show_help_options(options, "Subtitle options:",
2008                       OPT_SUBTITLE, 0, 0);
2009     printf("\n");
2010
2011     if (show_avoptions) {
2012         int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2013         show_help_children(avcodec_get_class(), flags);
2014         show_help_children(avformat_get_class(), flags);
2015         show_help_children(sws_get_class(), flags);
2016         show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM);
2017     }
2018 }
2019
2020 void show_usage(void)
2021 {
2022     printf("Hyper fast Audio and Video encoder\n");
2023     printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2024     printf("\n");
2025 }
2026
2027 enum OptGroup {
2028     GROUP_OUTFILE,
2029     GROUP_INFILE,
2030 };
2031
2032 static const OptionGroupDef groups[] = {
2033     [GROUP_OUTFILE] = { "output file",  NULL, OPT_OUTPUT },
2034     [GROUP_INFILE]  = { "input file",   "i",  OPT_INPUT },
2035 };
2036
2037 static int open_files(OptionGroupList *l, const char *inout,
2038                       int (*open_file)(OptionsContext*, const char*))
2039 {
2040     int i, ret;
2041
2042     for (i = 0; i < l->nb_groups; i++) {
2043         OptionGroup *g = &l->groups[i];
2044         OptionsContext o;
2045
2046         init_options(&o);
2047         o.g = g;
2048
2049         ret = parse_optgroup(&o, g);
2050         if (ret < 0) {
2051             av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
2052                    "%s.\n", inout, g->arg);
2053             return ret;
2054         }
2055
2056         av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
2057         ret = open_file(&o, g->arg);
2058         uninit_options(&o);
2059         if (ret < 0) {
2060             av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
2061                    inout, g->arg);
2062             return ret;
2063         }
2064         av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
2065     }
2066
2067     return 0;
2068 }
2069
2070 int avconv_parse_options(int argc, char **argv)
2071 {
2072     OptionParseContext octx;
2073     uint8_t error[128];
2074     int ret;
2075
2076     memset(&octx, 0, sizeof(octx));
2077
2078     /* split the commandline into an internal representation */
2079     ret = split_commandline(&octx, argc, argv, options, groups,
2080                             FF_ARRAY_ELEMS(groups));
2081     if (ret < 0) {
2082         av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
2083         goto fail;
2084     }
2085
2086     /* apply global options */
2087     ret = parse_optgroup(NULL, &octx.global_opts);
2088     if (ret < 0) {
2089         av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
2090         goto fail;
2091     }
2092
2093     /* open input files */
2094     ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
2095     if (ret < 0) {
2096         av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
2097         goto fail;
2098     }
2099
2100     /* open output files */
2101     ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
2102     if (ret < 0) {
2103         av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
2104         goto fail;
2105     }
2106
2107 fail:
2108     uninit_parse_context(&octx);
2109     if (ret < 0) {
2110         av_strerror(ret, error, sizeof(error));
2111         av_log(NULL, AV_LOG_FATAL, "%s\n", error);
2112     }
2113     return ret;
2114 }
2115
2116 #define OFFSET(x) offsetof(OptionsContext, x)
2117 const OptionDef options[] = {
2118     /* main options */
2119 #include "cmdutils_common_opts.h"
2120     { "f",              HAS_ARG | OPT_STRING | OPT_OFFSET |
2121                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(format) },
2122         "force format", "fmt" },
2123     { "y",              OPT_BOOL,                                    {              &file_overwrite },
2124         "overwrite output files" },
2125     { "c",              HAS_ARG | OPT_STRING | OPT_SPEC |
2126                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(codec_names) },
2127         "codec name", "codec" },
2128     { "codec",          HAS_ARG | OPT_STRING | OPT_SPEC |
2129                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(codec_names) },
2130         "codec name", "codec" },
2131     { "pre",            HAS_ARG | OPT_STRING | OPT_SPEC |
2132                         OPT_OUTPUT,                                  { .off       = OFFSET(presets) },
2133         "preset name", "preset" },
2134     { "map",            HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2135                         OPT_OUTPUT,                                  { .func_arg = opt_map },
2136         "set input stream mapping",
2137         "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
2138     { "map_metadata",   HAS_ARG | OPT_STRING | OPT_SPEC |
2139                         OPT_OUTPUT,                                  { .off       = OFFSET(metadata_map) },
2140         "set metadata information of outfile from infile",
2141         "outfile[,metadata]:infile[,metadata]" },
2142     { "map_chapters",   HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
2143                         OPT_OUTPUT,                                  { .off = OFFSET(chapters_input_file) },
2144         "set chapters mapping", "input_file_index" },
2145     { "t",              HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(recording_time) },
2146         "record or transcode \"duration\" seconds of audio/video",
2147         "duration" },
2148     { "fs",             HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
2149         "set the limit file size in bytes", "limit_size" },
2150     { "ss",             HAS_ARG | OPT_TIME | OPT_OFFSET |
2151                         OPT_INPUT | OPT_OUTPUT,                      { .off = OFFSET(start_time) },
2152         "set the start time offset", "time_off" },
2153     { "itsoffset",      HAS_ARG | OPT_TIME | OPT_OFFSET |
2154                         OPT_EXPERT | OPT_INPUT,                      { .off = OFFSET(input_ts_offset) },
2155         "set the input ts offset", "time_off" },
2156     { "itsscale",       HAS_ARG | OPT_DOUBLE | OPT_SPEC |
2157                         OPT_EXPERT | OPT_INPUT,                      { .off = OFFSET(ts_scale) },
2158         "set the input ts scale", "scale" },
2159     { "metadata",       HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
2160         "add metadata", "string=string" },
2161     { "dframes",        HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2162                         OPT_OUTPUT,                                  { .func_arg = opt_data_frames },
2163         "set the number of data frames to record", "number" },
2164     { "benchmark",      OPT_BOOL | OPT_EXPERT,                       { &do_benchmark },
2165         "add timings for benchmarking" },
2166     { "timelimit",      HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_timelimit },
2167         "set max runtime in seconds", "limit" },
2168     { "dump",           OPT_BOOL | OPT_EXPERT,                       { &do_pkt_dump },
2169         "dump each input packet" },
2170     { "hex",            OPT_BOOL | OPT_EXPERT,                       { &do_hex_dump },
2171         "when dumping packets, also dump the payload" },
2172     { "re",             OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2173                         OPT_INPUT,                                   { .off = OFFSET(rate_emu) },
2174         "read input at native frame rate", "" },
2175     { "target",         HAS_ARG | OPT_PERFILE | OPT_OUTPUT,          { .func_arg = opt_target },
2176         "specify target file type (\"vcd\", \"svcd\", \"dvd\","
2177         " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2178     { "vsync",          HAS_ARG | OPT_EXPERT,                        { opt_vsync },
2179         "video sync method", "" },
2180     { "async",          HAS_ARG | OPT_INT | OPT_EXPERT,              { &audio_sync_method },
2181         "audio sync method", "" },
2182     { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,          { &audio_drift_threshold },
2183         "audio drift threshold", "threshold" },
2184     { "copyts",         OPT_BOOL | OPT_EXPERT,                       { &copy_ts },
2185         "copy timestamps" },
2186     { "copytb",         OPT_BOOL | OPT_EXPERT,                       { &copy_tb },
2187         "copy input stream time base when stream copying" },
2188     { "shortest",       OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2189                         OPT_OUTPUT,                                  { .off = OFFSET(shortest) },
2190         "finish encoding within shortest input" },
2191     { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,       { &dts_delta_threshold },
2192         "timestamp discontinuity delta threshold", "threshold" },
2193     { "xerror",         OPT_BOOL | OPT_EXPERT,                       { &exit_on_error },
2194         "exit on error", "error" },
2195     { "copyinkf",       OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2196                         OPT_OUTPUT,                                  { .off = OFFSET(copy_initial_nonkeyframes) },
2197         "copy initial non-keyframes" },
2198     { "frames",         OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
2199         "set the number of frames to record", "number" },
2200     { "tag",            OPT_STRING | HAS_ARG | OPT_SPEC |
2201                         OPT_EXPERT | OPT_OUTPUT,                     { .off = OFFSET(codec_tags) },
2202         "force codec tag/fourcc", "fourcc/tag" },
2203     { "q",              HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
2204                         OPT_SPEC | OPT_OUTPUT,                       { .off = OFFSET(qscale) },
2205         "use fixed quality scale (VBR)", "q" },
2206     { "qscale",         HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
2207                         OPT_SPEC | OPT_OUTPUT,                       { .off = OFFSET(qscale) },
2208         "use fixed quality scale (VBR)", "q" },
2209     { "filter",         HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
2210         "set stream filterchain", "filter_list" },
2211     { "filter_script",  HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
2212         "read stream filtergraph description from a file", "filename" },
2213     { "filter_complex", HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_filter_complex },
2214         "create a complex filtergraph", "graph_description" },
2215     { "filter_complex_script", HAS_ARG | OPT_EXPERT,                 { .func_arg = opt_filter_complex_script },
2216         "read complex filtergraph description from a file", "filename" },
2217     { "stats",          OPT_BOOL,                                    { &print_stats },
2218         "print progress report during encoding", },
2219     { "attach",         HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2220                         OPT_OUTPUT,                                  { .func_arg = opt_attach },
2221         "add an attachment to the output file", "filename" },
2222     { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
2223                          OPT_EXPERT | OPT_INPUT,                     { .off = OFFSET(dump_attachment) },
2224         "extract an attachment into a file", "filename" },
2225     { "cpuflags",       HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_cpuflags },
2226         "set CPU flags mask", "mask" },
2227
2228     /* video options */
2229     { "vframes",      OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_video_frames },
2230         "set the number of video frames to record", "number" },
2231     { "r",            OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC |
2232                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_rates) },
2233         "set frame rate (Hz value, fraction or abbreviation)", "rate" },
2234     { "s",            OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC |
2235                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_sizes) },
2236         "set frame size (WxH or abbreviation)", "size" },
2237     { "aspect",       OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC |
2238                       OPT_OUTPUT,                                                { .off = OFFSET(frame_aspect_ratios) },
2239         "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
2240     { "pix_fmt",      OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
2241                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_pix_fmts) },
2242         "set pixel format", "format" },
2243     { "vn",           OPT_VIDEO | OPT_BOOL  | OPT_OFFSET | OPT_OUTPUT,           { .off = OFFSET(video_disable) },
2244         "disable video" },
2245     { "vdt",          OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT ,               { &video_discard },
2246         "discard threshold", "n" },
2247     { "rc_override",  OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
2248                       OPT_OUTPUT,                                                { .off = OFFSET(rc_overrides) },
2249         "rate control override for specific intervals", "override" },
2250     { "vcodec",       OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_INPUT |
2251                       OPT_OUTPUT,                                                { .func_arg = opt_video_codec },
2252         "force video codec ('copy' to copy stream)", "codec" },
2253     { "pass",         OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT,     { .off = OFFSET(pass) },
2254         "select the pass number (1 or 2)", "n" },
2255     { "passlogfile",  OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
2256                       OPT_OUTPUT,                                                { .off = OFFSET(passlogfiles) },
2257         "select two pass log file name prefix", "prefix" },
2258 #if FF_API_DEINTERLACE
2259     { "deinterlace",  OPT_VIDEO | OPT_EXPERT ,                                   { .func_arg = opt_deinterlace },
2260         "this option is deprecated, use the yadif filter instead" },
2261 #endif
2262     { "vstats",       OPT_VIDEO | OPT_EXPERT ,                                   { &opt_vstats },
2263         "dump video coding statistics to file" },
2264     { "vstats_file",  OPT_VIDEO | HAS_ARG | OPT_EXPERT ,                         { opt_vstats_file },
2265         "dump video coding statistics to file", "file" },
2266     { "vf",           OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_video_filters },
2267         "video filters", "filter list" },
2268     { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
2269                       OPT_OUTPUT,                                                { .off = OFFSET(intra_matrices) },
2270         "specify intra matrix coeffs", "matrix" },
2271     { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
2272                       OPT_OUTPUT,                                                { .off = OFFSET(inter_matrices) },
2273         "specify inter matrix coeffs", "matrix" },
2274     { "top",          OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_INT| OPT_SPEC |
2275                       OPT_OUTPUT,                                                { .off = OFFSET(top_field_first) },
2276         "top=1/bottom=0/auto=-1 field first", "" },
2277     { "dc",           OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT ,               { &intra_dc_precision },
2278         "intra_dc_precision", "precision" },
2279     { "vtag",         OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_PERFILE |
2280                       OPT_OUTPUT,                                                { .func_arg = opt_video_tag },
2281         "force video tag/fourcc", "fourcc/tag" },
2282     { "qphist",       OPT_VIDEO | OPT_BOOL | OPT_EXPERT ,                        { &qp_hist },
2283         "show QP histogram" },
2284     { "force_fps",    OPT_VIDEO | OPT_BOOL | OPT_EXPERT  | OPT_SPEC |
2285                       OPT_OUTPUT,                                                { .off = OFFSET(force_fps) },
2286         "force the selected framerate, disable the best supported framerate selection" },
2287     { "streamid",     OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2288                       OPT_OUTPUT,                                                { .func_arg = opt_streamid },
2289         "set the value of an outfile streamid", "streamIndex:value" },
2290     { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2291                           OPT_SPEC | OPT_OUTPUT,                                 { .off = OFFSET(forced_key_frames) },
2292         "force key frames at specified timestamps", "timestamps" },
2293
2294     /* audio options */
2295     { "aframes",        OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_frames },
2296         "set the number of audio frames to record", "number" },
2297     { "aq",             OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_qscale },
2298         "set audio quality (codec-specific)", "quality", },
2299     { "ar",             OPT_AUDIO | HAS_ARG  | OPT_INT | OPT_SPEC |
2300                         OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(audio_sample_rate) },
2301         "set audio sampling rate (in Hz)", "rate" },
2302     { "ac",             OPT_AUDIO | HAS_ARG  | OPT_INT | OPT_SPEC |
2303                         OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(audio_channels) },
2304         "set number of audio channels", "channels" },
2305     { "an",             OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_OUTPUT,            { .off = OFFSET(audio_disable) },
2306         "disable audio" },
2307     { "acodec",         OPT_AUDIO | HAS_ARG  | OPT_PERFILE |
2308                         OPT_INPUT | OPT_OUTPUT,                                    { .func_arg = opt_audio_codec },
2309         "force audio codec ('copy' to copy stream)", "codec" },
2310     { "atag",           OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_PERFILE |
2311                         OPT_OUTPUT,                                                { .func_arg = opt_audio_tag },
2312         "force audio tag/fourcc", "fourcc/tag" },
2313     { "vol",            OPT_AUDIO | HAS_ARG  | OPT_INT,                            { &audio_volume },
2314         "change audio volume (256=normal)" , "volume" },
2315     { "sample_fmt",     OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_SPEC |
2316                         OPT_STRING | OPT_INPUT | OPT_OUTPUT,                       { .off = OFFSET(sample_fmts) },
2317         "set sample format", "format" },
2318     { "channel_layout", OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_PERFILE |
2319                         OPT_INPUT | OPT_OUTPUT,                                    { .func_arg = opt_channel_layout },
2320         "set channel layout", "layout" },
2321     { "af",             OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_filters },
2322         "audio filters", "filter list" },
2323
2324     /* subtitle options */
2325     { "sn",     OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
2326         "disable subtitle" },
2327     { "scodec", OPT_SUBTITLE | HAS_ARG  | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
2328         "force subtitle codec ('copy' to copy stream)", "codec" },
2329     { "stag",   OPT_SUBTITLE | HAS_ARG  | OPT_EXPERT  | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_subtitle_tag }
2330         , "force subtitle tag/fourcc", "fourcc/tag" },
2331
2332     /* grab options */
2333     { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
2334
2335     /* muxer options */
2336     { "muxdelay",   OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
2337         "set the maximum demux-decode delay", "seconds" },
2338     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
2339         "set the initial demux-decode delay", "seconds" },
2340
2341     { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
2342         "A comma-separated list of bitstream filters", "bitstream_filters" },
2343
2344     /* data codec support */
2345     { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
2346         "force data codec ('copy' to copy stream)", "codec" },
2347
2348     { NULL, },
2349 };