cmdutils: change semantics of show_help_options() and document it.
[ffmpeg.git] / avconv_opt.c
1 /*
2  * avconv option parsing
3  *
4  * This file is part of Libav.
5  *
6  * Libav is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * Libav is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with Libav; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20
21 #include <stdint.h>
22
23 #include "avconv.h"
24 #include "cmdutils.h"
25
26 #include "libavformat/avformat.h"
27
28 #include "libavcodec/avcodec.h"
29
30 #include "libavfilter/avfilter.h"
31 #include "libavfilter/avfiltergraph.h"
32
33 #include "libavutil/audioconvert.h"
34 #include "libavutil/avassert.h"
35 #include "libavutil/avstring.h"
36 #include "libavutil/avutil.h"
37 #include "libavutil/intreadwrite.h"
38 #include "libavutil/fifo.h"
39 #include "libavutil/mathematics.h"
40 #include "libavutil/opt.h"
41 #include "libavutil/parseutils.h"
42 #include "libavutil/pixdesc.h"
43 #include "libavutil/pixfmt.h"
44
45 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
46 {\
47     int i, ret;\
48     for (i = 0; i < o->nb_ ## name; i++) {\
49         char *spec = o->name[i].specifier;\
50         if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
51             outvar = o->name[i].u.type;\
52         else if (ret < 0)\
53             exit_program(1);\
54     }\
55 }
56
57 char *pass_logfilename_prefix = NULL;
58 char *vstats_filename;
59
60 float audio_drift_threshold = 0.1;
61 float dts_delta_threshold   = 10;
62
63 int audio_volume      = 256;
64 int audio_sync_method = 0;
65 int video_sync_method = VSYNC_AUTO;
66 int do_deinterlace    = 0;
67 int do_benchmark      = 0;
68 int do_hex_dump       = 0;
69 int do_pkt_dump       = 0;
70 int copy_ts           = 0;
71 int copy_tb           = 1;
72 int opt_shortest      = 0;
73 int exit_on_error     = 0;
74 int print_stats       = 1;
75 int qp_hist           = 0;
76 int same_quant        = 0;
77
78 static int file_overwrite     = 0;
79 static int video_discard      = 0;
80 static int intra_dc_precision = 8;
81 static int do_pass            = 0;
82 static int using_stdin        = 0;
83 static int input_sync;
84
85 void reset_options(OptionsContext *o)
86 {
87     const OptionDef *po = options;
88     int i;
89
90     /* all OPT_SPEC and OPT_STRING can be freed in generic way */
91     while (po->name) {
92         void *dst = (uint8_t*)o + po->u.off;
93
94         if (po->flags & OPT_SPEC) {
95             SpecifierOpt **so = dst;
96             int i, *count = (int*)(so + 1);
97             for (i = 0; i < *count; i++) {
98                 av_freep(&(*so)[i].specifier);
99                 if (po->flags & OPT_STRING)
100                     av_freep(&(*so)[i].u.str);
101             }
102             av_freep(so);
103             *count = 0;
104         } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
105             av_freep(dst);
106         po++;
107     }
108
109     for (i = 0; i < o->nb_stream_maps; i++)
110         av_freep(&o->stream_maps[i].linklabel);
111     av_freep(&o->stream_maps);
112     av_freep(&o->meta_data_maps);
113     av_freep(&o->streamid_map);
114
115     memset(o, 0, sizeof(*o));
116
117     o->mux_max_delay  = 0.7;
118     o->recording_time = INT64_MAX;
119     o->limit_filesize = UINT64_MAX;
120     o->chapters_input_file = INT_MAX;
121
122     uninit_opts();
123     init_opts();
124 }
125
126
127 static double parse_frame_aspect_ratio(const char *arg)
128 {
129     int x = 0, y = 0;
130     double ar = 0;
131     const char *p;
132     char *end;
133
134     p = strchr(arg, ':');
135     if (p) {
136         x = strtol(arg, &end, 10);
137         if (end == p)
138             y = strtol(end + 1, &end, 10);
139         if (x > 0 && y > 0)
140             ar = (double)x / (double)y;
141     } else
142         ar = strtod(arg, NULL);
143
144     if (!ar) {
145         av_log(NULL, AV_LOG_FATAL, "Incorrect aspect ratio specification.\n");
146         exit_program(1);
147     }
148     return ar;
149 }
150
151 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
152 {
153     OptionsContext *o = optctx;
154     return parse_option(o, "codec:a", arg, options);
155 }
156
157 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
158 {
159     OptionsContext *o = optctx;
160     return parse_option(o, "codec:v", arg, options);
161 }
162
163 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
164 {
165     OptionsContext *o = optctx;
166     return parse_option(o, "codec:s", arg, options);
167 }
168
169 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
170 {
171     OptionsContext *o = optctx;
172     return parse_option(o, "codec:d", arg, options);
173 }
174
175 static int opt_map(void *optctx, const char *opt, const char *arg)
176 {
177     OptionsContext *o = optctx;
178     StreamMap *m = NULL;
179     int i, negative = 0, file_idx;
180     int sync_file_idx = -1, sync_stream_idx;
181     char *p, *sync;
182     char *map;
183
184     if (*arg == '-') {
185         negative = 1;
186         arg++;
187     }
188     map = av_strdup(arg);
189
190     /* parse sync stream first, just pick first matching stream */
191     if (sync = strchr(map, ',')) {
192         *sync = 0;
193         sync_file_idx = strtol(sync + 1, &sync, 0);
194         if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
195             av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
196             exit_program(1);
197         }
198         if (*sync)
199             sync++;
200         for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
201             if (check_stream_specifier(input_files[sync_file_idx]->ctx,
202                                        input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
203                 sync_stream_idx = i;
204                 break;
205             }
206         if (i == input_files[sync_file_idx]->nb_streams) {
207             av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
208                                        "match any streams.\n", arg);
209             exit_program(1);
210         }
211     }
212
213
214     if (map[0] == '[') {
215         /* this mapping refers to lavfi output */
216         const char *c = map + 1;
217         o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
218                                     &o->nb_stream_maps, o->nb_stream_maps + 1);
219         m = &o->stream_maps[o->nb_stream_maps - 1];
220         m->linklabel = av_get_token(&c, "]");
221         if (!m->linklabel) {
222             av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
223             exit_program(1);
224         }
225     } else {
226         file_idx = strtol(map, &p, 0);
227         if (file_idx >= nb_input_files || file_idx < 0) {
228             av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
229             exit_program(1);
230         }
231         if (negative)
232             /* disable some already defined maps */
233             for (i = 0; i < o->nb_stream_maps; i++) {
234                 m = &o->stream_maps[i];
235                 if (file_idx == m->file_index &&
236                     check_stream_specifier(input_files[m->file_index]->ctx,
237                                            input_files[m->file_index]->ctx->streams[m->stream_index],
238                                            *p == ':' ? p + 1 : p) > 0)
239                     m->disabled = 1;
240             }
241         else
242             for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
243                 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
244                             *p == ':' ? p + 1 : p) <= 0)
245                     continue;
246                 o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
247                                             &o->nb_stream_maps, o->nb_stream_maps + 1);
248                 m = &o->stream_maps[o->nb_stream_maps - 1];
249
250                 m->file_index   = file_idx;
251                 m->stream_index = i;
252
253                 if (sync_file_idx >= 0) {
254                     m->sync_file_index   = sync_file_idx;
255                     m->sync_stream_index = sync_stream_idx;
256                 } else {
257                     m->sync_file_index   = file_idx;
258                     m->sync_stream_index = i;
259                 }
260             }
261     }
262
263     if (!m) {
264         av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
265         exit_program(1);
266     }
267
268     av_freep(&map);
269     return 0;
270 }
271
272 static int opt_attach(void *optctx, const char *opt, const char *arg)
273 {
274     OptionsContext *o = optctx;
275     o->attachments = grow_array(o->attachments, sizeof(*o->attachments),
276                                 &o->nb_attachments, o->nb_attachments + 1);
277     o->attachments[o->nb_attachments - 1] = arg;
278     return 0;
279 }
280
281 /**
282  * Parse a metadata specifier in arg.
283  * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
284  * @param index for type c/p, chapter/program index is written here
285  * @param stream_spec for type s, the stream specifier is written here
286  */
287 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
288 {
289     if (*arg) {
290         *type = *arg;
291         switch (*arg) {
292         case 'g':
293             break;
294         case 's':
295             if (*(++arg) && *arg != ':') {
296                 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
297                 exit_program(1);
298             }
299             *stream_spec = *arg == ':' ? arg + 1 : "";
300             break;
301         case 'c':
302         case 'p':
303             if (*(++arg) == ':')
304                 *index = strtol(++arg, NULL, 0);
305             break;
306         default:
307             av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
308             exit_program(1);
309         }
310     } else
311         *type = 'g';
312 }
313
314 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
315 {
316     AVDictionary **meta_in = NULL;
317     AVDictionary **meta_out;
318     int i, ret = 0;
319     char type_in, type_out;
320     const char *istream_spec = NULL, *ostream_spec = NULL;
321     int idx_in = 0, idx_out = 0;
322
323     parse_meta_type(inspec,  &type_in,  &idx_in,  &istream_spec);
324     parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
325
326     if (type_in == 'g' || type_out == 'g')
327         o->metadata_global_manual = 1;
328     if (type_in == 's' || type_out == 's')
329         o->metadata_streams_manual = 1;
330     if (type_in == 'c' || type_out == 'c')
331         o->metadata_chapters_manual = 1;
332
333 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
334     if ((index) < 0 || (index) >= (nb_elems)) {\
335         av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
336                 (desc), (index));\
337         exit_program(1);\
338     }
339
340 #define SET_DICT(type, meta, context, index)\
341         switch (type) {\
342         case 'g':\
343             meta = &context->metadata;\
344             break;\
345         case 'c':\
346             METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
347             meta = &context->chapters[index]->metadata;\
348             break;\
349         case 'p':\
350             METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
351             meta = &context->programs[index]->metadata;\
352             break;\
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_program(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_program(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_program(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_program(1);
409     }
410     if (codec->type != type) {
411         av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
412         exit_program(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 /**
431  * Add all the streams from the given input file to the global
432  * list of input streams.
433  */
434 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
435 {
436     int i;
437
438     for (i = 0; i < ic->nb_streams; i++) {
439         AVStream *st = ic->streams[i];
440         AVCodecContext *dec = st->codec;
441         InputStream *ist = av_mallocz(sizeof(*ist));
442         char *framerate = NULL;
443
444         if (!ist)
445             exit_program(1);
446
447         input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
448         input_streams[nb_input_streams - 1] = ist;
449
450         ist->st = st;
451         ist->file_index = nb_input_files;
452         ist->discard = 1;
453         st->discard  = AVDISCARD_ALL;
454         ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, ic, st, NULL);
455
456         ist->ts_scale = 1.0;
457         MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
458
459         ist->dec = choose_decoder(o, ic, st);
460
461         switch (dec->codec_type) {
462         case AVMEDIA_TYPE_VIDEO:
463             ist->resample_height  = dec->height;
464             ist->resample_width   = dec->width;
465             ist->resample_pix_fmt = dec->pix_fmt;
466
467             MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
468             if (framerate && av_parse_video_rate(&ist->framerate,
469                                                  framerate) < 0) {
470                 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
471                        framerate);
472                 exit_program(1);
473             }
474
475             break;
476         case AVMEDIA_TYPE_AUDIO:
477             guess_input_channel_layout(ist);
478
479             ist->resample_sample_fmt     = dec->sample_fmt;
480             ist->resample_sample_rate    = dec->sample_rate;
481             ist->resample_channels       = dec->channels;
482             ist->resample_channel_layout = dec->channel_layout;
483
484             break;
485         case AVMEDIA_TYPE_DATA:
486         case AVMEDIA_TYPE_SUBTITLE:
487         case AVMEDIA_TYPE_ATTACHMENT:
488         case AVMEDIA_TYPE_UNKNOWN:
489             break;
490         default:
491             abort();
492         }
493     }
494 }
495
496 static void assert_file_overwrite(const char *filename)
497 {
498     if (!file_overwrite &&
499         (strchr(filename, ':') == NULL || filename[1] == ':' ||
500          av_strstart(filename, "file:", NULL))) {
501         if (avio_check(filename, 0) == 0) {
502             if (!using_stdin) {
503                 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
504                 fflush(stderr);
505                 if (!read_yesno()) {
506                     fprintf(stderr, "Not overwriting - exiting\n");
507                     exit_program(1);
508                 }
509             }
510             else {
511                 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
512                 exit_program(1);
513             }
514         }
515     }
516 }
517
518 static void dump_attachment(AVStream *st, const char *filename)
519 {
520     int ret;
521     AVIOContext *out = NULL;
522     AVDictionaryEntry *e;
523
524     if (!st->codec->extradata_size) {
525         av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
526                nb_input_files - 1, st->index);
527         return;
528     }
529     if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
530         filename = e->value;
531     if (!*filename) {
532         av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
533                "in stream #%d:%d.\n", nb_input_files - 1, st->index);
534         exit_program(1);
535     }
536
537     assert_file_overwrite(filename);
538
539     if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
540         av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
541                filename);
542         exit_program(1);
543     }
544
545     avio_write(out, st->codec->extradata, st->codec->extradata_size);
546     avio_flush(out);
547     avio_close(out);
548 }
549
550 static int opt_input_file(void *optctx, const char *opt, const char *filename)
551 {
552     OptionsContext *o = optctx;
553     AVFormatContext *ic;
554     AVInputFormat *file_iformat = NULL;
555     int err, i, ret;
556     int64_t timestamp;
557     uint8_t buf[128];
558     AVDictionary **opts;
559     int orig_nb_streams;                     // number of streams before avformat_find_stream_info
560
561     if (o->format) {
562         if (!(file_iformat = av_find_input_format(o->format))) {
563             av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
564             exit_program(1);
565         }
566     }
567
568     if (!strcmp(filename, "-"))
569         filename = "pipe:";
570
571     using_stdin |= !strncmp(filename, "pipe:", 5) ||
572                     !strcmp(filename, "/dev/stdin");
573
574     /* get default parameters from command line */
575     ic = avformat_alloc_context();
576     if (!ic) {
577         print_error(filename, AVERROR(ENOMEM));
578         exit_program(1);
579     }
580     if (o->nb_audio_sample_rate) {
581         snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
582         av_dict_set(&format_opts, "sample_rate", buf, 0);
583     }
584     if (o->nb_audio_channels) {
585         /* because we set audio_channels based on both the "ac" and
586          * "channel_layout" options, we need to check that the specified
587          * demuxer actually has the "channels" option before setting it */
588         if (file_iformat && file_iformat->priv_class &&
589             av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
590                         AV_OPT_SEARCH_FAKE_OBJ)) {
591             snprintf(buf, sizeof(buf), "%d",
592                      o->audio_channels[o->nb_audio_channels - 1].u.i);
593             av_dict_set(&format_opts, "channels", buf, 0);
594         }
595     }
596     if (o->nb_frame_rates) {
597         /* set the format-level framerate option;
598          * this is important for video grabbers, e.g. x11 */
599         if (file_iformat && file_iformat->priv_class &&
600             av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
601                         AV_OPT_SEARCH_FAKE_OBJ)) {
602             av_dict_set(&format_opts, "framerate",
603                         o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
604         }
605     }
606     if (o->nb_frame_sizes) {
607         av_dict_set(&format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
608     }
609     if (o->nb_frame_pix_fmts)
610         av_dict_set(&format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
611
612     ic->flags |= AVFMT_FLAG_NONBLOCK;
613     ic->interrupt_callback = int_cb;
614
615     /* open the input file with generic libav function */
616     err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
617     if (err < 0) {
618         print_error(filename, err);
619         exit_program(1);
620     }
621     assert_avoptions(format_opts);
622
623     /* apply forced codec ids */
624     for (i = 0; i < ic->nb_streams; i++)
625         choose_decoder(o, ic, ic->streams[i]);
626
627     /* Set AVCodecContext options for avformat_find_stream_info */
628     opts = setup_find_stream_info_opts(ic, codec_opts);
629     orig_nb_streams = ic->nb_streams;
630
631     /* If not enough info to get the stream parameters, we decode the
632        first frames to get it. (used in mpeg case for example) */
633     ret = avformat_find_stream_info(ic, opts);
634     if (ret < 0) {
635         av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
636         avformat_close_input(&ic);
637         exit_program(1);
638     }
639
640     timestamp = o->start_time;
641     /* add the stream start time */
642     if (ic->start_time != AV_NOPTS_VALUE)
643         timestamp += ic->start_time;
644
645     /* if seeking requested, we execute it */
646     if (o->start_time != 0) {
647         ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
648         if (ret < 0) {
649             av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
650                    filename, (double)timestamp / AV_TIME_BASE);
651         }
652     }
653
654     /* update the current parameters so that they match the one of the input stream */
655     add_input_streams(o, ic);
656
657     /* dump the file content */
658     av_dump_format(ic, nb_input_files, filename, 0);
659
660     input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
661     if (!(input_files[nb_input_files - 1] = av_mallocz(sizeof(*input_files[0]))))
662         exit_program(1);
663
664     input_files[nb_input_files - 1]->ctx        = ic;
665     input_files[nb_input_files - 1]->ist_index  = nb_input_streams - ic->nb_streams;
666     input_files[nb_input_files - 1]->ts_offset  = o->input_ts_offset - (copy_ts ? 0 : timestamp);
667     input_files[nb_input_files - 1]->nb_streams = ic->nb_streams;
668     input_files[nb_input_files - 1]->rate_emu   = o->rate_emu;
669
670     for (i = 0; i < o->nb_dump_attachment; i++) {
671         int j;
672
673         for (j = 0; j < ic->nb_streams; j++) {
674             AVStream *st = ic->streams[j];
675
676             if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
677                 dump_attachment(st, o->dump_attachment[i].u.str);
678         }
679     }
680
681     for (i = 0; i < orig_nb_streams; i++)
682         av_dict_free(&opts[i]);
683     av_freep(&opts);
684
685     reset_options(o);
686     return 0;
687 }
688
689 static uint8_t *get_line(AVIOContext *s)
690 {
691     AVIOContext *line;
692     uint8_t *buf;
693     char c;
694
695     if (avio_open_dyn_buf(&line) < 0) {
696         av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
697         exit_program(1);
698     }
699
700     while ((c = avio_r8(s)) && c != '\n')
701         avio_w8(line, c);
702     avio_w8(line, 0);
703     avio_close_dyn_buf(line, &buf);
704
705     return buf;
706 }
707
708 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
709 {
710     int i, ret = 1;
711     char filename[1000];
712     const char *base[3] = { getenv("AVCONV_DATADIR"),
713                             getenv("HOME"),
714                             AVCONV_DATADIR,
715                             };
716
717     for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
718         if (!base[i])
719             continue;
720         if (codec_name) {
721             snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
722                      i != 1 ? "" : "/.avconv", codec_name, preset_name);
723             ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
724         }
725         if (ret) {
726             snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
727                      i != 1 ? "" : "/.avconv", preset_name);
728             ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
729         }
730     }
731     return ret;
732 }
733
734 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
735 {
736     char *codec_name = NULL;
737
738     MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
739     if (!codec_name) {
740         ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
741                                                   NULL, ost->st->codec->codec_type);
742         ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
743     } else if (!strcmp(codec_name, "copy"))
744         ost->stream_copy = 1;
745     else {
746         ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
747         ost->st->codec->codec_id = ost->enc->id;
748     }
749 }
750
751 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type)
752 {
753     OutputStream *ost;
754     AVStream *st = avformat_new_stream(oc, NULL);
755     int idx      = oc->nb_streams - 1, ret = 0;
756     char *bsf = NULL, *next, *codec_tag = NULL;
757     AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
758     double qscale = -1;
759     char *buf = NULL, *arg = NULL, *preset = NULL;
760     AVIOContext *s = NULL;
761
762     if (!st) {
763         av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
764         exit_program(1);
765     }
766
767     if (oc->nb_streams - 1 < o->nb_streamid_map)
768         st->id = o->streamid_map[oc->nb_streams - 1];
769
770     output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
771                                 nb_output_streams + 1);
772     if (!(ost = av_mallocz(sizeof(*ost))))
773         exit_program(1);
774     output_streams[nb_output_streams - 1] = ost;
775
776     ost->file_index = nb_output_files;
777     ost->index      = idx;
778     ost->st         = st;
779     st->codec->codec_type = type;
780     choose_encoder(o, oc, ost);
781     if (ost->enc) {
782         ost->opts  = filter_codec_opts(codec_opts, ost->enc->id, oc, st, ost->enc);
783     }
784
785     avcodec_get_context_defaults3(st->codec, ost->enc);
786     st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
787
788     MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
789     if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
790         do  {
791             buf = get_line(s);
792             if (!buf[0] || buf[0] == '#') {
793                 av_free(buf);
794                 continue;
795             }
796             if (!(arg = strchr(buf, '='))) {
797                 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
798                 exit_program(1);
799             }
800             *arg++ = 0;
801             av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
802             av_free(buf);
803         } while (!s->eof_reached);
804         avio_close(s);
805     }
806     if (ret) {
807         av_log(NULL, AV_LOG_FATAL,
808                "Preset %s specified for stream %d:%d, but could not be opened.\n",
809                preset, ost->file_index, ost->index);
810         exit_program(1);
811     }
812
813     ost->max_frames = INT64_MAX;
814     MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
815
816     MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
817     while (bsf) {
818         if (next = strchr(bsf, ','))
819             *next++ = 0;
820         if (!(bsfc = av_bitstream_filter_init(bsf))) {
821             av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
822             exit_program(1);
823         }
824         if (bsfc_prev)
825             bsfc_prev->next = bsfc;
826         else
827             ost->bitstream_filters = bsfc;
828
829         bsfc_prev = bsfc;
830         bsf       = next;
831     }
832
833     MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
834     if (codec_tag) {
835         uint32_t tag = strtol(codec_tag, &next, 0);
836         if (*next)
837             tag = AV_RL32(codec_tag);
838         st->codec->codec_tag = tag;
839     }
840
841     MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
842     if (qscale >= 0 || same_quant) {
843         st->codec->flags |= CODEC_FLAG_QSCALE;
844         st->codec->global_quality = FF_QP2LAMBDA * qscale;
845     }
846
847     if (oc->oformat->flags & AVFMT_GLOBALHEADER)
848         st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
849
850     av_opt_get_int(sws_opts, "sws_flags", 0, &ost->sws_flags);
851
852     ost->pix_fmts[0] = ost->pix_fmts[1] = PIX_FMT_NONE;
853
854     return ost;
855 }
856
857 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
858 {
859     int i;
860     const char *p = str;
861     for (i = 0;; i++) {
862         dest[i] = atoi(p);
863         if (i == 63)
864             break;
865         p = strchr(p, ',');
866         if (!p) {
867             av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
868             exit_program(1);
869         }
870         p++;
871     }
872 }
873
874 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc)
875 {
876     AVStream *st;
877     OutputStream *ost;
878     AVCodecContext *video_enc;
879
880     ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO);
881     st  = ost->st;
882     video_enc = st->codec;
883
884     if (!ost->stream_copy) {
885         const char *p = NULL;
886         char *frame_rate = NULL, *frame_size = NULL;
887         char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
888         char *intra_matrix = NULL, *inter_matrix = NULL;
889         const char *filters = "null";
890         int i;
891
892         MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
893         if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
894             av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
895             exit_program(1);
896         }
897
898         MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
899         if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
900             av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
901             exit_program(1);
902         }
903
904         MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
905         if (frame_aspect_ratio)
906             ost->frame_aspect_ratio = parse_frame_aspect_ratio(frame_aspect_ratio);
907
908         MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
909         if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == PIX_FMT_NONE) {
910             av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
911             exit_program(1);
912         }
913         st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
914
915         MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
916         if (intra_matrix) {
917             if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
918                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
919                 exit_program(1);
920             }
921             parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
922         }
923         MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
924         if (inter_matrix) {
925             if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
926                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
927                 exit_program(1);
928             }
929             parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
930         }
931
932         MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
933         for (i = 0; p; i++) {
934             int start, end, q;
935             int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
936             if (e != 3) {
937                 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
938                 exit_program(1);
939             }
940             video_enc->rc_override =
941                 av_realloc(video_enc->rc_override,
942                            sizeof(RcOverride) * (i + 1));
943             video_enc->rc_override[i].start_frame = start;
944             video_enc->rc_override[i].end_frame   = end;
945             if (q > 0) {
946                 video_enc->rc_override[i].qscale         = q;
947                 video_enc->rc_override[i].quality_factor = 1.0;
948             }
949             else {
950                 video_enc->rc_override[i].qscale         = 0;
951                 video_enc->rc_override[i].quality_factor = -q/100.0;
952             }
953             p = strchr(p, '/');
954             if (p) p++;
955         }
956         video_enc->rc_override_count = i;
957         if (!video_enc->rc_initial_buffer_occupancy)
958             video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size * 3 / 4;
959         video_enc->intra_dc_precision = intra_dc_precision - 8;
960
961         /* two pass mode */
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 /* same option as mencoder */
1500 static int opt_pass(const char *opt, const char *arg)
1501 {
1502     do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 2);
1503     return 0;
1504 }
1505
1506
1507 static int opt_target(void *optctx, const char *opt, const char *arg)
1508 {
1509     OptionsContext *o = optctx;
1510     enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
1511     static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
1512
1513     if (!strncmp(arg, "pal-", 4)) {
1514         norm = PAL;
1515         arg += 4;
1516     } else if (!strncmp(arg, "ntsc-", 5)) {
1517         norm = NTSC;
1518         arg += 5;
1519     } else if (!strncmp(arg, "film-", 5)) {
1520         norm = FILM;
1521         arg += 5;
1522     } else {
1523         /* Try to determine PAL/NTSC by peeking in the input files */
1524         if (nb_input_files) {
1525             int i, j, fr;
1526             for (j = 0; j < nb_input_files; j++) {
1527                 for (i = 0; i < input_files[j]->nb_streams; i++) {
1528                     AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
1529                     if (c->codec_type != AVMEDIA_TYPE_VIDEO)
1530                         continue;
1531                     fr = c->time_base.den * 1000 / c->time_base.num;
1532                     if (fr == 25000) {
1533                         norm = PAL;
1534                         break;
1535                     } else if ((fr == 29970) || (fr == 23976)) {
1536                         norm = NTSC;
1537                         break;
1538                     }
1539                 }
1540                 if (norm != UNKNOWN)
1541                     break;
1542             }
1543         }
1544         if (norm != UNKNOWN)
1545             av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
1546     }
1547
1548     if (norm == UNKNOWN) {
1549         av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
1550         av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
1551         av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
1552         exit_program(1);
1553     }
1554
1555     if (!strcmp(arg, "vcd")) {
1556         opt_video_codec(o, "c:v", "mpeg1video");
1557         opt_audio_codec(o, "c:a", "mp2");
1558         parse_option(o, "f", "vcd", options);
1559
1560         parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
1561         parse_option(o, "r", frame_rates[norm], options);
1562         opt_default("g", norm == PAL ? "15" : "18");
1563
1564         opt_default("b", "1150000");
1565         opt_default("maxrate", "1150000");
1566         opt_default("minrate", "1150000");
1567         opt_default("bufsize", "327680"); // 40*1024*8;
1568
1569         opt_default("b:a", "224000");
1570         parse_option(o, "ar", "44100", options);
1571         parse_option(o, "ac", "2", options);
1572
1573         opt_default("packetsize", "2324");
1574         opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
1575
1576         /* We have to offset the PTS, so that it is consistent with the SCR.
1577            SCR starts at 36000, but the first two packs contain only padding
1578            and the first pack from the other stream, respectively, may also have
1579            been written before.
1580            So the real data starts at SCR 36000+3*1200. */
1581         o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
1582     } else if (!strcmp(arg, "svcd")) {
1583
1584         opt_video_codec(o, "c:v", "mpeg2video");
1585         opt_audio_codec(o, "c:a", "mp2");
1586         parse_option(o, "f", "svcd", options);
1587
1588         parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
1589         parse_option(o, "r", frame_rates[norm], options);
1590         opt_default("g", norm == PAL ? "15" : "18");
1591
1592         opt_default("b", "2040000");
1593         opt_default("maxrate", "2516000");
1594         opt_default("minrate", "0"); // 1145000;
1595         opt_default("bufsize", "1835008"); // 224*1024*8;
1596         opt_default("flags", "+scan_offset");
1597
1598
1599         opt_default("b:a", "224000");
1600         parse_option(o, "ar", "44100", options);
1601
1602         opt_default("packetsize", "2324");
1603
1604     } else if (!strcmp(arg, "dvd")) {
1605
1606         opt_video_codec(o, "c:v", "mpeg2video");
1607         opt_audio_codec(o, "c:a", "ac3");
1608         parse_option(o, "f", "dvd", options);
1609
1610         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1611         parse_option(o, "r", frame_rates[norm], options);
1612         opt_default("g", norm == PAL ? "15" : "18");
1613
1614         opt_default("b", "6000000");
1615         opt_default("maxrate", "9000000");
1616         opt_default("minrate", "0"); // 1500000;
1617         opt_default("bufsize", "1835008"); // 224*1024*8;
1618
1619         opt_default("packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
1620         opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
1621
1622         opt_default("b:a", "448000");
1623         parse_option(o, "ar", "48000", options);
1624
1625     } else if (!strncmp(arg, "dv", 2)) {
1626
1627         parse_option(o, "f", "dv", options);
1628
1629         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1630         parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
1631                           norm == PAL ? "yuv420p" : "yuv411p", options);
1632         parse_option(o, "r", frame_rates[norm], options);
1633
1634         parse_option(o, "ar", "48000", options);
1635         parse_option(o, "ac", "2", options);
1636
1637     } else {
1638         av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
1639         return AVERROR(EINVAL);
1640     }
1641     return 0;
1642 }
1643
1644 static int opt_vstats_file(const char *opt, const char *arg)
1645 {
1646     av_free (vstats_filename);
1647     vstats_filename = av_strdup (arg);
1648     return 0;
1649 }
1650
1651 static int opt_vstats(const char *opt, const char *arg)
1652 {
1653     char filename[40];
1654     time_t today2 = time(NULL);
1655     struct tm *today = localtime(&today2);
1656
1657     snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
1658              today->tm_sec);
1659     return opt_vstats_file(opt, filename);
1660 }
1661
1662 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
1663 {
1664     OptionsContext *o = optctx;
1665     return parse_option(o, "frames:v", arg, options);
1666 }
1667
1668 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
1669 {
1670     OptionsContext *o = optctx;
1671     return parse_option(o, "frames:a", arg, options);
1672 }
1673
1674 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
1675 {
1676     OptionsContext *o = optctx;
1677     return parse_option(o, "frames:d", arg, options);
1678 }
1679
1680 static int opt_video_tag(void *optctx, const char *opt, const char *arg)
1681 {
1682     OptionsContext *o = optctx;
1683     return parse_option(o, "tag:v", arg, options);
1684 }
1685
1686 static int opt_audio_tag(void *optctx, const char *opt, const char *arg)
1687 {
1688     OptionsContext *o = optctx;
1689     return parse_option(o, "tag:a", arg, options);
1690 }
1691
1692 static int opt_subtitle_tag(void *optctx, const char *opt, const char *arg)
1693 {
1694     OptionsContext *o = optctx;
1695     return parse_option(o, "tag:s", arg, options);
1696 }
1697
1698 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
1699 {
1700     OptionsContext *o = optctx;
1701     return parse_option(o, "filter:v", arg, options);
1702 }
1703
1704 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
1705 {
1706     OptionsContext *o = optctx;
1707     return parse_option(o, "filter:a", arg, options);
1708 }
1709
1710 static int opt_vsync(const char *opt, const char *arg)
1711 {
1712     if      (!av_strcasecmp(arg, "cfr"))         video_sync_method = VSYNC_CFR;
1713     else if (!av_strcasecmp(arg, "vfr"))         video_sync_method = VSYNC_VFR;
1714     else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
1715
1716     if (video_sync_method == VSYNC_AUTO)
1717         video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
1718     return 0;
1719 }
1720
1721 static int opt_deinterlace(const char *opt, const char *arg)
1722 {
1723     av_log(NULL, AV_LOG_WARNING, "-%s is deprecated, use -filter:v yadif instead\n", opt);
1724     do_deinterlace = 1;
1725     return 0;
1726 }
1727
1728 int opt_cpuflags(const char *opt, const char *arg)
1729 {
1730     int flags = av_parse_cpu_flags(arg);
1731
1732     if (flags < 0)
1733         return flags;
1734
1735     av_set_cpu_flags_mask(flags);
1736     return 0;
1737 }
1738
1739 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
1740 {
1741     OptionsContext *o = optctx;
1742     char layout_str[32];
1743     char *stream_str;
1744     char *ac_str;
1745     int ret, channels, ac_str_size;
1746     uint64_t layout;
1747
1748     layout = av_get_channel_layout(arg);
1749     if (!layout) {
1750         av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
1751         return AVERROR(EINVAL);
1752     }
1753     snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
1754     ret = opt_default(opt, layout_str);
1755     if (ret < 0)
1756         return ret;
1757
1758     /* set 'ac' option based on channel layout */
1759     channels = av_get_channel_layout_nb_channels(layout);
1760     snprintf(layout_str, sizeof(layout_str), "%d", channels);
1761     stream_str = strchr(opt, ':');
1762     ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
1763     ac_str = av_mallocz(ac_str_size);
1764     if (!ac_str)
1765         return AVERROR(ENOMEM);
1766     av_strlcpy(ac_str, "ac", 3);
1767     if (stream_str)
1768         av_strlcat(ac_str, stream_str, ac_str_size);
1769     ret = parse_option(o, ac_str, layout_str, options);
1770     av_free(ac_str);
1771
1772     return ret;
1773 }
1774
1775 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
1776 {
1777     OptionsContext *o = optctx;
1778     return parse_option(o, "q:a", arg, options);
1779 }
1780
1781 static int opt_filter_complex(const char *opt, const char *arg)
1782 {
1783     filtergraphs = grow_array(filtergraphs, sizeof(*filtergraphs),
1784                               &nb_filtergraphs, nb_filtergraphs + 1);
1785     if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
1786         return AVERROR(ENOMEM);
1787     filtergraphs[nb_filtergraphs - 1]->index       = nb_filtergraphs - 1;
1788     filtergraphs[nb_filtergraphs - 1]->graph_desc = arg;
1789     return 0;
1790 }
1791
1792 static int show_help(const char *opt, const char *arg)
1793 {
1794     int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
1795     av_log_set_callback(log_callback_help);
1796     show_usage();
1797     show_help_options(options, "Main options:",
1798                       0, OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE);
1799     show_help_options(options, "Advanced options:",
1800                       OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE);
1801     show_help_options(options, "Video options:",
1802                       OPT_VIDEO, OPT_EXPERT | OPT_AUDIO);
1803     show_help_options(options, "Advanced Video options:",
1804                       OPT_EXPERT | OPT_VIDEO, OPT_AUDIO);
1805     show_help_options(options, "Audio options:",
1806                       OPT_AUDIO, OPT_EXPERT | OPT_VIDEO);
1807     show_help_options(options, "Advanced Audio options:",
1808                       OPT_EXPERT | OPT_AUDIO, OPT_VIDEO);
1809     show_help_options(options, "Subtitle options:",
1810                       OPT_SUBTITLE, 0);
1811     printf("\n");
1812     show_help_children(avcodec_get_class(), flags);
1813     show_help_children(avformat_get_class(), flags);
1814     show_help_children(sws_get_class(), flags);
1815     return 0;
1816 }
1817
1818 void show_usage(void)
1819 {
1820     printf("Hyper fast Audio and Video encoder\n");
1821     printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
1822     printf("\n");
1823 }
1824
1825
1826 #define OFFSET(x) offsetof(OptionsContext, x)
1827 const OptionDef options[] = {
1828     /* main options */
1829 #include "cmdutils_common_opts.h"
1830     { "f",              HAS_ARG | OPT_STRING | OPT_OFFSET,           { .off       = OFFSET(format) },
1831         "force format", "fmt" },
1832     { "i",              HAS_ARG | OPT_FUNC2,                         { .func2_arg = opt_input_file },
1833         "input file name", "filename" },
1834     { "y",              OPT_BOOL,                                    {              &file_overwrite },
1835         "overwrite output files" },
1836     { "c",              HAS_ARG | OPT_STRING | OPT_SPEC,             { .off       = OFFSET(codec_names) },
1837         "codec name", "codec" },
1838     { "codec",          HAS_ARG | OPT_STRING | OPT_SPEC,             { .off       = OFFSET(codec_names) },
1839         "codec name", "codec" },
1840     { "pre",            HAS_ARG | OPT_STRING | OPT_SPEC,             { .off       = OFFSET(presets) },
1841         "preset name", "preset" },
1842     { "map",            HAS_ARG | OPT_EXPERT | OPT_FUNC2,            { .func2_arg = opt_map },
1843         "set input stream mapping",
1844         "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
1845     { "map_metadata",   HAS_ARG | OPT_STRING | OPT_SPEC,             { .off       = OFFSET(metadata_map) },
1846         "set metadata information of outfile from infile",
1847         "outfile[,metadata]:infile[,metadata]" },
1848     { "map_chapters",   HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(chapters_input_file) },
1849         "set chapters mapping", "input_file_index" },
1850     { "t",              HAS_ARG | OPT_TIME | OPT_OFFSET,             { .off = OFFSET(recording_time) },
1851         "record or transcode \"duration\" seconds of audio/video",
1852         "duration" },
1853     { "fs",             HAS_ARG | OPT_INT64 | OPT_OFFSET,            { .off = OFFSET(limit_filesize) },
1854         "set the limit file size in bytes", "limit_size" },
1855     { "ss",             HAS_ARG | OPT_TIME | OPT_OFFSET,             { .off = OFFSET(start_time) },
1856         "set the start time offset", "time_off" },
1857     { "itsoffset",      HAS_ARG | OPT_TIME | OPT_OFFSET,             { .off = OFFSET(input_ts_offset) },
1858         "set the input ts offset", "time_off" },
1859     { "itsscale",       HAS_ARG | OPT_DOUBLE | OPT_SPEC,             { .off = OFFSET(ts_scale) },
1860         "set the input ts scale", "scale" },
1861     { "metadata",       HAS_ARG | OPT_STRING | OPT_SPEC,             { .off = OFFSET(metadata) },
1862         "add metadata", "string=string" },
1863     { "dframes",        HAS_ARG | OPT_FUNC2,                         { .func2_arg = opt_data_frames },
1864         "set the number of data frames to record", "number" },
1865     { "benchmark",      OPT_BOOL | OPT_EXPERT,                       { &do_benchmark },
1866         "add timings for benchmarking" },
1867     { "timelimit",      HAS_ARG,                                     { .func_arg = opt_timelimit },
1868         "set max runtime in seconds", "limit" },
1869     { "dump",           OPT_BOOL | OPT_EXPERT,                       { &do_pkt_dump },
1870         "dump each input packet" },
1871     { "hex",            OPT_BOOL | OPT_EXPERT,                       { &do_hex_dump },
1872         "when dumping packets, also dump the payload" },
1873     { "re",             OPT_BOOL | OPT_EXPERT | OPT_OFFSET,          { .off = OFFSET(rate_emu) },
1874         "read input at native frame rate", "" },
1875     { "target",         HAS_ARG | OPT_FUNC2,                         { .func2_arg = opt_target },
1876         "specify target file type (\"vcd\", \"svcd\", \"dvd\","
1877         " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
1878     { "vsync",          HAS_ARG | OPT_EXPERT,                        { opt_vsync },
1879         "video sync method", "" },
1880     { "async",          HAS_ARG | OPT_INT | OPT_EXPERT,              { &audio_sync_method },
1881         "audio sync method", "" },
1882     { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,          { &audio_drift_threshold },
1883         "audio drift threshold", "threshold" },
1884     { "copyts",         OPT_BOOL | OPT_EXPERT,                       { &copy_ts },
1885         "copy timestamps" },
1886     { "copytb",         OPT_BOOL | OPT_EXPERT,                       { &copy_tb },
1887         "copy input stream time base when stream copying" },
1888     { "shortest",       OPT_BOOL | OPT_EXPERT | OPT_OFFSET,          { .off = OFFSET(shortest) },
1889         "finish encoding within shortest input" },
1890     { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,       { &dts_delta_threshold },
1891         "timestamp discontinuity delta threshold", "threshold" },
1892     { "xerror",         OPT_BOOL,                                    { &exit_on_error },
1893         "exit on error", "error" },
1894     { "copyinkf",       OPT_BOOL | OPT_EXPERT | OPT_SPEC,            { .off = OFFSET(copy_initial_nonkeyframes) },
1895         "copy initial non-keyframes" },
1896     { "frames",         OPT_INT64 | HAS_ARG | OPT_SPEC,              { .off = OFFSET(max_frames) },
1897         "set the number of frames to record", "number" },
1898     { "tag",            OPT_STRING | HAS_ARG | OPT_SPEC,             { .off = OFFSET(codec_tags) },
1899         "force codec tag/fourcc", "fourcc/tag" },
1900     { "q",              HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC,{ .off = OFFSET(qscale) },
1901         "use fixed quality scale (VBR)", "q" },
1902     { "qscale",         HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC,{ .off = OFFSET(qscale) },
1903         "use fixed quality scale (VBR)", "q" },
1904     { "filter",         HAS_ARG | OPT_STRING | OPT_SPEC,             { .off = OFFSET(filters) },
1905         "set stream filterchain", "filter_list" },
1906     { "filter_complex", HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_filter_complex },
1907         "create a complex filtergraph", "graph_description" },
1908     { "stats",          OPT_BOOL,                                    { &print_stats },
1909         "print progress report during encoding", },
1910     { "attach",         HAS_ARG | OPT_FUNC2,                         { .func2_arg = opt_attach },
1911         "add an attachment to the output file", "filename" },
1912     { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC,            { .off = OFFSET(dump_attachment) },
1913         "extract an attachment into a file", "filename" },
1914     { "cpuflags",       HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_cpuflags },
1915         "set CPU flags mask", "mask" },
1916
1917     /* video options */
1918     { "vframes",      OPT_VIDEO | HAS_ARG  | OPT_FUNC2,                          { .func2_arg = opt_video_frames },
1919         "set the number of video frames to record", "number" },
1920     { "r",            OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC,              { .off = OFFSET(frame_rates) },
1921         "set frame rate (Hz value, fraction or abbreviation)", "rate" },
1922     { "s",            OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC,              { .off = OFFSET(frame_sizes) },
1923         "set frame size (WxH or abbreviation)", "size" },
1924     { "aspect",       OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC,              { .off = OFFSET(frame_aspect_ratios) },
1925         "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
1926     { "pix_fmt",      OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC, { .off = OFFSET(frame_pix_fmts) },
1927         "set pixel format", "format" },
1928     { "vn",           OPT_VIDEO | OPT_BOOL  | OPT_OFFSET,                        { .off = OFFSET(video_disable) },
1929         "disable video" },
1930     { "vdt",          OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT ,               { &video_discard },
1931         "discard threshold", "n" },
1932     { "rc_override",  OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC, { .off = OFFSET(rc_overrides) },
1933         "rate control override for specific intervals", "override" },
1934     { "vcodec",       OPT_VIDEO | HAS_ARG  | OPT_FUNC2,                          { .func2_arg = opt_video_codec },
1935         "force video codec ('copy' to copy stream)", "codec" },
1936     { "same_quant",   OPT_VIDEO | OPT_BOOL ,                                     { &same_quant },
1937         "use same quantizer as source (implies VBR)" },
1938     { "pass",         OPT_VIDEO | HAS_ARG ,                                      { opt_pass },
1939         "select the pass number (1 or 2)", "n" },
1940     { "passlogfile",  OPT_VIDEO | HAS_ARG | OPT_STRING ,                         { &pass_logfilename_prefix },
1941         "select two pass log file name prefix", "prefix" },
1942     { "deinterlace",  OPT_VIDEO | OPT_EXPERT ,                                   { .func_arg = opt_deinterlace },
1943         "this option is deprecated, use the yadif filter instead" },
1944     { "vstats",       OPT_VIDEO | OPT_EXPERT ,                                   { &opt_vstats },
1945         "dump video coding statistics to file" },
1946     { "vstats_file",  OPT_VIDEO | HAS_ARG | OPT_EXPERT ,                         { opt_vstats_file },
1947         "dump video coding statistics to file", "file" },
1948     { "vf",           OPT_VIDEO | HAS_ARG  | OPT_FUNC2,                          { .func2_arg = opt_video_filters },
1949         "video filters", "filter list" },
1950     { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC, { .off = OFFSET(intra_matrices) },
1951         "specify intra matrix coeffs", "matrix" },
1952     { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC, { .off = OFFSET(inter_matrices) },
1953         "specify inter matrix coeffs", "matrix" },
1954     { "top",          OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_INT| OPT_SPEC,     { .off = OFFSET(top_field_first) },
1955         "top=1/bottom=0/auto=-1 field first", "" },
1956     { "dc",           OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT ,               { &intra_dc_precision },
1957         "intra_dc_precision", "precision" },
1958     { "vtag",         OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_FUNC2,             { .func2_arg = opt_video_tag },
1959         "force video tag/fourcc", "fourcc/tag" },
1960     { "qphist",       OPT_VIDEO | OPT_BOOL | OPT_EXPERT ,                        { &qp_hist },
1961         "show QP histogram" },
1962     { "force_fps",    OPT_VIDEO | OPT_BOOL | OPT_EXPERT  | OPT_SPEC,             { .off = OFFSET(force_fps) },
1963         "force the selected framerate, disable the best supported framerate selection" },
1964     { "streamid",     OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_FUNC2,              { .func2_arg = opt_streamid },
1965         "set the value of an outfile streamid", "streamIndex:value" },
1966     { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT  | OPT_SPEC,
1967         { .off = OFFSET(forced_key_frames) }, "force key frames at specified timestamps", "timestamps" },
1968
1969     /* audio options */
1970     { "aframes",        OPT_AUDIO | HAS_ARG  | OPT_FUNC2,                          { .func2_arg = opt_audio_frames },
1971         "set the number of audio frames to record", "number" },
1972     { "aq",             OPT_AUDIO | HAS_ARG  | OPT_FUNC2,                          { .func2_arg = opt_audio_qscale },
1973         "set audio quality (codec-specific)", "quality", },
1974     { "ar",             OPT_AUDIO | HAS_ARG  | OPT_INT | OPT_SPEC,                 { .off = OFFSET(audio_sample_rate) },
1975         "set audio sampling rate (in Hz)", "rate" },
1976     { "ac",             OPT_AUDIO | HAS_ARG  | OPT_INT | OPT_SPEC,                 { .off = OFFSET(audio_channels) },
1977         "set number of audio channels", "channels" },
1978     { "an",             OPT_AUDIO | OPT_BOOL | OPT_OFFSET,                         { .off = OFFSET(audio_disable) },
1979         "disable audio" },
1980     { "acodec",         OPT_AUDIO | HAS_ARG  | OPT_FUNC2,                          { .func2_arg = opt_audio_codec },
1981         "force audio codec ('copy' to copy stream)", "codec" },
1982     { "atag",           OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_FUNC2,             { .func2_arg = opt_audio_tag },
1983         "force audio tag/fourcc", "fourcc/tag" },
1984     { "vol",            OPT_AUDIO | HAS_ARG  | OPT_INT,                            { &audio_volume },
1985         "change audio volume (256=normal)" , "volume" },
1986     { "sample_fmt",     OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_SPEC | OPT_STRING, { .off = OFFSET(sample_fmts) },
1987         "set sample format", "format" },
1988     { "channel_layout", OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_FUNC2,             { .func2_arg = opt_channel_layout },
1989         "set channel layout", "layout" },
1990     { "af",             OPT_AUDIO | HAS_ARG  | OPT_FUNC2,                          { .func2_arg = opt_audio_filters },
1991         "audio filters", "filter list" },
1992
1993     /* subtitle options */
1994     { "sn",     OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET, { .off = OFFSET(subtitle_disable) },
1995         "disable subtitle" },
1996     { "scodec", OPT_SUBTITLE | HAS_ARG  | OPT_FUNC2,  { .func2_arg = opt_subtitle_codec },
1997         "force subtitle codec ('copy' to copy stream)", "codec" },
1998     { "stag",   OPT_SUBTITLE | HAS_ARG  | OPT_EXPERT  | OPT_FUNC2, { .func2_arg = opt_subtitle_tag }
1999         , "force subtitle tag/fourcc", "fourcc/tag" },
2000
2001     /* grab options */
2002     { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
2003
2004     /* muxer options */
2005     { "muxdelay",   OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(mux_max_delay) },
2006         "set the maximum demux-decode delay", "seconds" },
2007     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(mux_preload) },
2008         "set the initial demux-decode delay", "seconds" },
2009
2010     { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(bitstream_filters) },
2011         "A comma-separated list of bitstream filters", "bitstream_filters" },
2012
2013     /* data codec support */
2014     { "dcodec", HAS_ARG | OPT_DATA | OPT_FUNC2, { .func2_arg = opt_data_codec },
2015         "force data codec ('copy' to copy stream)", "codec" },
2016
2017     { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, { .func_arg = opt_default },
2018         "generic catch all option", "" },
2019     { NULL, },
2020 };