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