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