avconv: make the -pass option per-stream.
[ffmpeg.git] / avconv_opt.c
1 /*
2  * avconv option parsing
3  *
4  * This file is part of Libav.
5  *
6  * Libav is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * Libav is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with Libav; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20
21 #include <stdint.h>
22
23 #include "avconv.h"
24 #include "cmdutils.h"
25
26 #include "libavformat/avformat.h"
27
28 #include "libavcodec/avcodec.h"
29
30 #include "libavfilter/avfilter.h"
31 #include "libavfilter/avfiltergraph.h"
32
33 #include "libavutil/audioconvert.h"
34 #include "libavutil/avassert.h"
35 #include "libavutil/avstring.h"
36 #include "libavutil/avutil.h"
37 #include "libavutil/intreadwrite.h"
38 #include "libavutil/fifo.h"
39 #include "libavutil/mathematics.h"
40 #include "libavutil/opt.h"
41 #include "libavutil/parseutils.h"
42 #include "libavutil/pixdesc.h"
43 #include "libavutil/pixfmt.h"
44
45 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
46 {\
47     int i, ret;\
48     for (i = 0; i < o->nb_ ## name; i++) {\
49         char *spec = o->name[i].specifier;\
50         if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
51             outvar = o->name[i].u.type;\
52         else if (ret < 0)\
53             exit_program(1);\
54     }\
55 }
56
57 char *pass_logfilename_prefix = NULL;
58 char *vstats_filename;
59
60 float audio_drift_threshold = 0.1;
61 float dts_delta_threshold   = 10;
62
63 int audio_volume      = 256;
64 int audio_sync_method = 0;
65 int video_sync_method = VSYNC_AUTO;
66 int do_deinterlace    = 0;
67 int do_benchmark      = 0;
68 int do_hex_dump       = 0;
69 int do_pkt_dump       = 0;
70 int copy_ts           = 0;
71 int copy_tb           = 1;
72 int exit_on_error     = 0;
73 int print_stats       = 1;
74 int qp_hist           = 0;
75 int same_quant        = 0;
76
77 static int file_overwrite     = 0;
78 static int video_discard      = 0;
79 static int intra_dc_precision = 8;
80 static int using_stdin        = 0;
81 static int input_sync;
82
83 void reset_options(OptionsContext *o)
84 {
85     const OptionDef *po = options;
86     int i;
87
88     /* all OPT_SPEC and OPT_STRING can be freed in generic way */
89     while (po->name) {
90         void *dst = (uint8_t*)o + po->u.off;
91
92         if (po->flags & OPT_SPEC) {
93             SpecifierOpt **so = dst;
94             int i, *count = (int*)(so + 1);
95             for (i = 0; i < *count; i++) {
96                 av_freep(&(*so)[i].specifier);
97                 if (po->flags & OPT_STRING)
98                     av_freep(&(*so)[i].u.str);
99             }
100             av_freep(so);
101             *count = 0;
102         } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
103             av_freep(dst);
104         po++;
105     }
106
107     for (i = 0; i < o->nb_stream_maps; i++)
108         av_freep(&o->stream_maps[i].linklabel);
109     av_freep(&o->stream_maps);
110     av_freep(&o->meta_data_maps);
111     av_freep(&o->streamid_map);
112
113     memset(o, 0, sizeof(*o));
114
115     o->mux_max_delay  = 0.7;
116     o->recording_time = INT64_MAX;
117     o->limit_filesize = UINT64_MAX;
118     o->chapters_input_file = INT_MAX;
119
120     uninit_opts();
121     init_opts();
122 }
123
124
125 static double parse_frame_aspect_ratio(const char *arg)
126 {
127     int x = 0, y = 0;
128     double ar = 0;
129     const char *p;
130     char *end;
131
132     p = strchr(arg, ':');
133     if (p) {
134         x = strtol(arg, &end, 10);
135         if (end == p)
136             y = strtol(end + 1, &end, 10);
137         if (x > 0 && y > 0)
138             ar = (double)x / (double)y;
139     } else
140         ar = strtod(arg, NULL);
141
142     if (!ar) {
143         av_log(NULL, AV_LOG_FATAL, "Incorrect aspect ratio specification.\n");
144         exit_program(1);
145     }
146     return ar;
147 }
148
149 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
150 {
151     OptionsContext *o = optctx;
152     return parse_option(o, "codec:a", arg, options);
153 }
154
155 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
156 {
157     OptionsContext *o = optctx;
158     return parse_option(o, "codec:v", arg, options);
159 }
160
161 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
162 {
163     OptionsContext *o = optctx;
164     return parse_option(o, "codec:s", arg, options);
165 }
166
167 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
168 {
169     OptionsContext *o = optctx;
170     return parse_option(o, "codec:d", arg, options);
171 }
172
173 static int opt_map(void *optctx, const char *opt, const char *arg)
174 {
175     OptionsContext *o = optctx;
176     StreamMap *m = NULL;
177     int i, negative = 0, file_idx;
178     int sync_file_idx = -1, sync_stream_idx;
179     char *p, *sync;
180     char *map;
181
182     if (*arg == '-') {
183         negative = 1;
184         arg++;
185     }
186     map = av_strdup(arg);
187
188     /* parse sync stream first, just pick first matching stream */
189     if (sync = strchr(map, ',')) {
190         *sync = 0;
191         sync_file_idx = strtol(sync + 1, &sync, 0);
192         if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
193             av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
194             exit_program(1);
195         }
196         if (*sync)
197             sync++;
198         for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
199             if (check_stream_specifier(input_files[sync_file_idx]->ctx,
200                                        input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
201                 sync_stream_idx = i;
202                 break;
203             }
204         if (i == input_files[sync_file_idx]->nb_streams) {
205             av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
206                                        "match any streams.\n", arg);
207             exit_program(1);
208         }
209     }
210
211
212     if (map[0] == '[') {
213         /* this mapping refers to lavfi output */
214         const char *c = map + 1;
215         o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
216                                     &o->nb_stream_maps, o->nb_stream_maps + 1);
217         m = &o->stream_maps[o->nb_stream_maps - 1];
218         m->linklabel = av_get_token(&c, "]");
219         if (!m->linklabel) {
220             av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
221             exit_program(1);
222         }
223     } else {
224         file_idx = strtol(map, &p, 0);
225         if (file_idx >= nb_input_files || file_idx < 0) {
226             av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
227             exit_program(1);
228         }
229         if (negative)
230             /* disable some already defined maps */
231             for (i = 0; i < o->nb_stream_maps; i++) {
232                 m = &o->stream_maps[i];
233                 if (file_idx == m->file_index &&
234                     check_stream_specifier(input_files[m->file_index]->ctx,
235                                            input_files[m->file_index]->ctx->streams[m->stream_index],
236                                            *p == ':' ? p + 1 : p) > 0)
237                     m->disabled = 1;
238             }
239         else
240             for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
241                 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
242                             *p == ':' ? p + 1 : p) <= 0)
243                     continue;
244                 o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
245                                             &o->nb_stream_maps, o->nb_stream_maps + 1);
246                 m = &o->stream_maps[o->nb_stream_maps - 1];
247
248                 m->file_index   = file_idx;
249                 m->stream_index = i;
250
251                 if (sync_file_idx >= 0) {
252                     m->sync_file_index   = sync_file_idx;
253                     m->sync_stream_index = sync_stream_idx;
254                 } else {
255                     m->sync_file_index   = file_idx;
256                     m->sync_stream_index = i;
257                 }
258             }
259     }
260
261     if (!m) {
262         av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
263         exit_program(1);
264     }
265
266     av_freep(&map);
267     return 0;
268 }
269
270 static int opt_attach(void *optctx, const char *opt, const char *arg)
271 {
272     OptionsContext *o = optctx;
273     o->attachments = grow_array(o->attachments, sizeof(*o->attachments),
274                                 &o->nb_attachments, o->nb_attachments + 1);
275     o->attachments[o->nb_attachments - 1] = arg;
276     return 0;
277 }
278
279 /**
280  * Parse a metadata specifier in arg.
281  * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
282  * @param index for type c/p, chapter/program index is written here
283  * @param stream_spec for type s, the stream specifier is written here
284  */
285 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
286 {
287     if (*arg) {
288         *type = *arg;
289         switch (*arg) {
290         case 'g':
291             break;
292         case 's':
293             if (*(++arg) && *arg != ':') {
294                 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
295                 exit_program(1);
296             }
297             *stream_spec = *arg == ':' ? arg + 1 : "";
298             break;
299         case 'c':
300         case 'p':
301             if (*(++arg) == ':')
302                 *index = strtol(++arg, NULL, 0);
303             break;
304         default:
305             av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
306             exit_program(1);
307         }
308     } else
309         *type = 'g';
310 }
311
312 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
313 {
314     AVDictionary **meta_in = NULL;
315     AVDictionary **meta_out;
316     int i, ret = 0;
317     char type_in, type_out;
318     const char *istream_spec = NULL, *ostream_spec = NULL;
319     int idx_in = 0, idx_out = 0;
320
321     parse_meta_type(inspec,  &type_in,  &idx_in,  &istream_spec);
322     parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
323
324     if (type_in == 'g' || type_out == 'g')
325         o->metadata_global_manual = 1;
326     if (type_in == 's' || type_out == 's')
327         o->metadata_streams_manual = 1;
328     if (type_in == 'c' || type_out == 'c')
329         o->metadata_chapters_manual = 1;
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_program(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         default: av_assert0(0);\
352         }\
353
354     SET_DICT(type_in, meta_in, ic, idx_in);
355     SET_DICT(type_out, meta_out, oc, idx_out);
356
357     /* for input streams choose first matching stream */
358     if (type_in == 's') {
359         for (i = 0; i < ic->nb_streams; i++) {
360             if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
361                 meta_in = &ic->streams[i]->metadata;
362                 break;
363             } else if (ret < 0)
364                 exit_program(1);
365         }
366         if (!meta_in) {
367             av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match  any streams.\n", istream_spec);
368             exit_program(1);
369         }
370     }
371
372     if (type_out == 's') {
373         for (i = 0; i < oc->nb_streams; i++) {
374             if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
375                 meta_out = &oc->streams[i]->metadata;
376                 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
377             } else if (ret < 0)
378                 exit_program(1);
379         }
380     } else
381         av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
382
383     return 0;
384 }
385
386 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
387 {
388     const AVCodecDescriptor *desc;
389     const char *codec_string = encoder ? "encoder" : "decoder";
390     AVCodec *codec;
391
392     codec = encoder ?
393         avcodec_find_encoder_by_name(name) :
394         avcodec_find_decoder_by_name(name);
395
396     if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
397         codec = encoder ? avcodec_find_encoder(desc->id) :
398                           avcodec_find_decoder(desc->id);
399         if (codec)
400             av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
401                    codec_string, codec->name, desc->name);
402     }
403
404     if (!codec) {
405         av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
406         exit_program(1);
407     }
408     if (codec->type != type) {
409         av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
410         exit_program(1);
411     }
412     return codec;
413 }
414
415 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
416 {
417     char *codec_name = NULL;
418
419     MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
420     if (codec_name) {
421         AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
422         st->codec->codec_id = codec->id;
423         return codec;
424     } else
425         return avcodec_find_decoder(st->codec->codec_id);
426 }
427
428 /**
429  * Add all the streams from the given input file to the global
430  * list of input streams.
431  */
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_program(1);
444
445         input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
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_program(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_program(1);
506                 }
507             }
508             else {
509                 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
510                 exit_program(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_program(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_program(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_program(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_program(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_program(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_program(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     input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
659     if (!(input_files[nb_input_files - 1] = av_mallocz(sizeof(*input_files[0]))))
660         exit_program(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_program(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     char *buf = NULL, *arg = NULL, *preset = NULL;
758     AVIOContext *s = NULL;
759
760     if (!st) {
761         av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
762         exit_program(1);
763     }
764
765     if (oc->nb_streams - 1 < o->nb_streamid_map)
766         st->id = o->streamid_map[oc->nb_streams - 1];
767
768     output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
769                                 nb_output_streams + 1);
770     if (!(ost = av_mallocz(sizeof(*ost))))
771         exit_program(1);
772     output_streams[nb_output_streams - 1] = ost;
773
774     ost->file_index = nb_output_files;
775     ost->index      = idx;
776     ost->st         = st;
777     st->codec->codec_type = type;
778     choose_encoder(o, oc, ost);
779     if (ost->enc) {
780         ost->opts  = filter_codec_opts(codec_opts, ost->enc->id, oc, st, ost->enc);
781     }
782
783     avcodec_get_context_defaults3(st->codec, ost->enc);
784     st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
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_program(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_program(1);
809     }
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_program(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 || same_quant) {
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] = 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_program(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_program(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_program(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)) == PIX_FMT_NONE) {
909             av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
910             exit_program(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_program(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_program(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_program(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(forced_key_frames, str, ost->forced_keyframes, oc, st);
971         if (ost->forced_keyframes)
972             ost->forced_keyframes = av_strdup(ost->forced_keyframes);
973
974         MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
975
976         ost->top_field_first = -1;
977         MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
978
979         MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
980         ost->avfilter = av_strdup(filters);
981     } else {
982         MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
983     }
984
985     return ost;
986 }
987
988 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc)
989 {
990     AVStream *st;
991     OutputStream *ost;
992     AVCodecContext *audio_enc;
993
994     ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO);
995     st  = ost->st;
996
997     audio_enc = st->codec;
998     audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
999
1000     if (!ost->stream_copy) {
1001         char *sample_fmt = NULL;
1002         const char *filters = "anull";
1003
1004         MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1005
1006         MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1007         if (sample_fmt &&
1008             (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1009             av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1010             exit_program(1);
1011         }
1012
1013         MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1014
1015         MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
1016         ost->avfilter = av_strdup(filters);
1017     }
1018
1019     return ost;
1020 }
1021
1022 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc)
1023 {
1024     OutputStream *ost;
1025
1026     ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA);
1027     if (!ost->stream_copy) {
1028         av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1029         exit_program(1);
1030     }
1031
1032     return ost;
1033 }
1034
1035 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc)
1036 {
1037     OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT);
1038     ost->stream_copy = 1;
1039     return ost;
1040 }
1041
1042 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc)
1043 {
1044     AVStream *st;
1045     OutputStream *ost;
1046     AVCodecContext *subtitle_enc;
1047
1048     ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE);
1049     st  = ost->st;
1050     subtitle_enc = st->codec;
1051
1052     subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1053
1054     return ost;
1055 }
1056
1057 /* arg format is "output-stream-index:streamid-value". */
1058 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1059 {
1060     OptionsContext *o = optctx;
1061     int idx;
1062     char *p;
1063     char idx_str[16];
1064
1065     av_strlcpy(idx_str, arg, sizeof(idx_str));
1066     p = strchr(idx_str, ':');
1067     if (!p) {
1068         av_log(NULL, AV_LOG_FATAL,
1069                "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1070                arg, opt);
1071         exit_program(1);
1072     }
1073     *p++ = '\0';
1074     idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, INT_MAX);
1075     o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1076     o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1077     return 0;
1078 }
1079
1080 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1081 {
1082     AVFormatContext *is = ifile->ctx;
1083     AVFormatContext *os = ofile->ctx;
1084     int i;
1085
1086     for (i = 0; i < is->nb_chapters; i++) {
1087         AVChapter *in_ch = is->chapters[i], *out_ch;
1088         int64_t ts_off   = av_rescale_q(ofile->start_time - ifile->ts_offset,
1089                                        AV_TIME_BASE_Q, in_ch->time_base);
1090         int64_t rt       = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1091                            av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1092
1093
1094         if (in_ch->end < ts_off)
1095             continue;
1096         if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1097             break;
1098
1099         out_ch = av_mallocz(sizeof(AVChapter));
1100         if (!out_ch)
1101             return AVERROR(ENOMEM);
1102
1103         out_ch->id        = in_ch->id;
1104         out_ch->time_base = in_ch->time_base;
1105         out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
1106         out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
1107
1108         if (copy_metadata)
1109             av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1110
1111         os->nb_chapters++;
1112         os->chapters = av_realloc(os->chapters, sizeof(AVChapter) * os->nb_chapters);
1113         if (!os->chapters)
1114             return AVERROR(ENOMEM);
1115         os->chapters[os->nb_chapters - 1] = out_ch;
1116     }
1117     return 0;
1118 }
1119
1120 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1121                                AVFormatContext *oc)
1122 {
1123     OutputStream *ost;
1124
1125     switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1126                                   ofilter->out_tmp->pad_idx)) {
1127     case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
1128     case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
1129     default:
1130         av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1131                "currently.\n");
1132         exit_program(1);
1133     }
1134
1135     ost->source_index = -1;
1136     ost->filter       = ofilter;
1137
1138     ofilter->ost      = ost;
1139
1140     if (ost->stream_copy) {
1141         av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1142                "which is fed from a complex filtergraph. Filtering and streamcopy "
1143                "cannot be used together.\n", ost->file_index, ost->index);
1144         exit_program(1);
1145     }
1146
1147     if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
1148         av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
1149         exit_program(1);
1150     }
1151     avfilter_inout_free(&ofilter->out_tmp);
1152 }
1153
1154 static int configure_complex_filters(void)
1155 {
1156     int i, ret = 0;
1157
1158     for (i = 0; i < nb_filtergraphs; i++)
1159         if (!filtergraphs[i]->graph &&
1160             (ret = configure_filtergraph(filtergraphs[i])) < 0)
1161             return ret;
1162     return 0;
1163 }
1164
1165 void opt_output_file(void *optctx, const char *filename)
1166 {
1167     OptionsContext *o = optctx;
1168     AVFormatContext *oc;
1169     int i, j, err;
1170     AVOutputFormat *file_oformat;
1171     OutputStream *ost;
1172     InputStream  *ist;
1173
1174     if (configure_complex_filters() < 0) {
1175         av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
1176         exit_program(1);
1177     }
1178
1179     if (!strcmp(filename, "-"))
1180         filename = "pipe:";
1181
1182     oc = avformat_alloc_context();
1183     if (!oc) {
1184         print_error(filename, AVERROR(ENOMEM));
1185         exit_program(1);
1186     }
1187
1188     if (o->format) {
1189         file_oformat = av_guess_format(o->format, NULL, NULL);
1190         if (!file_oformat) {
1191             av_log(NULL, AV_LOG_FATAL, "Requested output format '%s' is not a suitable output format\n", o->format);
1192             exit_program(1);
1193         }
1194     } else {
1195         file_oformat = av_guess_format(NULL, filename, NULL);
1196         if (!file_oformat) {
1197             av_log(NULL, AV_LOG_FATAL, "Unable to find a suitable output format for '%s'\n",
1198                    filename);
1199             exit_program(1);
1200         }
1201     }
1202
1203     oc->oformat = file_oformat;
1204     oc->interrupt_callback = int_cb;
1205     av_strlcpy(oc->filename, filename, sizeof(oc->filename));
1206
1207     /* create streams for all unlabeled output pads */
1208     for (i = 0; i < nb_filtergraphs; i++) {
1209         FilterGraph *fg = filtergraphs[i];
1210         for (j = 0; j < fg->nb_outputs; j++) {
1211             OutputFilter *ofilter = fg->outputs[j];
1212
1213             if (!ofilter->out_tmp || ofilter->out_tmp->name)
1214                 continue;
1215
1216             switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1217                                           ofilter->out_tmp->pad_idx)) {
1218             case AVMEDIA_TYPE_VIDEO:    o->video_disable    = 1; break;
1219             case AVMEDIA_TYPE_AUDIO:    o->audio_disable    = 1; break;
1220             case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1221             }
1222             init_output_filter(ofilter, o, oc);
1223         }
1224     }
1225
1226     if (!o->nb_stream_maps) {
1227         /* pick the "best" stream of each type */
1228 #define NEW_STREAM(type, index)\
1229         if (index >= 0) {\
1230             ost = new_ ## type ## _stream(o, oc);\
1231             ost->source_index = index;\
1232             ost->sync_ist     = input_streams[index];\
1233             input_streams[index]->discard = 0;\
1234             input_streams[index]->st->discard = AVDISCARD_NONE;\
1235         }
1236
1237         /* video: highest resolution */
1238         if (!o->video_disable && oc->oformat->video_codec != AV_CODEC_ID_NONE) {
1239             int area = 0, idx = -1;
1240             for (i = 0; i < nb_input_streams; i++) {
1241                 ist = input_streams[i];
1242                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1243                     ist->st->codec->width * ist->st->codec->height > area) {
1244                     area = ist->st->codec->width * ist->st->codec->height;
1245                     idx = i;
1246                 }
1247             }
1248             NEW_STREAM(video, idx);
1249         }
1250
1251         /* audio: most channels */
1252         if (!o->audio_disable && oc->oformat->audio_codec != AV_CODEC_ID_NONE) {
1253             int channels = 0, idx = -1;
1254             for (i = 0; i < nb_input_streams; i++) {
1255                 ist = input_streams[i];
1256                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1257                     ist->st->codec->channels > channels) {
1258                     channels = ist->st->codec->channels;
1259                     idx = i;
1260                 }
1261             }
1262             NEW_STREAM(audio, idx);
1263         }
1264
1265         /* subtitles: pick first */
1266         if (!o->subtitle_disable && oc->oformat->subtitle_codec != AV_CODEC_ID_NONE) {
1267             for (i = 0; i < nb_input_streams; i++)
1268                 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1269                     NEW_STREAM(subtitle, i);
1270                     break;
1271                 }
1272         }
1273         /* do something with data? */
1274     } else {
1275         for (i = 0; i < o->nb_stream_maps; i++) {
1276             StreamMap *map = &o->stream_maps[i];
1277
1278             if (map->disabled)
1279                 continue;
1280
1281             if (map->linklabel) {
1282                 FilterGraph *fg;
1283                 OutputFilter *ofilter = NULL;
1284                 int j, k;
1285
1286                 for (j = 0; j < nb_filtergraphs; j++) {
1287                     fg = filtergraphs[j];
1288                     for (k = 0; k < fg->nb_outputs; k++) {
1289                         AVFilterInOut *out = fg->outputs[k]->out_tmp;
1290                         if (out && !strcmp(out->name, map->linklabel)) {
1291                             ofilter = fg->outputs[k];
1292                             goto loop_end;
1293                         }
1294                     }
1295                 }
1296 loop_end:
1297                 if (!ofilter) {
1298                     av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1299                            "in any defined filter graph.\n", map->linklabel);
1300                     exit_program(1);
1301                 }
1302                 init_output_filter(ofilter, o, oc);
1303             } else {
1304                 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
1305                 switch (ist->st->codec->codec_type) {
1306                 case AVMEDIA_TYPE_VIDEO:    ost = new_video_stream(o, oc);    break;
1307                 case AVMEDIA_TYPE_AUDIO:    ost = new_audio_stream(o, oc);    break;
1308                 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(o, oc); break;
1309                 case AVMEDIA_TYPE_DATA:     ost = new_data_stream(o, oc);     break;
1310                 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc); break;
1311                 default:
1312                     av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
1313                            map->file_index, map->stream_index);
1314                     exit_program(1);
1315                 }
1316
1317                 ost->source_index = input_files[map->file_index]->ist_index + map->stream_index;
1318                 ost->sync_ist     = input_streams[input_files[map->sync_file_index]->ist_index +
1319                                                map->sync_stream_index];
1320                 ist->discard = 0;
1321                 ist->st->discard = AVDISCARD_NONE;
1322             }
1323         }
1324     }
1325
1326     /* handle attached files */
1327     for (i = 0; i < o->nb_attachments; i++) {
1328         AVIOContext *pb;
1329         uint8_t *attachment;
1330         const char *p;
1331         int64_t len;
1332
1333         if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
1334             av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
1335                    o->attachments[i]);
1336             exit_program(1);
1337         }
1338         if ((len = avio_size(pb)) <= 0) {
1339             av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
1340                    o->attachments[i]);
1341             exit_program(1);
1342         }
1343         if (!(attachment = av_malloc(len))) {
1344             av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
1345                    o->attachments[i]);
1346             exit_program(1);
1347         }
1348         avio_read(pb, attachment, len);
1349
1350         ost = new_attachment_stream(o, oc);
1351         ost->stream_copy               = 0;
1352         ost->source_index              = -1;
1353         ost->attachment_filename       = o->attachments[i];
1354         ost->st->codec->extradata      = attachment;
1355         ost->st->codec->extradata_size = len;
1356
1357         p = strrchr(o->attachments[i], '/');
1358         av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
1359         avio_close(pb);
1360     }
1361
1362     output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
1363     if (!(output_files[nb_output_files - 1] = av_mallocz(sizeof(*output_files[0]))))
1364         exit_program(1);
1365
1366     output_files[nb_output_files - 1]->ctx            = oc;
1367     output_files[nb_output_files - 1]->ost_index      = nb_output_streams - oc->nb_streams;
1368     output_files[nb_output_files - 1]->recording_time = o->recording_time;
1369     if (o->recording_time != INT64_MAX)
1370         oc->duration = o->recording_time;
1371     output_files[nb_output_files - 1]->start_time     = o->start_time;
1372     output_files[nb_output_files - 1]->limit_filesize = o->limit_filesize;
1373     output_files[nb_output_files - 1]->shortest       = o->shortest;
1374     av_dict_copy(&output_files[nb_output_files - 1]->opts, format_opts, 0);
1375
1376     /* check filename in case of an image number is expected */
1377     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
1378         if (!av_filename_number_test(oc->filename)) {
1379             print_error(oc->filename, AVERROR(EINVAL));
1380             exit_program(1);
1381         }
1382     }
1383
1384     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
1385         /* test if it already exists to avoid losing precious files */
1386         assert_file_overwrite(filename);
1387
1388         /* open the file */
1389         if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
1390                               &oc->interrupt_callback,
1391                               &output_files[nb_output_files - 1]->opts)) < 0) {
1392             print_error(filename, err);
1393             exit_program(1);
1394         }
1395     }
1396
1397     if (o->mux_preload) {
1398         uint8_t buf[64];
1399         snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
1400         av_dict_set(&output_files[nb_output_files - 1]->opts, "preload", buf, 0);
1401     }
1402     oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
1403     oc->flags |= AVFMT_FLAG_NONBLOCK;
1404
1405     /* copy metadata */
1406     for (i = 0; i < o->nb_metadata_map; i++) {
1407         char *p;
1408         int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
1409
1410         if (in_file_index < 0)
1411             continue;
1412         if (in_file_index >= nb_input_files) {
1413             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
1414             exit_program(1);
1415         }
1416         copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc, input_files[in_file_index]->ctx, o);
1417     }
1418
1419     /* copy chapters */
1420     if (o->chapters_input_file >= nb_input_files) {
1421         if (o->chapters_input_file == INT_MAX) {
1422             /* copy chapters from the first input file that has them*/
1423             o->chapters_input_file = -1;
1424             for (i = 0; i < nb_input_files; i++)
1425                 if (input_files[i]->ctx->nb_chapters) {
1426                     o->chapters_input_file = i;
1427                     break;
1428                 }
1429         } else {
1430             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
1431                    o->chapters_input_file);
1432             exit_program(1);
1433         }
1434     }
1435     if (o->chapters_input_file >= 0)
1436         copy_chapters(input_files[o->chapters_input_file], output_files[nb_output_files - 1],
1437                       !o->metadata_chapters_manual);
1438
1439     /* copy global metadata by default */
1440     if (!o->metadata_global_manual && nb_input_files)
1441         av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
1442                      AV_DICT_DONT_OVERWRITE);
1443     if (!o->metadata_streams_manual)
1444         for (i = output_files[nb_output_files - 1]->ost_index; i < nb_output_streams; i++) {
1445             InputStream *ist;
1446             if (output_streams[i]->source_index < 0)         /* this is true e.g. for attached files */
1447                 continue;
1448             ist = input_streams[output_streams[i]->source_index];
1449             av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
1450         }
1451
1452     /* process manually set metadata */
1453     for (i = 0; i < o->nb_metadata; i++) {
1454         AVDictionary **m;
1455         char type, *val;
1456         const char *stream_spec;
1457         int index = 0, j, ret;
1458
1459         val = strchr(o->metadata[i].u.str, '=');
1460         if (!val) {
1461             av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
1462                    o->metadata[i].u.str);
1463             exit_program(1);
1464         }
1465         *val++ = 0;
1466
1467         parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
1468         if (type == 's') {
1469             for (j = 0; j < oc->nb_streams; j++) {
1470                 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
1471                     av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
1472                 } else if (ret < 0)
1473                     exit_program(1);
1474             }
1475         }
1476         else {
1477             switch (type) {
1478             case 'g':
1479                 m = &oc->metadata;
1480                 break;
1481             case 'c':
1482                 if (index < 0 || index >= oc->nb_chapters) {
1483                     av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
1484                     exit_program(1);
1485                 }
1486                 m = &oc->chapters[index]->metadata;
1487                 break;
1488             default:
1489                 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
1490                 exit_program(1);
1491             }
1492             av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
1493         }
1494     }
1495
1496     reset_options(o);
1497 }
1498
1499 static int opt_target(void *optctx, const char *opt, const char *arg)
1500 {
1501     OptionsContext *o = optctx;
1502     enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
1503     static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
1504
1505     if (!strncmp(arg, "pal-", 4)) {
1506         norm = PAL;
1507         arg += 4;
1508     } else if (!strncmp(arg, "ntsc-", 5)) {
1509         norm = NTSC;
1510         arg += 5;
1511     } else if (!strncmp(arg, "film-", 5)) {
1512         norm = FILM;
1513         arg += 5;
1514     } else {
1515         /* Try to determine PAL/NTSC by peeking in the input files */
1516         if (nb_input_files) {
1517             int i, j, fr;
1518             for (j = 0; j < nb_input_files; j++) {
1519                 for (i = 0; i < input_files[j]->nb_streams; i++) {
1520                     AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
1521                     if (c->codec_type != AVMEDIA_TYPE_VIDEO)
1522                         continue;
1523                     fr = c->time_base.den * 1000 / c->time_base.num;
1524                     if (fr == 25000) {
1525                         norm = PAL;
1526                         break;
1527                     } else if ((fr == 29970) || (fr == 23976)) {
1528                         norm = NTSC;
1529                         break;
1530                     }
1531                 }
1532                 if (norm != UNKNOWN)
1533                     break;
1534             }
1535         }
1536         if (norm != UNKNOWN)
1537             av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
1538     }
1539
1540     if (norm == UNKNOWN) {
1541         av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
1542         av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
1543         av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
1544         exit_program(1);
1545     }
1546
1547     if (!strcmp(arg, "vcd")) {
1548         opt_video_codec(o, "c:v", "mpeg1video");
1549         opt_audio_codec(o, "c:a", "mp2");
1550         parse_option(o, "f", "vcd", options);
1551
1552         parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
1553         parse_option(o, "r", frame_rates[norm], options);
1554         opt_default("g", norm == PAL ? "15" : "18");
1555
1556         opt_default("b", "1150000");
1557         opt_default("maxrate", "1150000");
1558         opt_default("minrate", "1150000");
1559         opt_default("bufsize", "327680"); // 40*1024*8;
1560
1561         opt_default("b:a", "224000");
1562         parse_option(o, "ar", "44100", options);
1563         parse_option(o, "ac", "2", options);
1564
1565         opt_default("packetsize", "2324");
1566         opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
1567
1568         /* We have to offset the PTS, so that it is consistent with the SCR.
1569            SCR starts at 36000, but the first two packs contain only padding
1570            and the first pack from the other stream, respectively, may also have
1571            been written before.
1572            So the real data starts at SCR 36000+3*1200. */
1573         o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
1574     } else if (!strcmp(arg, "svcd")) {
1575
1576         opt_video_codec(o, "c:v", "mpeg2video");
1577         opt_audio_codec(o, "c:a", "mp2");
1578         parse_option(o, "f", "svcd", options);
1579
1580         parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
1581         parse_option(o, "r", frame_rates[norm], options);
1582         opt_default("g", norm == PAL ? "15" : "18");
1583
1584         opt_default("b", "2040000");
1585         opt_default("maxrate", "2516000");
1586         opt_default("minrate", "0"); // 1145000;
1587         opt_default("bufsize", "1835008"); // 224*1024*8;
1588         opt_default("flags", "+scan_offset");
1589
1590
1591         opt_default("b:a", "224000");
1592         parse_option(o, "ar", "44100", options);
1593
1594         opt_default("packetsize", "2324");
1595
1596     } else if (!strcmp(arg, "dvd")) {
1597
1598         opt_video_codec(o, "c:v", "mpeg2video");
1599         opt_audio_codec(o, "c:a", "ac3");
1600         parse_option(o, "f", "dvd", options);
1601
1602         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1603         parse_option(o, "r", frame_rates[norm], options);
1604         opt_default("g", norm == PAL ? "15" : "18");
1605
1606         opt_default("b", "6000000");
1607         opt_default("maxrate", "9000000");
1608         opt_default("minrate", "0"); // 1500000;
1609         opt_default("bufsize", "1835008"); // 224*1024*8;
1610
1611         opt_default("packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
1612         opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
1613
1614         opt_default("b:a", "448000");
1615         parse_option(o, "ar", "48000", options);
1616
1617     } else if (!strncmp(arg, "dv", 2)) {
1618
1619         parse_option(o, "f", "dv", options);
1620
1621         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1622         parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
1623                           norm == PAL ? "yuv420p" : "yuv411p", options);
1624         parse_option(o, "r", frame_rates[norm], options);
1625
1626         parse_option(o, "ar", "48000", options);
1627         parse_option(o, "ac", "2", options);
1628
1629     } else {
1630         av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
1631         return AVERROR(EINVAL);
1632     }
1633     return 0;
1634 }
1635
1636 static int opt_vstats_file(const char *opt, const char *arg)
1637 {
1638     av_free (vstats_filename);
1639     vstats_filename = av_strdup (arg);
1640     return 0;
1641 }
1642
1643 static int opt_vstats(const char *opt, const char *arg)
1644 {
1645     char filename[40];
1646     time_t today2 = time(NULL);
1647     struct tm *today = localtime(&today2);
1648
1649     snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
1650              today->tm_sec);
1651     return opt_vstats_file(opt, filename);
1652 }
1653
1654 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
1655 {
1656     OptionsContext *o = optctx;
1657     return parse_option(o, "frames:v", arg, options);
1658 }
1659
1660 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
1661 {
1662     OptionsContext *o = optctx;
1663     return parse_option(o, "frames:a", arg, options);
1664 }
1665
1666 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
1667 {
1668     OptionsContext *o = optctx;
1669     return parse_option(o, "frames:d", arg, options);
1670 }
1671
1672 static int opt_video_tag(void *optctx, const char *opt, const char *arg)
1673 {
1674     OptionsContext *o = optctx;
1675     return parse_option(o, "tag:v", arg, options);
1676 }
1677
1678 static int opt_audio_tag(void *optctx, const char *opt, const char *arg)
1679 {
1680     OptionsContext *o = optctx;
1681     return parse_option(o, "tag:a", arg, options);
1682 }
1683
1684 static int opt_subtitle_tag(void *optctx, const char *opt, const char *arg)
1685 {
1686     OptionsContext *o = optctx;
1687     return parse_option(o, "tag:s", arg, options);
1688 }
1689
1690 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
1691 {
1692     OptionsContext *o = optctx;
1693     return parse_option(o, "filter:v", arg, options);
1694 }
1695
1696 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
1697 {
1698     OptionsContext *o = optctx;
1699     return parse_option(o, "filter:a", arg, options);
1700 }
1701
1702 static int opt_vsync(const char *opt, const char *arg)
1703 {
1704     if      (!av_strcasecmp(arg, "cfr"))         video_sync_method = VSYNC_CFR;
1705     else if (!av_strcasecmp(arg, "vfr"))         video_sync_method = VSYNC_VFR;
1706     else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
1707
1708     if (video_sync_method == VSYNC_AUTO)
1709         video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
1710     return 0;
1711 }
1712
1713 static int opt_deinterlace(const char *opt, const char *arg)
1714 {
1715     av_log(NULL, AV_LOG_WARNING, "-%s is deprecated, use -filter:v yadif instead\n", opt);
1716     do_deinterlace = 1;
1717     return 0;
1718 }
1719
1720 int opt_cpuflags(const char *opt, const char *arg)
1721 {
1722     int flags = av_parse_cpu_flags(arg);
1723
1724     if (flags < 0)
1725         return flags;
1726
1727     av_set_cpu_flags_mask(flags);
1728     return 0;
1729 }
1730
1731 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
1732 {
1733     OptionsContext *o = optctx;
1734     char layout_str[32];
1735     char *stream_str;
1736     char *ac_str;
1737     int ret, channels, ac_str_size;
1738     uint64_t layout;
1739
1740     layout = av_get_channel_layout(arg);
1741     if (!layout) {
1742         av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
1743         return AVERROR(EINVAL);
1744     }
1745     snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
1746     ret = opt_default(opt, layout_str);
1747     if (ret < 0)
1748         return ret;
1749
1750     /* set 'ac' option based on channel layout */
1751     channels = av_get_channel_layout_nb_channels(layout);
1752     snprintf(layout_str, sizeof(layout_str), "%d", channels);
1753     stream_str = strchr(opt, ':');
1754     ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
1755     ac_str = av_mallocz(ac_str_size);
1756     if (!ac_str)
1757         return AVERROR(ENOMEM);
1758     av_strlcpy(ac_str, "ac", 3);
1759     if (stream_str)
1760         av_strlcat(ac_str, stream_str, ac_str_size);
1761     ret = parse_option(o, ac_str, layout_str, options);
1762     av_free(ac_str);
1763
1764     return ret;
1765 }
1766
1767 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
1768 {
1769     OptionsContext *o = optctx;
1770     return parse_option(o, "q:a", arg, options);
1771 }
1772
1773 static int opt_filter_complex(const char *opt, const char *arg)
1774 {
1775     filtergraphs = grow_array(filtergraphs, sizeof(*filtergraphs),
1776                               &nb_filtergraphs, nb_filtergraphs + 1);
1777     if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
1778         return AVERROR(ENOMEM);
1779     filtergraphs[nb_filtergraphs - 1]->index       = nb_filtergraphs - 1;
1780     filtergraphs[nb_filtergraphs - 1]->graph_desc = arg;
1781     return 0;
1782 }
1783
1784 void show_help_default(const char *opt, const char *arg)
1785 {
1786     /* per-file options have at least one of those set */
1787     const int per_file = OPT_SPEC | OPT_OFFSET | OPT_FUNC2;
1788     int show_advanced = 0, show_avoptions = 0;
1789
1790     if (opt) {
1791         if (!strcmp(opt, "long"))
1792             show_advanced = 1;
1793         else if (!strcmp(opt, "full"))
1794             show_advanced = show_avoptions = 1;
1795         else
1796             av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
1797     }
1798
1799     show_usage();
1800
1801     printf("Getting help:\n"
1802            "    -h      -- print basic options\n"
1803            "    -h long -- print more options\n"
1804            "    -h full -- print all options (including all format and codec specific options, very long)\n"
1805            "    See man %s for detailed description of the options.\n"
1806            "\n", program_name);
1807
1808     show_help_options(options, "Print help / information / capabilities:",
1809                       OPT_EXIT, 0, 0);
1810
1811     show_help_options(options, "Global options (affect whole program "
1812                       "instead of just one file:",
1813                       0, per_file | OPT_EXIT | OPT_EXPERT, 0);
1814     if (show_advanced)
1815         show_help_options(options, "Advanced global options:", OPT_EXPERT,
1816                           per_file | OPT_EXIT, 0);
1817
1818     show_help_options(options, "Per-file main options:", 0,
1819                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
1820                       OPT_EXIT, per_file);
1821     if (show_advanced)
1822         show_help_options(options, "Advanced per-file options:",
1823                           OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
1824
1825     show_help_options(options, "Video options:",
1826                       OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
1827     if (show_advanced)
1828         show_help_options(options, "Advanced Video options:",
1829                           OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
1830
1831     show_help_options(options, "Audio options:",
1832                       OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
1833     if (show_advanced)
1834         show_help_options(options, "Advanced Audio options:",
1835                           OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
1836     show_help_options(options, "Subtitle options:",
1837                       OPT_SUBTITLE, 0, 0);
1838     printf("\n");
1839
1840     if (show_avoptions) {
1841         int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
1842         show_help_children(avcodec_get_class(), flags);
1843         show_help_children(avformat_get_class(), flags);
1844         show_help_children(sws_get_class(), flags);
1845     }
1846 }
1847
1848 void show_usage(void)
1849 {
1850     printf("Hyper fast Audio and Video encoder\n");
1851     printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
1852     printf("\n");
1853 }
1854
1855
1856 #define OFFSET(x) offsetof(OptionsContext, x)
1857 const OptionDef options[] = {
1858     /* main options */
1859 #include "cmdutils_common_opts.h"
1860     { "f",              HAS_ARG | OPT_STRING | OPT_OFFSET,           { .off       = OFFSET(format) },
1861         "force format", "fmt" },
1862     { "i",              HAS_ARG | OPT_FUNC2,                         { .func2_arg = opt_input_file },
1863         "input file name", "filename" },
1864     { "y",              OPT_BOOL,                                    {              &file_overwrite },
1865         "overwrite output files" },
1866     { "c",              HAS_ARG | OPT_STRING | OPT_SPEC,             { .off       = OFFSET(codec_names) },
1867         "codec name", "codec" },
1868     { "codec",          HAS_ARG | OPT_STRING | OPT_SPEC,             { .off       = OFFSET(codec_names) },
1869         "codec name", "codec" },
1870     { "pre",            HAS_ARG | OPT_STRING | OPT_SPEC,             { .off       = OFFSET(presets) },
1871         "preset name", "preset" },
1872     { "map",            HAS_ARG | OPT_EXPERT | OPT_FUNC2,            { .func2_arg = opt_map },
1873         "set input stream mapping",
1874         "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
1875     { "map_metadata",   HAS_ARG | OPT_STRING | OPT_SPEC,             { .off       = OFFSET(metadata_map) },
1876         "set metadata information of outfile from infile",
1877         "outfile[,metadata]:infile[,metadata]" },
1878     { "map_chapters",   HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(chapters_input_file) },
1879         "set chapters mapping", "input_file_index" },
1880     { "t",              HAS_ARG | OPT_TIME | OPT_OFFSET,             { .off = OFFSET(recording_time) },
1881         "record or transcode \"duration\" seconds of audio/video",
1882         "duration" },
1883     { "fs",             HAS_ARG | OPT_INT64 | OPT_OFFSET,            { .off = OFFSET(limit_filesize) },
1884         "set the limit file size in bytes", "limit_size" },
1885     { "ss",             HAS_ARG | OPT_TIME | OPT_OFFSET,             { .off = OFFSET(start_time) },
1886         "set the start time offset", "time_off" },
1887     { "itsoffset",      HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_EXPERT,{ .off = OFFSET(input_ts_offset) },
1888         "set the input ts offset", "time_off" },
1889     { "itsscale",       HAS_ARG | OPT_DOUBLE | OPT_SPEC | OPT_EXPERT,{ .off = OFFSET(ts_scale) },
1890         "set the input ts scale", "scale" },
1891     { "metadata",       HAS_ARG | OPT_STRING | OPT_SPEC,             { .off = OFFSET(metadata) },
1892         "add metadata", "string=string" },
1893     { "dframes",        HAS_ARG | OPT_FUNC2 | OPT_EXPERT,            { .func2_arg = opt_data_frames },
1894         "set the number of data frames to record", "number" },
1895     { "benchmark",      OPT_BOOL | OPT_EXPERT,                       { &do_benchmark },
1896         "add timings for benchmarking" },
1897     { "timelimit",      HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_timelimit },
1898         "set max runtime in seconds", "limit" },
1899     { "dump",           OPT_BOOL | OPT_EXPERT,                       { &do_pkt_dump },
1900         "dump each input packet" },
1901     { "hex",            OPT_BOOL | OPT_EXPERT,                       { &do_hex_dump },
1902         "when dumping packets, also dump the payload" },
1903     { "re",             OPT_BOOL | OPT_EXPERT | OPT_OFFSET,          { .off = OFFSET(rate_emu) },
1904         "read input at native frame rate", "" },
1905     { "target",         HAS_ARG | OPT_FUNC2,                         { .func2_arg = opt_target },
1906         "specify target file type (\"vcd\", \"svcd\", \"dvd\","
1907         " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
1908     { "vsync",          HAS_ARG | OPT_EXPERT,                        { opt_vsync },
1909         "video sync method", "" },
1910     { "async",          HAS_ARG | OPT_INT | OPT_EXPERT,              { &audio_sync_method },
1911         "audio sync method", "" },
1912     { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,          { &audio_drift_threshold },
1913         "audio drift threshold", "threshold" },
1914     { "copyts",         OPT_BOOL | OPT_EXPERT,                       { &copy_ts },
1915         "copy timestamps" },
1916     { "copytb",         OPT_BOOL | OPT_EXPERT,                       { &copy_tb },
1917         "copy input stream time base when stream copying" },
1918     { "shortest",       OPT_BOOL | OPT_EXPERT | OPT_OFFSET,          { .off = OFFSET(shortest) },
1919         "finish encoding within shortest input" },
1920     { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,       { &dts_delta_threshold },
1921         "timestamp discontinuity delta threshold", "threshold" },
1922     { "xerror",         OPT_BOOL | OPT_EXPERT,                       { &exit_on_error },
1923         "exit on error", "error" },
1924     { "copyinkf",       OPT_BOOL | OPT_EXPERT | OPT_SPEC,            { .off = OFFSET(copy_initial_nonkeyframes) },
1925         "copy initial non-keyframes" },
1926     { "frames",         OPT_INT64 | HAS_ARG | OPT_SPEC,              { .off = OFFSET(max_frames) },
1927         "set the number of frames to record", "number" },
1928     { "tag",            OPT_STRING | HAS_ARG | OPT_SPEC | OPT_EXPERT,{ .off = OFFSET(codec_tags) },
1929         "force codec tag/fourcc", "fourcc/tag" },
1930     { "q",              HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC,{ .off = OFFSET(qscale) },
1931         "use fixed quality scale (VBR)", "q" },
1932     { "qscale",         HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC,{ .off = OFFSET(qscale) },
1933         "use fixed quality scale (VBR)", "q" },
1934     { "filter",         HAS_ARG | OPT_STRING | OPT_SPEC,             { .off = OFFSET(filters) },
1935         "set stream filterchain", "filter_list" },
1936     { "filter_complex", HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_filter_complex },
1937         "create a complex filtergraph", "graph_description" },
1938     { "stats",          OPT_BOOL,                                    { &print_stats },
1939         "print progress report during encoding", },
1940     { "attach",         HAS_ARG | OPT_FUNC2 | OPT_EXPERT,            { .func2_arg = opt_attach },
1941         "add an attachment to the output file", "filename" },
1942     { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |OPT_EXPERT,{ .off = OFFSET(dump_attachment) },
1943         "extract an attachment into a file", "filename" },
1944     { "cpuflags",       HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_cpuflags },
1945         "set CPU flags mask", "mask" },
1946
1947     /* video options */
1948     { "vframes",      OPT_VIDEO | HAS_ARG  | OPT_FUNC2,                          { .func2_arg = opt_video_frames },
1949         "set the number of video frames to record", "number" },
1950     { "r",            OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC,              { .off = OFFSET(frame_rates) },
1951         "set frame rate (Hz value, fraction or abbreviation)", "rate" },
1952     { "s",            OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC,              { .off = OFFSET(frame_sizes) },
1953         "set frame size (WxH or abbreviation)", "size" },
1954     { "aspect",       OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC,              { .off = OFFSET(frame_aspect_ratios) },
1955         "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
1956     { "pix_fmt",      OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC, { .off = OFFSET(frame_pix_fmts) },
1957         "set pixel format", "format" },
1958     { "vn",           OPT_VIDEO | OPT_BOOL  | OPT_OFFSET,                        { .off = OFFSET(video_disable) },
1959         "disable video" },
1960     { "vdt",          OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT ,               { &video_discard },
1961         "discard threshold", "n" },
1962     { "rc_override",  OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC, { .off = OFFSET(rc_overrides) },
1963         "rate control override for specific intervals", "override" },
1964     { "vcodec",       OPT_VIDEO | HAS_ARG  | OPT_FUNC2,                          { .func2_arg = opt_video_codec },
1965         "force video codec ('copy' to copy stream)", "codec" },
1966     { "same_quant",   OPT_VIDEO | OPT_BOOL | OPT_EXPERT,                         { &same_quant },
1967         "use same quantizer as source (implies VBR)" },
1968     { "pass",         OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT,                  { .off = OFFSET(pass) },
1969         "select the pass number (1 or 2)", "n" },
1970     { "passlogfile",  OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT,             { &pass_logfilename_prefix },
1971         "select two pass log file name prefix", "prefix" },
1972     { "deinterlace",  OPT_VIDEO | OPT_EXPERT ,                                   { .func_arg = opt_deinterlace },
1973         "this option is deprecated, use the yadif filter instead" },
1974     { "vstats",       OPT_VIDEO | OPT_EXPERT ,                                   { &opt_vstats },
1975         "dump video coding statistics to file" },
1976     { "vstats_file",  OPT_VIDEO | HAS_ARG | OPT_EXPERT ,                         { opt_vstats_file },
1977         "dump video coding statistics to file", "file" },
1978     { "vf",           OPT_VIDEO | HAS_ARG  | OPT_FUNC2,                          { .func2_arg = opt_video_filters },
1979         "video filters", "filter list" },
1980     { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC, { .off = OFFSET(intra_matrices) },
1981         "specify intra matrix coeffs", "matrix" },
1982     { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC, { .off = OFFSET(inter_matrices) },
1983         "specify inter matrix coeffs", "matrix" },
1984     { "top",          OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_INT| OPT_SPEC,     { .off = OFFSET(top_field_first) },
1985         "top=1/bottom=0/auto=-1 field first", "" },
1986     { "dc",           OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT ,               { &intra_dc_precision },
1987         "intra_dc_precision", "precision" },
1988     { "vtag",         OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_FUNC2,             { .func2_arg = opt_video_tag },
1989         "force video tag/fourcc", "fourcc/tag" },
1990     { "qphist",       OPT_VIDEO | OPT_BOOL | OPT_EXPERT ,                        { &qp_hist },
1991         "show QP histogram" },
1992     { "force_fps",    OPT_VIDEO | OPT_BOOL | OPT_EXPERT  | OPT_SPEC,             { .off = OFFSET(force_fps) },
1993         "force the selected framerate, disable the best supported framerate selection" },
1994     { "streamid",     OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_FUNC2,              { .func2_arg = opt_streamid },
1995         "set the value of an outfile streamid", "streamIndex:value" },
1996     { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT  | OPT_SPEC,
1997         { .off = OFFSET(forced_key_frames) }, "force key frames at specified timestamps", "timestamps" },
1998
1999     /* audio options */
2000     { "aframes",        OPT_AUDIO | HAS_ARG  | OPT_FUNC2,                          { .func2_arg = opt_audio_frames },
2001         "set the number of audio frames to record", "number" },
2002     { "aq",             OPT_AUDIO | HAS_ARG  | OPT_FUNC2,                          { .func2_arg = opt_audio_qscale },
2003         "set audio quality (codec-specific)", "quality", },
2004     { "ar",             OPT_AUDIO | HAS_ARG  | OPT_INT | OPT_SPEC,                 { .off = OFFSET(audio_sample_rate) },
2005         "set audio sampling rate (in Hz)", "rate" },
2006     { "ac",             OPT_AUDIO | HAS_ARG  | OPT_INT | OPT_SPEC,                 { .off = OFFSET(audio_channels) },
2007         "set number of audio channels", "channels" },
2008     { "an",             OPT_AUDIO | OPT_BOOL | OPT_OFFSET,                         { .off = OFFSET(audio_disable) },
2009         "disable audio" },
2010     { "acodec",         OPT_AUDIO | HAS_ARG  | OPT_FUNC2,                          { .func2_arg = opt_audio_codec },
2011         "force audio codec ('copy' to copy stream)", "codec" },
2012     { "atag",           OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_FUNC2,             { .func2_arg = opt_audio_tag },
2013         "force audio tag/fourcc", "fourcc/tag" },
2014     { "vol",            OPT_AUDIO | HAS_ARG  | OPT_INT,                            { &audio_volume },
2015         "change audio volume (256=normal)" , "volume" },
2016     { "sample_fmt",     OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_SPEC | OPT_STRING, { .off = OFFSET(sample_fmts) },
2017         "set sample format", "format" },
2018     { "channel_layout", OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_FUNC2,             { .func2_arg = opt_channel_layout },
2019         "set channel layout", "layout" },
2020     { "af",             OPT_AUDIO | HAS_ARG  | OPT_FUNC2,                          { .func2_arg = opt_audio_filters },
2021         "audio filters", "filter list" },
2022
2023     /* subtitle options */
2024     { "sn",     OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET, { .off = OFFSET(subtitle_disable) },
2025         "disable subtitle" },
2026     { "scodec", OPT_SUBTITLE | HAS_ARG  | OPT_FUNC2,  { .func2_arg = opt_subtitle_codec },
2027         "force subtitle codec ('copy' to copy stream)", "codec" },
2028     { "stag",   OPT_SUBTITLE | HAS_ARG  | OPT_EXPERT  | OPT_FUNC2, { .func2_arg = opt_subtitle_tag }
2029         , "force subtitle tag/fourcc", "fourcc/tag" },
2030
2031     /* grab options */
2032     { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
2033
2034     /* muxer options */
2035     { "muxdelay",   OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(mux_max_delay) },
2036         "set the maximum demux-decode delay", "seconds" },
2037     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(mux_preload) },
2038         "set the initial demux-decode delay", "seconds" },
2039
2040     { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT, { .off = OFFSET(bitstream_filters) },
2041         "A comma-separated list of bitstream filters", "bitstream_filters" },
2042
2043     /* data codec support */
2044     { "dcodec", HAS_ARG | OPT_DATA | OPT_FUNC2 | OPT_EXPERT, { .func2_arg = opt_data_codec },
2045         "force data codec ('copy' to copy stream)", "codec" },
2046
2047     { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, { .func_arg = opt_default },
2048         "generic catch all option", "" },
2049     { NULL, },
2050 };