avconv: use a local variable for OutputFile in open_output_file().
[ffmpeg.git] / avconv_opt.c
1 /*
2  * avconv option parsing
3  *
4  * This file is part of Libav.
5  *
6  * Libav is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * Libav is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with Libav; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20
21 #include <stdint.h>
22
23 #include "avconv.h"
24 #include "cmdutils.h"
25
26 #include "libavformat/avformat.h"
27
28 #include "libavcodec/avcodec.h"
29
30 #include "libavfilter/avfilter.h"
31 #include "libavfilter/avfiltergraph.h"
32
33 #include "libavutil/avassert.h"
34 #include "libavutil/avstring.h"
35 #include "libavutil/avutil.h"
36 #include "libavutil/channel_layout.h"
37 #include "libavutil/intreadwrite.h"
38 #include "libavutil/fifo.h"
39 #include "libavutil/mathematics.h"
40 #include "libavutil/opt.h"
41 #include "libavutil/parseutils.h"
42 #include "libavutil/pixdesc.h"
43 #include "libavutil/pixfmt.h"
44
45 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
46 {\
47     int i, ret;\
48     for (i = 0; i < o->nb_ ## name; i++) {\
49         char *spec = o->name[i].specifier;\
50         if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
51             outvar = o->name[i].u.type;\
52         else if (ret < 0)\
53             exit(1);\
54     }\
55 }
56
57 char *vstats_filename;
58
59 float audio_drift_threshold = 0.1;
60 float dts_delta_threshold   = 10;
61
62 int audio_volume      = 256;
63 int audio_sync_method = 0;
64 int video_sync_method = VSYNC_AUTO;
65 int do_deinterlace    = 0;
66 int do_benchmark      = 0;
67 int do_hex_dump       = 0;
68 int do_pkt_dump       = 0;
69 int copy_ts           = 0;
70 int copy_tb           = 1;
71 int exit_on_error     = 0;
72 int print_stats       = 1;
73 int qp_hist           = 0;
74
75 static int file_overwrite     = 0;
76 static int video_discard      = 0;
77 static int intra_dc_precision = 8;
78 static int using_stdin        = 0;
79 static int input_sync;
80
81 static void uninit_options(OptionsContext *o)
82 {
83     const OptionDef *po = options;
84     int i;
85
86     /* all OPT_SPEC and OPT_STRING can be freed in generic way */
87     while (po->name) {
88         void *dst = (uint8_t*)o + po->u.off;
89
90         if (po->flags & OPT_SPEC) {
91             SpecifierOpt **so = dst;
92             int i, *count = (int*)(so + 1);
93             for (i = 0; i < *count; i++) {
94                 av_freep(&(*so)[i].specifier);
95                 if (po->flags & OPT_STRING)
96                     av_freep(&(*so)[i].u.str);
97             }
98             av_freep(so);
99             *count = 0;
100         } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
101             av_freep(dst);
102         po++;
103     }
104
105     for (i = 0; i < o->nb_stream_maps; i++)
106         av_freep(&o->stream_maps[i].linklabel);
107     av_freep(&o->stream_maps);
108     av_freep(&o->meta_data_maps);
109     av_freep(&o->streamid_map);
110 }
111
112 static void init_options(OptionsContext *o)
113 {
114     memset(o, 0, sizeof(*o));
115
116     o->mux_max_delay  = 0.7;
117     o->recording_time = INT64_MAX;
118     o->limit_filesize = UINT64_MAX;
119     o->chapters_input_file = INT_MAX;
120 }
121
122 static double parse_frame_aspect_ratio(const char *arg)
123 {
124     int x = 0, y = 0;
125     double ar = 0;
126     const char *p;
127     char *end;
128
129     p = strchr(arg, ':');
130     if (p) {
131         x = strtol(arg, &end, 10);
132         if (end == p)
133             y = strtol(end + 1, &end, 10);
134         if (x > 0 && y > 0)
135             ar = (double)x / (double)y;
136     } else
137         ar = strtod(arg, NULL);
138
139     if (!ar) {
140         av_log(NULL, AV_LOG_FATAL, "Incorrect aspect ratio specification.\n");
141         exit(1);
142     }
143     return ar;
144 }
145
146 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
147 {
148     OptionsContext *o = optctx;
149     return parse_option(o, "codec:a", arg, options);
150 }
151
152 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
153 {
154     OptionsContext *o = optctx;
155     return parse_option(o, "codec:v", arg, options);
156 }
157
158 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
159 {
160     OptionsContext *o = optctx;
161     return parse_option(o, "codec:s", arg, options);
162 }
163
164 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
165 {
166     OptionsContext *o = optctx;
167     return parse_option(o, "codec:d", arg, options);
168 }
169
170 static int opt_map(void *optctx, const char *opt, const char *arg)
171 {
172     OptionsContext *o = optctx;
173     StreamMap *m = NULL;
174     int i, negative = 0, file_idx;
175     int sync_file_idx = -1, sync_stream_idx;
176     char *p, *sync;
177     char *map;
178
179     if (*arg == '-') {
180         negative = 1;
181         arg++;
182     }
183     map = av_strdup(arg);
184
185     /* parse sync stream first, just pick first matching stream */
186     if (sync = strchr(map, ',')) {
187         *sync = 0;
188         sync_file_idx = strtol(sync + 1, &sync, 0);
189         if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
190             av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
191             exit(1);
192         }
193         if (*sync)
194             sync++;
195         for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
196             if (check_stream_specifier(input_files[sync_file_idx]->ctx,
197                                        input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
198                 sync_stream_idx = i;
199                 break;
200             }
201         if (i == input_files[sync_file_idx]->nb_streams) {
202             av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
203                                        "match any streams.\n", arg);
204             exit(1);
205         }
206     }
207
208
209     if (map[0] == '[') {
210         /* this mapping refers to lavfi output */
211         const char *c = map + 1;
212         GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
213         m = &o->stream_maps[o->nb_stream_maps - 1];
214         m->linklabel = av_get_token(&c, "]");
215         if (!m->linklabel) {
216             av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
217             exit(1);
218         }
219     } else {
220         file_idx = strtol(map, &p, 0);
221         if (file_idx >= nb_input_files || file_idx < 0) {
222             av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
223             exit(1);
224         }
225         if (negative)
226             /* disable some already defined maps */
227             for (i = 0; i < o->nb_stream_maps; i++) {
228                 m = &o->stream_maps[i];
229                 if (file_idx == m->file_index &&
230                     check_stream_specifier(input_files[m->file_index]->ctx,
231                                            input_files[m->file_index]->ctx->streams[m->stream_index],
232                                            *p == ':' ? p + 1 : p) > 0)
233                     m->disabled = 1;
234             }
235         else
236             for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
237                 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
238                             *p == ':' ? p + 1 : p) <= 0)
239                     continue;
240                 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
241                 m = &o->stream_maps[o->nb_stream_maps - 1];
242
243                 m->file_index   = file_idx;
244                 m->stream_index = i;
245
246                 if (sync_file_idx >= 0) {
247                     m->sync_file_index   = sync_file_idx;
248                     m->sync_stream_index = sync_stream_idx;
249                 } else {
250                     m->sync_file_index   = file_idx;
251                     m->sync_stream_index = i;
252                 }
253             }
254     }
255
256     if (!m) {
257         av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
258         exit(1);
259     }
260
261     av_freep(&map);
262     return 0;
263 }
264
265 static int opt_attach(void *optctx, const char *opt, const char *arg)
266 {
267     OptionsContext *o = optctx;
268     GROW_ARRAY(o->attachments, o->nb_attachments);
269     o->attachments[o->nb_attachments - 1] = arg;
270     return 0;
271 }
272
273 /**
274  * Parse a metadata specifier passed as 'arg' parameter.
275  * @param arg  metadata string to parse
276  * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
277  * @param index for type c/p, chapter/program index is written here
278  * @param stream_spec for type s, the stream specifier is written here
279  */
280 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
281 {
282     if (*arg) {
283         *type = *arg;
284         switch (*arg) {
285         case 'g':
286             break;
287         case 's':
288             if (*(++arg) && *arg != ':') {
289                 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
290                 exit(1);
291             }
292             *stream_spec = *arg == ':' ? arg + 1 : "";
293             break;
294         case 'c':
295         case 'p':
296             if (*(++arg) == ':')
297                 *index = strtol(++arg, NULL, 0);
298             break;
299         default:
300             av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
301             exit(1);
302         }
303     } else
304         *type = 'g';
305 }
306
307 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
308 {
309     AVDictionary **meta_in = NULL;
310     AVDictionary **meta_out;
311     int i, ret = 0;
312     char type_in, type_out;
313     const char *istream_spec = NULL, *ostream_spec = NULL;
314     int idx_in = 0, idx_out = 0;
315
316     parse_meta_type(inspec,  &type_in,  &idx_in,  &istream_spec);
317     parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
318
319     if (type_in == 'g' || type_out == 'g')
320         o->metadata_global_manual = 1;
321     if (type_in == 's' || type_out == 's')
322         o->metadata_streams_manual = 1;
323     if (type_in == 'c' || type_out == 'c')
324         o->metadata_chapters_manual = 1;
325
326     /* ic is NULL when just disabling automatic mappings */
327     if (!ic)
328         return 0;
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         case 's':\
351             break; /* handled separately below */ \
352         default: av_assert0(0);\
353         }\
354
355     SET_DICT(type_in, meta_in, ic, idx_in);
356     SET_DICT(type_out, meta_out, oc, idx_out);
357
358     /* for input streams choose first matching stream */
359     if (type_in == 's') {
360         for (i = 0; i < ic->nb_streams; i++) {
361             if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
362                 meta_in = &ic->streams[i]->metadata;
363                 break;
364             } else if (ret < 0)
365                 exit(1);
366         }
367         if (!meta_in) {
368             av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match  any streams.\n", istream_spec);
369             exit(1);
370         }
371     }
372
373     if (type_out == 's') {
374         for (i = 0; i < oc->nb_streams; i++) {
375             if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
376                 meta_out = &oc->streams[i]->metadata;
377                 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
378             } else if (ret < 0)
379                 exit(1);
380         }
381     } else
382         av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
383
384     return 0;
385 }
386
387 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
388 {
389     const AVCodecDescriptor *desc;
390     const char *codec_string = encoder ? "encoder" : "decoder";
391     AVCodec *codec;
392
393     codec = encoder ?
394         avcodec_find_encoder_by_name(name) :
395         avcodec_find_decoder_by_name(name);
396
397     if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
398         codec = encoder ? avcodec_find_encoder(desc->id) :
399                           avcodec_find_decoder(desc->id);
400         if (codec)
401             av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
402                    codec_string, codec->name, desc->name);
403     }
404
405     if (!codec) {
406         av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
407         exit(1);
408     }
409     if (codec->type != type) {
410         av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
411         exit(1);
412     }
413     return codec;
414 }
415
416 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
417 {
418     char *codec_name = NULL;
419
420     MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
421     if (codec_name) {
422         AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
423         st->codec->codec_id = codec->id;
424         return codec;
425     } else
426         return avcodec_find_decoder(st->codec->codec_id);
427 }
428
429 /* Add all the streams from the given input file to the global
430  * list of input streams. */
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         GROW_ARRAY(input_streams, nb_input_streams);
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
452         ist->ts_scale = 1.0;
453         MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
454
455         ist->dec = choose_decoder(o, ic, st);
456         ist->opts = filter_codec_opts(o->g->codec_opts, ist->st->codec->codec_id, ic, st, ist->dec);
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 open_input_file(OptionsContext *o, const char *filename)
548 {
549     AVFormatContext *ic;
550     AVInputFormat *file_iformat = NULL;
551     int err, i, ret;
552     int64_t timestamp;
553     uint8_t buf[128];
554     AVDictionary **opts;
555     int orig_nb_streams;                     // number of streams before avformat_find_stream_info
556
557     if (o->format) {
558         if (!(file_iformat = av_find_input_format(o->format))) {
559             av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
560             exit(1);
561         }
562     }
563
564     if (!strcmp(filename, "-"))
565         filename = "pipe:";
566
567     using_stdin |= !strncmp(filename, "pipe:", 5) ||
568                     !strcmp(filename, "/dev/stdin");
569
570     /* get default parameters from command line */
571     ic = avformat_alloc_context();
572     if (!ic) {
573         print_error(filename, AVERROR(ENOMEM));
574         exit(1);
575     }
576     if (o->nb_audio_sample_rate) {
577         snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
578         av_dict_set(&o->g->format_opts, "sample_rate", buf, 0);
579     }
580     if (o->nb_audio_channels) {
581         /* because we set audio_channels based on both the "ac" and
582          * "channel_layout" options, we need to check that the specified
583          * demuxer actually has the "channels" option before setting it */
584         if (file_iformat && file_iformat->priv_class &&
585             av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
586                         AV_OPT_SEARCH_FAKE_OBJ)) {
587             snprintf(buf, sizeof(buf), "%d",
588                      o->audio_channels[o->nb_audio_channels - 1].u.i);
589             av_dict_set(&o->g->format_opts, "channels", buf, 0);
590         }
591     }
592     if (o->nb_frame_rates) {
593         /* set the format-level framerate option;
594          * this is important for video grabbers, e.g. x11 */
595         if (file_iformat && file_iformat->priv_class &&
596             av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
597                         AV_OPT_SEARCH_FAKE_OBJ)) {
598             av_dict_set(&o->g->format_opts, "framerate",
599                         o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
600         }
601     }
602     if (o->nb_frame_sizes) {
603         av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
604     }
605     if (o->nb_frame_pix_fmts)
606         av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
607
608     ic->flags |= AVFMT_FLAG_NONBLOCK;
609     ic->interrupt_callback = int_cb;
610
611     /* open the input file with generic libav function */
612     err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
613     if (err < 0) {
614         print_error(filename, err);
615         exit(1);
616     }
617     assert_avoptions(o->g->format_opts);
618
619     /* apply forced codec ids */
620     for (i = 0; i < ic->nb_streams; i++)
621         choose_decoder(o, ic, ic->streams[i]);
622
623     /* Set AVCodecContext options for avformat_find_stream_info */
624     opts = setup_find_stream_info_opts(ic, o->g->codec_opts);
625     orig_nb_streams = ic->nb_streams;
626
627     /* If not enough info to get the stream parameters, we decode the
628        first frames to get it. (used in mpeg case for example) */
629     ret = avformat_find_stream_info(ic, opts);
630     if (ret < 0) {
631         av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
632         avformat_close_input(&ic);
633         exit(1);
634     }
635
636     timestamp = o->start_time;
637     /* add the stream start time */
638     if (ic->start_time != AV_NOPTS_VALUE)
639         timestamp += ic->start_time;
640
641     /* if seeking requested, we execute it */
642     if (o->start_time != 0) {
643         ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
644         if (ret < 0) {
645             av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
646                    filename, (double)timestamp / AV_TIME_BASE);
647         }
648     }
649
650     /* update the current parameters so that they match the one of the input stream */
651     add_input_streams(o, ic);
652
653     /* dump the file content */
654     av_dump_format(ic, nb_input_files, filename, 0);
655
656     GROW_ARRAY(input_files, nb_input_files);
657     if (!(input_files[nb_input_files - 1] = av_mallocz(sizeof(*input_files[0]))))
658         exit(1);
659
660     input_files[nb_input_files - 1]->ctx        = ic;
661     input_files[nb_input_files - 1]->ist_index  = nb_input_streams - ic->nb_streams;
662     input_files[nb_input_files - 1]->ts_offset  = o->input_ts_offset - (copy_ts ? 0 : timestamp);
663     input_files[nb_input_files - 1]->nb_streams = ic->nb_streams;
664     input_files[nb_input_files - 1]->rate_emu   = o->rate_emu;
665
666     for (i = 0; i < o->nb_dump_attachment; i++) {
667         int j;
668
669         for (j = 0; j < ic->nb_streams; j++) {
670             AVStream *st = ic->streams[j];
671
672             if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
673                 dump_attachment(st, o->dump_attachment[i].u.str);
674         }
675     }
676
677     for (i = 0; i < orig_nb_streams; i++)
678         av_dict_free(&opts[i]);
679     av_freep(&opts);
680
681     return 0;
682 }
683
684 static uint8_t *get_line(AVIOContext *s)
685 {
686     AVIOContext *line;
687     uint8_t *buf;
688     char c;
689
690     if (avio_open_dyn_buf(&line) < 0) {
691         av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
692         exit(1);
693     }
694
695     while ((c = avio_r8(s)) && c != '\n')
696         avio_w8(line, c);
697     avio_w8(line, 0);
698     avio_close_dyn_buf(line, &buf);
699
700     return buf;
701 }
702
703 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
704 {
705     int i, ret = 1;
706     char filename[1000];
707     const char *base[3] = { getenv("AVCONV_DATADIR"),
708                             getenv("HOME"),
709                             AVCONV_DATADIR,
710                             };
711
712     for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
713         if (!base[i])
714             continue;
715         if (codec_name) {
716             snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
717                      i != 1 ? "" : "/.avconv", codec_name, preset_name);
718             ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
719         }
720         if (ret) {
721             snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
722                      i != 1 ? "" : "/.avconv", preset_name);
723             ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
724         }
725     }
726     return ret;
727 }
728
729 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
730 {
731     char *codec_name = NULL;
732
733     MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
734     if (!codec_name) {
735         ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
736                                                   NULL, ost->st->codec->codec_type);
737         ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
738     } else if (!strcmp(codec_name, "copy"))
739         ost->stream_copy = 1;
740     else {
741         ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
742         ost->st->codec->codec_id = ost->enc->id;
743     }
744 }
745
746 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type)
747 {
748     OutputStream *ost;
749     AVStream *st = avformat_new_stream(oc, NULL);
750     int idx      = oc->nb_streams - 1, ret = 0;
751     char *bsf = NULL, *next, *codec_tag = NULL;
752     AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
753     double qscale = -1;
754
755     if (!st) {
756         av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
757         exit(1);
758     }
759
760     if (oc->nb_streams - 1 < o->nb_streamid_map)
761         st->id = o->streamid_map[oc->nb_streams - 1];
762
763     GROW_ARRAY(output_streams, nb_output_streams);
764     if (!(ost = av_mallocz(sizeof(*ost))))
765         exit(1);
766     output_streams[nb_output_streams - 1] = ost;
767
768     ost->file_index = nb_output_files;
769     ost->index      = idx;
770     ost->st         = st;
771     st->codec->codec_type = type;
772     choose_encoder(o, oc, ost);
773     if (ost->enc) {
774         AVIOContext *s = NULL;
775         char *buf = NULL, *arg = NULL, *preset = NULL;
776
777         ost->opts  = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
778
779         MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
780         if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
781             do  {
782                 buf = get_line(s);
783                 if (!buf[0] || buf[0] == '#') {
784                     av_free(buf);
785                     continue;
786                 }
787                 if (!(arg = strchr(buf, '='))) {
788                     av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
789                     exit(1);
790                 }
791                 *arg++ = 0;
792                 av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
793                 av_free(buf);
794             } while (!s->eof_reached);
795             avio_close(s);
796         }
797         if (ret) {
798             av_log(NULL, AV_LOG_FATAL,
799                    "Preset %s specified for stream %d:%d, but could not be opened.\n",
800                    preset, ost->file_index, ost->index);
801             exit(1);
802         }
803     } else {
804         ost->opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
805     }
806
807     avcodec_get_context_defaults3(st->codec, ost->enc);
808     st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
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) {
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(o->g->sws_opts, "sws_flags", 0, &ost->sws_flags);
848
849     av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
850
851     ost->pix_fmts[0] = ost->pix_fmts[1] = AV_PIX_FMT_NONE;
852
853     return ost;
854 }
855
856 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
857 {
858     int i;
859     const char *p = str;
860     for (i = 0;; i++) {
861         dest[i] = atoi(p);
862         if (i == 63)
863             break;
864         p = strchr(p, ',');
865         if (!p) {
866             av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
867             exit(1);
868         }
869         p++;
870     }
871 }
872
873 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc)
874 {
875     AVStream *st;
876     OutputStream *ost;
877     AVCodecContext *video_enc;
878
879     ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO);
880     st  = ost->st;
881     video_enc = st->codec;
882
883     if (!ost->stream_copy) {
884         const char *p = NULL;
885         char *frame_rate = NULL, *frame_size = NULL;
886         char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
887         char *intra_matrix = NULL, *inter_matrix = NULL;
888         const char *filters = "null";
889         int do_pass = 0;
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(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(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)) == AV_PIX_FMT_NONE) {
910             av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
911             exit(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(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(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(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         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 static int open_output_file(OptionsContext *o, const char *filename)
1172 {
1173     AVFormatContext *oc;
1174     int i, j, err;
1175     AVOutputFormat *file_oformat;
1176     OutputFile *of;
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     GROW_ARRAY(output_files, nb_output_files);
1369     of = av_mallocz(sizeof(*of));
1370     if (!of)
1371         exit(1);
1372     output_files[nb_output_files - 1] = of;
1373
1374     of->ctx            = oc;
1375     of->ost_index      = nb_output_streams - oc->nb_streams;
1376     of->recording_time = o->recording_time;
1377     if (o->recording_time != INT64_MAX)
1378         oc->duration = o->recording_time;
1379     of->start_time     = o->start_time;
1380     of->limit_filesize = o->limit_filesize;
1381     of->shortest       = o->shortest;
1382     av_dict_copy(&of->opts, o->g->format_opts, 0);
1383
1384     /* check filename in case of an image number is expected */
1385     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
1386         if (!av_filename_number_test(oc->filename)) {
1387             print_error(oc->filename, AVERROR(EINVAL));
1388             exit(1);
1389         }
1390     }
1391
1392     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
1393         /* test if it already exists to avoid losing precious files */
1394         assert_file_overwrite(filename);
1395
1396         /* open the file */
1397         if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
1398                               &oc->interrupt_callback,
1399                               &of->opts)) < 0) {
1400             print_error(filename, err);
1401             exit(1);
1402         }
1403     }
1404
1405     if (o->mux_preload) {
1406         uint8_t buf[64];
1407         snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
1408         av_dict_set(&of->opts, "preload", buf, 0);
1409     }
1410     oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
1411     oc->flags |= AVFMT_FLAG_NONBLOCK;
1412
1413     /* copy metadata */
1414     for (i = 0; i < o->nb_metadata_map; i++) {
1415         char *p;
1416         int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
1417
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,
1423                       in_file_index >= 0 ?
1424                       input_files[in_file_index]->ctx : NULL, o);
1425     }
1426
1427     /* copy chapters */
1428     if (o->chapters_input_file >= nb_input_files) {
1429         if (o->chapters_input_file == INT_MAX) {
1430             /* copy chapters from the first input file that has them*/
1431             o->chapters_input_file = -1;
1432             for (i = 0; i < nb_input_files; i++)
1433                 if (input_files[i]->ctx->nb_chapters) {
1434                     o->chapters_input_file = i;
1435                     break;
1436                 }
1437         } else {
1438             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
1439                    o->chapters_input_file);
1440             exit(1);
1441         }
1442     }
1443     if (o->chapters_input_file >= 0)
1444         copy_chapters(input_files[o->chapters_input_file], of,
1445                       !o->metadata_chapters_manual);
1446
1447     /* copy global metadata by default */
1448     if (!o->metadata_global_manual && nb_input_files)
1449         av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
1450                      AV_DICT_DONT_OVERWRITE);
1451     if (!o->metadata_streams_manual)
1452         for (i = of->ost_index; i < nb_output_streams; i++) {
1453             InputStream *ist;
1454             if (output_streams[i]->source_index < 0)         /* this is true e.g. for attached files */
1455                 continue;
1456             ist = input_streams[output_streams[i]->source_index];
1457             av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
1458         }
1459
1460     /* process manually set metadata */
1461     for (i = 0; i < o->nb_metadata; i++) {
1462         AVDictionary **m;
1463         char type, *val;
1464         const char *stream_spec;
1465         int index = 0, j, ret;
1466
1467         val = strchr(o->metadata[i].u.str, '=');
1468         if (!val) {
1469             av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
1470                    o->metadata[i].u.str);
1471             exit(1);
1472         }
1473         *val++ = 0;
1474
1475         parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
1476         if (type == 's') {
1477             for (j = 0; j < oc->nb_streams; j++) {
1478                 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
1479                     av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
1480                 } else if (ret < 0)
1481                     exit(1);
1482             }
1483         }
1484         else {
1485             switch (type) {
1486             case 'g':
1487                 m = &oc->metadata;
1488                 break;
1489             case 'c':
1490                 if (index < 0 || index >= oc->nb_chapters) {
1491                     av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
1492                     exit(1);
1493                 }
1494                 m = &oc->chapters[index]->metadata;
1495                 break;
1496             default:
1497                 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
1498                 exit(1);
1499             }
1500             av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
1501         }
1502     }
1503
1504     return 0;
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(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(NULL, "g", norm == PAL ? "15" : "18");
1563
1564         opt_default(NULL, "b", "1150000");
1565         opt_default(NULL, "maxrate", "1150000");
1566         opt_default(NULL, "minrate", "1150000");
1567         opt_default(NULL, "bufsize", "327680"); // 40*1024*8;
1568
1569         opt_default(NULL, "b:a", "224000");
1570         parse_option(o, "ar", "44100", options);
1571         parse_option(o, "ac", "2", options);
1572
1573         opt_default(NULL, "packetsize", "2324");
1574         opt_default(NULL, "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(NULL, "g", norm == PAL ? "15" : "18");
1591
1592         opt_default(NULL, "b", "2040000");
1593         opt_default(NULL, "maxrate", "2516000");
1594         opt_default(NULL, "minrate", "0"); // 1145000;
1595         opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
1596         opt_default(NULL, "flags", "+scan_offset");
1597
1598
1599         opt_default(NULL, "b:a", "224000");
1600         parse_option(o, "ar", "44100", options);
1601
1602         opt_default(NULL, "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(NULL, "g", norm == PAL ? "15" : "18");
1613
1614         opt_default(NULL, "b", "6000000");
1615         opt_default(NULL, "maxrate", "9000000");
1616         opt_default(NULL, "minrate", "0"); // 1500000;
1617         opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
1618
1619         opt_default(NULL, "packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
1620         opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
1621
1622         opt_default(NULL, "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(void *optctx, 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(void *optctx, 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(NULL, 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(void *optctx, 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 #if FF_API_DEINTERLACE
1722 static int opt_deinterlace(void *optctx, const char *opt, const char *arg)
1723 {
1724     av_log(NULL, AV_LOG_WARNING, "-%s is deprecated, use -filter:v yadif instead\n", opt);
1725     do_deinterlace = 1;
1726     return 0;
1727 }
1728 #endif
1729
1730 int opt_cpuflags(void *optctx, const char *opt, const char *arg)
1731 {
1732     int flags = av_parse_cpu_flags(arg);
1733
1734     if (flags < 0)
1735         return flags;
1736
1737     av_set_cpu_flags_mask(flags);
1738     return 0;
1739 }
1740
1741 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
1742 {
1743     OptionsContext *o = optctx;
1744     char layout_str[32];
1745     char *stream_str;
1746     char *ac_str;
1747     int ret, channels, ac_str_size;
1748     uint64_t layout;
1749
1750     layout = av_get_channel_layout(arg);
1751     if (!layout) {
1752         av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
1753         return AVERROR(EINVAL);
1754     }
1755     snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
1756     ret = opt_default(NULL, opt, layout_str);
1757     if (ret < 0)
1758         return ret;
1759
1760     /* set 'ac' option based on channel layout */
1761     channels = av_get_channel_layout_nb_channels(layout);
1762     snprintf(layout_str, sizeof(layout_str), "%d", channels);
1763     stream_str = strchr(opt, ':');
1764     ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
1765     ac_str = av_mallocz(ac_str_size);
1766     if (!ac_str)
1767         return AVERROR(ENOMEM);
1768     av_strlcpy(ac_str, "ac", 3);
1769     if (stream_str)
1770         av_strlcat(ac_str, stream_str, ac_str_size);
1771     ret = parse_option(o, ac_str, layout_str, options);
1772     av_free(ac_str);
1773
1774     return ret;
1775 }
1776
1777 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
1778 {
1779     OptionsContext *o = optctx;
1780     return parse_option(o, "q:a", arg, options);
1781 }
1782
1783 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
1784 {
1785     GROW_ARRAY(filtergraphs, nb_filtergraphs);
1786     if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
1787         return AVERROR(ENOMEM);
1788     filtergraphs[nb_filtergraphs - 1]->index       = nb_filtergraphs - 1;
1789     filtergraphs[nb_filtergraphs - 1]->graph_desc = arg;
1790     return 0;
1791 }
1792
1793 void show_help_default(const char *opt, const char *arg)
1794 {
1795     /* per-file options have at least one of those set */
1796     const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
1797     int show_advanced = 0, show_avoptions = 0;
1798
1799     if (opt && *opt) {
1800         if (!strcmp(opt, "long"))
1801             show_advanced = 1;
1802         else if (!strcmp(opt, "full"))
1803             show_advanced = show_avoptions = 1;
1804         else
1805             av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
1806     }
1807
1808     show_usage();
1809
1810     printf("Getting help:\n"
1811            "    -h      -- print basic options\n"
1812            "    -h long -- print more options\n"
1813            "    -h full -- print all options (including all format and codec specific options, very long)\n"
1814            "    See man %s for detailed description of the options.\n"
1815            "\n", program_name);
1816
1817     show_help_options(options, "Print help / information / capabilities:",
1818                       OPT_EXIT, 0, 0);
1819
1820     show_help_options(options, "Global options (affect whole program "
1821                       "instead of just one file:",
1822                       0, per_file | OPT_EXIT | OPT_EXPERT, 0);
1823     if (show_advanced)
1824         show_help_options(options, "Advanced global options:", OPT_EXPERT,
1825                           per_file | OPT_EXIT, 0);
1826
1827     show_help_options(options, "Per-file main options:", 0,
1828                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
1829                       OPT_EXIT, per_file);
1830     if (show_advanced)
1831         show_help_options(options, "Advanced per-file options:",
1832                           OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
1833
1834     show_help_options(options, "Video options:",
1835                       OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
1836     if (show_advanced)
1837         show_help_options(options, "Advanced Video options:",
1838                           OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
1839
1840     show_help_options(options, "Audio options:",
1841                       OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
1842     if (show_advanced)
1843         show_help_options(options, "Advanced Audio options:",
1844                           OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
1845     show_help_options(options, "Subtitle options:",
1846                       OPT_SUBTITLE, 0, 0);
1847     printf("\n");
1848
1849     if (show_avoptions) {
1850         int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
1851         show_help_children(avcodec_get_class(), flags);
1852         show_help_children(avformat_get_class(), flags);
1853         show_help_children(sws_get_class(), flags);
1854     }
1855 }
1856
1857 void show_usage(void)
1858 {
1859     printf("Hyper fast Audio and Video encoder\n");
1860     printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
1861     printf("\n");
1862 }
1863
1864 enum OptGroup {
1865     GROUP_OUTFILE,
1866     GROUP_INFILE,
1867 };
1868
1869 static const OptionGroupDef groups[] = {
1870     [GROUP_OUTFILE] = { "output file",  NULL, OPT_OUTPUT },
1871     [GROUP_INFILE]  = { "input file",   "i",  OPT_INPUT },
1872 };
1873
1874 static int open_files(OptionGroupList *l, const char *inout,
1875                       int (*open_file)(OptionsContext*, const char*))
1876 {
1877     int i, ret;
1878
1879     for (i = 0; i < l->nb_groups; i++) {
1880         OptionGroup *g = &l->groups[i];
1881         OptionsContext o;
1882
1883         init_options(&o);
1884         o.g = g;
1885
1886         ret = parse_optgroup(&o, g);
1887         if (ret < 0) {
1888             av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
1889                    "%s.\n", inout, g->arg);
1890             return ret;
1891         }
1892
1893         av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
1894         ret = open_file(&o, g->arg);
1895         uninit_options(&o);
1896         if (ret < 0) {
1897             av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
1898                    inout, g->arg);
1899             return ret;
1900         }
1901         av_log(NULL, AV_LOG_DEBUG, "Successfully openened the file.\n");
1902     }
1903
1904     return 0;
1905 }
1906
1907 int avconv_parse_options(int argc, char **argv)
1908 {
1909     OptionParseContext octx;
1910     uint8_t error[128];
1911     int ret;
1912
1913     memset(&octx, 0, sizeof(octx));
1914
1915     /* split the commandline into an internal representation */
1916     ret = split_commandline(&octx, argc, argv, options, groups,
1917                             FF_ARRAY_ELEMS(groups));
1918     if (ret < 0) {
1919         av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
1920         goto fail;
1921     }
1922
1923     /* apply global options */
1924     ret = parse_optgroup(NULL, &octx.global_opts);
1925     if (ret < 0) {
1926         av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
1927         goto fail;
1928     }
1929
1930     /* open input files */
1931     ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
1932     if (ret < 0) {
1933         av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
1934         goto fail;
1935     }
1936
1937     /* open output files */
1938     ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
1939     if (ret < 0) {
1940         av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
1941         goto fail;
1942     }
1943
1944 fail:
1945     uninit_parse_context(&octx);
1946     if (ret < 0) {
1947         av_strerror(ret, error, sizeof(error));
1948         av_log(NULL, AV_LOG_FATAL, "%s\n", error);
1949     }
1950     return ret;
1951 }
1952
1953 #define OFFSET(x) offsetof(OptionsContext, x)
1954 const OptionDef options[] = {
1955     /* main options */
1956 #include "cmdutils_common_opts.h"
1957     { "f",              HAS_ARG | OPT_STRING | OPT_OFFSET |
1958                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(format) },
1959         "force format", "fmt" },
1960     { "y",              OPT_BOOL,                                    {              &file_overwrite },
1961         "overwrite output files" },
1962     { "c",              HAS_ARG | OPT_STRING | OPT_SPEC |
1963                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(codec_names) },
1964         "codec name", "codec" },
1965     { "codec",          HAS_ARG | OPT_STRING | OPT_SPEC |
1966                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(codec_names) },
1967         "codec name", "codec" },
1968     { "pre",            HAS_ARG | OPT_STRING | OPT_SPEC |
1969                         OPT_OUTPUT,                                  { .off       = OFFSET(presets) },
1970         "preset name", "preset" },
1971     { "map",            HAS_ARG | OPT_EXPERT | OPT_PERFILE |
1972                         OPT_OUTPUT,                                  { .func_arg = opt_map },
1973         "set input stream mapping",
1974         "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
1975     { "map_metadata",   HAS_ARG | OPT_STRING | OPT_SPEC |
1976                         OPT_OUTPUT,                                  { .off       = OFFSET(metadata_map) },
1977         "set metadata information of outfile from infile",
1978         "outfile[,metadata]:infile[,metadata]" },
1979     { "map_chapters",   HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
1980                         OPT_OUTPUT,                                  { .off = OFFSET(chapters_input_file) },
1981         "set chapters mapping", "input_file_index" },
1982     { "t",              HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(recording_time) },
1983         "record or transcode \"duration\" seconds of audio/video",
1984         "duration" },
1985     { "fs",             HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
1986         "set the limit file size in bytes", "limit_size" },
1987     { "ss",             HAS_ARG | OPT_TIME | OPT_OFFSET |
1988                         OPT_INPUT | OPT_OUTPUT,                      { .off = OFFSET(start_time) },
1989         "set the start time offset", "time_off" },
1990     { "itsoffset",      HAS_ARG | OPT_TIME | OPT_OFFSET |
1991                         OPT_EXPERT | OPT_INPUT,                      { .off = OFFSET(input_ts_offset) },
1992         "set the input ts offset", "time_off" },
1993     { "itsscale",       HAS_ARG | OPT_DOUBLE | OPT_SPEC |
1994                         OPT_EXPERT | OPT_INPUT,                      { .off = OFFSET(ts_scale) },
1995         "set the input ts scale", "scale" },
1996     { "metadata",       HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
1997         "add metadata", "string=string" },
1998     { "dframes",        HAS_ARG | OPT_PERFILE | OPT_EXPERT |
1999                         OPT_OUTPUT,                                  { .func_arg = opt_data_frames },
2000         "set the number of data frames to record", "number" },
2001     { "benchmark",      OPT_BOOL | OPT_EXPERT,                       { &do_benchmark },
2002         "add timings for benchmarking" },
2003     { "timelimit",      HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_timelimit },
2004         "set max runtime in seconds", "limit" },
2005     { "dump",           OPT_BOOL | OPT_EXPERT,                       { &do_pkt_dump },
2006         "dump each input packet" },
2007     { "hex",            OPT_BOOL | OPT_EXPERT,                       { &do_hex_dump },
2008         "when dumping packets, also dump the payload" },
2009     { "re",             OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2010                         OPT_INPUT,                                   { .off = OFFSET(rate_emu) },
2011         "read input at native frame rate", "" },
2012     { "target",         HAS_ARG | OPT_PERFILE | OPT_OUTPUT,          { .func_arg = opt_target },
2013         "specify target file type (\"vcd\", \"svcd\", \"dvd\","
2014         " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2015     { "vsync",          HAS_ARG | OPT_EXPERT,                        { opt_vsync },
2016         "video sync method", "" },
2017     { "async",          HAS_ARG | OPT_INT | OPT_EXPERT,              { &audio_sync_method },
2018         "audio sync method", "" },
2019     { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,          { &audio_drift_threshold },
2020         "audio drift threshold", "threshold" },
2021     { "copyts",         OPT_BOOL | OPT_EXPERT,                       { &copy_ts },
2022         "copy timestamps" },
2023     { "copytb",         OPT_BOOL | OPT_EXPERT,                       { &copy_tb },
2024         "copy input stream time base when stream copying" },
2025     { "shortest",       OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2026                         OPT_OUTPUT,                                  { .off = OFFSET(shortest) },
2027         "finish encoding within shortest input" },
2028     { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,       { &dts_delta_threshold },
2029         "timestamp discontinuity delta threshold", "threshold" },
2030     { "xerror",         OPT_BOOL | OPT_EXPERT,                       { &exit_on_error },
2031         "exit on error", "error" },
2032     { "copyinkf",       OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2033                         OPT_OUTPUT,                                  { .off = OFFSET(copy_initial_nonkeyframes) },
2034         "copy initial non-keyframes" },
2035     { "frames",         OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
2036         "set the number of frames to record", "number" },
2037     { "tag",            OPT_STRING | HAS_ARG | OPT_SPEC |
2038                         OPT_EXPERT | OPT_OUTPUT,                     { .off = OFFSET(codec_tags) },
2039         "force codec tag/fourcc", "fourcc/tag" },
2040     { "q",              HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
2041                         OPT_SPEC | OPT_OUTPUT,                       { .off = OFFSET(qscale) },
2042         "use fixed quality scale (VBR)", "q" },
2043     { "qscale",         HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
2044                         OPT_SPEC | OPT_OUTPUT,                       { .off = OFFSET(qscale) },
2045         "use fixed quality scale (VBR)", "q" },
2046     { "filter",         HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
2047         "set stream filterchain", "filter_list" },
2048     { "filter_complex", HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_filter_complex },
2049         "create a complex filtergraph", "graph_description" },
2050     { "stats",          OPT_BOOL,                                    { &print_stats },
2051         "print progress report during encoding", },
2052     { "attach",         HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2053                         OPT_OUTPUT,                                  { .func_arg = opt_attach },
2054         "add an attachment to the output file", "filename" },
2055     { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
2056                          OPT_EXPERT | OPT_INPUT,                     { .off = OFFSET(dump_attachment) },
2057         "extract an attachment into a file", "filename" },
2058     { "cpuflags",       HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_cpuflags },
2059         "set CPU flags mask", "mask" },
2060
2061     /* video options */
2062     { "vframes",      OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_video_frames },
2063         "set the number of video frames to record", "number" },
2064     { "r",            OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC |
2065                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_rates) },
2066         "set frame rate (Hz value, fraction or abbreviation)", "rate" },
2067     { "s",            OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC |
2068                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_sizes) },
2069         "set frame size (WxH or abbreviation)", "size" },
2070     { "aspect",       OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC |
2071                       OPT_OUTPUT,                                                { .off = OFFSET(frame_aspect_ratios) },
2072         "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
2073     { "pix_fmt",      OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
2074                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_pix_fmts) },
2075         "set pixel format", "format" },
2076     { "vn",           OPT_VIDEO | OPT_BOOL  | OPT_OFFSET | OPT_OUTPUT,           { .off = OFFSET(video_disable) },
2077         "disable video" },
2078     { "vdt",          OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT ,               { &video_discard },
2079         "discard threshold", "n" },
2080     { "rc_override",  OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
2081                       OPT_OUTPUT,                                                { .off = OFFSET(rc_overrides) },
2082         "rate control override for specific intervals", "override" },
2083     { "vcodec",       OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_INPUT |
2084                       OPT_OUTPUT,                                                { .func_arg = opt_video_codec },
2085         "force video codec ('copy' to copy stream)", "codec" },
2086     { "pass",         OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT,     { .off = OFFSET(pass) },
2087         "select the pass number (1 or 2)", "n" },
2088     { "passlogfile",  OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
2089                       OPT_OUTPUT,                                                { .off = OFFSET(passlogfiles) },
2090         "select two pass log file name prefix", "prefix" },
2091 #if FF_API_DEINTERLACE
2092     { "deinterlace",  OPT_VIDEO | OPT_EXPERT ,                                   { .func_arg = opt_deinterlace },
2093         "this option is deprecated, use the yadif filter instead" },
2094 #endif
2095     { "vstats",       OPT_VIDEO | OPT_EXPERT ,                                   { &opt_vstats },
2096         "dump video coding statistics to file" },
2097     { "vstats_file",  OPT_VIDEO | HAS_ARG | OPT_EXPERT ,                         { opt_vstats_file },
2098         "dump video coding statistics to file", "file" },
2099     { "vf",           OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_video_filters },
2100         "video filters", "filter list" },
2101     { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
2102                       OPT_OUTPUT,                                                { .off = OFFSET(intra_matrices) },
2103         "specify intra matrix coeffs", "matrix" },
2104     { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
2105                       OPT_OUTPUT,                                                { .off = OFFSET(inter_matrices) },
2106         "specify inter matrix coeffs", "matrix" },
2107     { "top",          OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_INT| OPT_SPEC |
2108                       OPT_OUTPUT,                                                { .off = OFFSET(top_field_first) },
2109         "top=1/bottom=0/auto=-1 field first", "" },
2110     { "dc",           OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT ,               { &intra_dc_precision },
2111         "intra_dc_precision", "precision" },
2112     { "vtag",         OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_PERFILE |
2113                       OPT_OUTPUT,                                                { .func_arg = opt_video_tag },
2114         "force video tag/fourcc", "fourcc/tag" },
2115     { "qphist",       OPT_VIDEO | OPT_BOOL | OPT_EXPERT ,                        { &qp_hist },
2116         "show QP histogram" },
2117     { "force_fps",    OPT_VIDEO | OPT_BOOL | OPT_EXPERT  | OPT_SPEC |
2118                       OPT_OUTPUT,                                                { .off = OFFSET(force_fps) },
2119         "force the selected framerate, disable the best supported framerate selection" },
2120     { "streamid",     OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2121                       OPT_OUTPUT,                                                { .func_arg = opt_streamid },
2122         "set the value of an outfile streamid", "streamIndex:value" },
2123     { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2124                           OPT_SPEC | OPT_OUTPUT,                                 { .off = OFFSET(forced_key_frames) },
2125         "force key frames at specified timestamps", "timestamps" },
2126
2127     /* audio options */
2128     { "aframes",        OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_frames },
2129         "set the number of audio frames to record", "number" },
2130     { "aq",             OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_qscale },
2131         "set audio quality (codec-specific)", "quality", },
2132     { "ar",             OPT_AUDIO | HAS_ARG  | OPT_INT | OPT_SPEC |
2133                         OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(audio_sample_rate) },
2134         "set audio sampling rate (in Hz)", "rate" },
2135     { "ac",             OPT_AUDIO | HAS_ARG  | OPT_INT | OPT_SPEC |
2136                         OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(audio_channels) },
2137         "set number of audio channels", "channels" },
2138     { "an",             OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_OUTPUT,            { .off = OFFSET(audio_disable) },
2139         "disable audio" },
2140     { "acodec",         OPT_AUDIO | HAS_ARG  | OPT_PERFILE |
2141                         OPT_INPUT | OPT_OUTPUT,                                    { .func_arg = opt_audio_codec },
2142         "force audio codec ('copy' to copy stream)", "codec" },
2143     { "atag",           OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_PERFILE |
2144                         OPT_OUTPUT,                                                { .func_arg = opt_audio_tag },
2145         "force audio tag/fourcc", "fourcc/tag" },
2146     { "vol",            OPT_AUDIO | HAS_ARG  | OPT_INT,                            { &audio_volume },
2147         "change audio volume (256=normal)" , "volume" },
2148     { "sample_fmt",     OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_SPEC |
2149                         OPT_STRING | OPT_INPUT | OPT_OUTPUT,                       { .off = OFFSET(sample_fmts) },
2150         "set sample format", "format" },
2151     { "channel_layout", OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_PERFILE |
2152                         OPT_INPUT | OPT_OUTPUT,                                    { .func_arg = opt_channel_layout },
2153         "set channel layout", "layout" },
2154     { "af",             OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_filters },
2155         "audio filters", "filter list" },
2156
2157     /* subtitle options */
2158     { "sn",     OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
2159         "disable subtitle" },
2160     { "scodec", OPT_SUBTITLE | HAS_ARG  | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
2161         "force subtitle codec ('copy' to copy stream)", "codec" },
2162     { "stag",   OPT_SUBTITLE | HAS_ARG  | OPT_EXPERT  | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_subtitle_tag }
2163         , "force subtitle tag/fourcc", "fourcc/tag" },
2164
2165     /* grab options */
2166     { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
2167
2168     /* muxer options */
2169     { "muxdelay",   OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
2170         "set the maximum demux-decode delay", "seconds" },
2171     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
2172         "set the initial demux-decode delay", "seconds" },
2173
2174     { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
2175         "A comma-separated list of bitstream filters", "bitstream_filters" },
2176
2177     /* data codec support */
2178     { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
2179         "force data codec ('copy' to copy stream)", "codec" },
2180
2181     { NULL, },
2182 };