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