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