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