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