avconv: fix a typo
[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     InputFile *f;
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(&o->g->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(&o->g->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(&o->g->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(&o->g->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(&o->g->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, &o->g->format_opts);
614     if (err < 0) {
615         print_error(filename, err);
616         exit(1);
617     }
618     assert_avoptions(o->g->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, o->g->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     GROW_ARRAY(input_files, nb_input_files);
658     f = av_mallocz(sizeof(*f));
659     if (!f)
660         exit(1);
661     input_files[nb_input_files - 1] = f;
662
663     f->ctx        = ic;
664     f->ist_index  = nb_input_streams - ic->nb_streams;
665     f->ts_offset  = o->input_ts_offset - (copy_ts ? 0 : timestamp);
666     f->nb_streams = ic->nb_streams;
667     f->rate_emu   = o->rate_emu;
668
669     for (i = 0; i < o->nb_dump_attachment; i++) {
670         int j;
671
672         for (j = 0; j < ic->nb_streams; j++) {
673             AVStream *st = ic->streams[j];
674
675             if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
676                 dump_attachment(st, o->dump_attachment[i].u.str);
677         }
678     }
679
680     for (i = 0; i < orig_nb_streams; i++)
681         av_dict_free(&opts[i]);
682     av_freep(&opts);
683
684     return 0;
685 }
686
687 static uint8_t *get_line(AVIOContext *s)
688 {
689     AVIOContext *line;
690     uint8_t *buf;
691     char c;
692
693     if (avio_open_dyn_buf(&line) < 0) {
694         av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
695         exit(1);
696     }
697
698     while ((c = avio_r8(s)) && c != '\n')
699         avio_w8(line, c);
700     avio_w8(line, 0);
701     avio_close_dyn_buf(line, &buf);
702
703     return buf;
704 }
705
706 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
707 {
708     int i, ret = 1;
709     char filename[1000];
710     const char *base[3] = { getenv("AVCONV_DATADIR"),
711                             getenv("HOME"),
712                             AVCONV_DATADIR,
713                             };
714
715     for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
716         if (!base[i])
717             continue;
718         if (codec_name) {
719             snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
720                      i != 1 ? "" : "/.avconv", codec_name, preset_name);
721             ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
722         }
723         if (ret) {
724             snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
725                      i != 1 ? "" : "/.avconv", preset_name);
726             ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
727         }
728     }
729     return ret;
730 }
731
732 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
733 {
734     char *codec_name = NULL;
735
736     MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
737     if (!codec_name) {
738         ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
739                                                   NULL, ost->st->codec->codec_type);
740         ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
741     } else if (!strcmp(codec_name, "copy"))
742         ost->stream_copy = 1;
743     else {
744         ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
745         ost->st->codec->codec_id = ost->enc->id;
746     }
747 }
748
749 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type)
750 {
751     OutputStream *ost;
752     AVStream *st = avformat_new_stream(oc, NULL);
753     int idx      = oc->nb_streams - 1, ret = 0;
754     char *bsf = NULL, *next, *codec_tag = NULL;
755     AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
756     double qscale = -1;
757
758     if (!st) {
759         av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
760         exit(1);
761     }
762
763     if (oc->nb_streams - 1 < o->nb_streamid_map)
764         st->id = o->streamid_map[oc->nb_streams - 1];
765
766     GROW_ARRAY(output_streams, nb_output_streams);
767     if (!(ost = av_mallocz(sizeof(*ost))))
768         exit(1);
769     output_streams[nb_output_streams - 1] = ost;
770
771     ost->file_index = nb_output_files;
772     ost->index      = idx;
773     ost->st         = st;
774     st->codec->codec_type = type;
775     choose_encoder(o, oc, ost);
776     if (ost->enc) {
777         AVIOContext *s = NULL;
778         char *buf = NULL, *arg = NULL, *preset = NULL;
779
780         ost->opts  = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
781
782         MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
783         if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
784             do  {
785                 buf = get_line(s);
786                 if (!buf[0] || buf[0] == '#') {
787                     av_free(buf);
788                     continue;
789                 }
790                 if (!(arg = strchr(buf, '='))) {
791                     av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
792                     exit(1);
793                 }
794                 *arg++ = 0;
795                 av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
796                 av_free(buf);
797             } while (!s->eof_reached);
798             avio_close(s);
799         }
800         if (ret) {
801             av_log(NULL, AV_LOG_FATAL,
802                    "Preset %s specified for stream %d:%d, but could not be opened.\n",
803                    preset, ost->file_index, ost->index);
804             exit(1);
805         }
806     } else {
807         ost->opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
808     }
809
810     avcodec_get_context_defaults3(st->codec, ost->enc);
811     st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
812
813     ost->max_frames = INT64_MAX;
814     MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
815
816     MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
817     while (bsf) {
818         if (next = strchr(bsf, ','))
819             *next++ = 0;
820         if (!(bsfc = av_bitstream_filter_init(bsf))) {
821             av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
822             exit(1);
823         }
824         if (bsfc_prev)
825             bsfc_prev->next = bsfc;
826         else
827             ost->bitstream_filters = bsfc;
828
829         bsfc_prev = bsfc;
830         bsf       = next;
831     }
832
833     MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
834     if (codec_tag) {
835         uint32_t tag = strtol(codec_tag, &next, 0);
836         if (*next)
837             tag = AV_RL32(codec_tag);
838         st->codec->codec_tag = tag;
839     }
840
841     MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
842     if (qscale >= 0) {
843         st->codec->flags |= CODEC_FLAG_QSCALE;
844         st->codec->global_quality = FF_QP2LAMBDA * qscale;
845     }
846
847     if (oc->oformat->flags & AVFMT_GLOBALHEADER)
848         st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
849
850     av_opt_get_int(o->g->sws_opts, "sws_flags", 0, &ost->sws_flags);
851
852     av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
853
854     ost->pix_fmts[0] = ost->pix_fmts[1] = AV_PIX_FMT_NONE;
855
856     return ost;
857 }
858
859 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
860 {
861     int i;
862     const char *p = str;
863     for (i = 0;; i++) {
864         dest[i] = atoi(p);
865         if (i == 63)
866             break;
867         p = strchr(p, ',');
868         if (!p) {
869             av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
870             exit(1);
871         }
872         p++;
873     }
874 }
875
876 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc)
877 {
878     AVStream *st;
879     OutputStream *ost;
880     AVCodecContext *video_enc;
881
882     ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO);
883     st  = ost->st;
884     video_enc = st->codec;
885
886     if (!ost->stream_copy) {
887         const char *p = NULL;
888         char *frame_rate = NULL, *frame_size = NULL;
889         char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
890         char *intra_matrix = NULL, *inter_matrix = NULL;
891         const char *filters = "null";
892         int do_pass = 0;
893         int i;
894
895         MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
896         if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
897             av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
898             exit(1);
899         }
900
901         MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
902         if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
903             av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
904             exit(1);
905         }
906
907         MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
908         if (frame_aspect_ratio)
909             ost->frame_aspect_ratio = parse_frame_aspect_ratio(frame_aspect_ratio);
910
911         MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
912         if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
913             av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
914             exit(1);
915         }
916         st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
917
918         MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
919         if (intra_matrix) {
920             if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
921                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
922                 exit(1);
923             }
924             parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
925         }
926         MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
927         if (inter_matrix) {
928             if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
929                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
930                 exit(1);
931             }
932             parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
933         }
934
935         MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
936         for (i = 0; p; i++) {
937             int start, end, q;
938             int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
939             if (e != 3) {
940                 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
941                 exit(1);
942             }
943             video_enc->rc_override =
944                 av_realloc(video_enc->rc_override,
945                            sizeof(RcOverride) * (i + 1));
946             video_enc->rc_override[i].start_frame = start;
947             video_enc->rc_override[i].end_frame   = end;
948             if (q > 0) {
949                 video_enc->rc_override[i].qscale         = q;
950                 video_enc->rc_override[i].quality_factor = 1.0;
951             }
952             else {
953                 video_enc->rc_override[i].qscale         = 0;
954                 video_enc->rc_override[i].quality_factor = -q/100.0;
955             }
956             p = strchr(p, '/');
957             if (p) p++;
958         }
959         video_enc->rc_override_count = i;
960         video_enc->intra_dc_precision = intra_dc_precision - 8;
961
962         /* two pass mode */
963         MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
964         if (do_pass) {
965             if (do_pass == 1) {
966                 video_enc->flags |= CODEC_FLAG_PASS1;
967             } else {
968                 video_enc->flags |= CODEC_FLAG_PASS2;
969             }
970         }
971
972         MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
973         if (ost->logfile_prefix &&
974             !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
975             exit(1);
976
977         MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
978         if (ost->forced_keyframes)
979             ost->forced_keyframes = av_strdup(ost->forced_keyframes);
980
981         MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
982
983         ost->top_field_first = -1;
984         MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
985
986         MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
987         ost->avfilter = av_strdup(filters);
988     } else {
989         MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
990     }
991
992     return ost;
993 }
994
995 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc)
996 {
997     AVStream *st;
998     OutputStream *ost;
999     AVCodecContext *audio_enc;
1000
1001     ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO);
1002     st  = ost->st;
1003
1004     audio_enc = st->codec;
1005     audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1006
1007     if (!ost->stream_copy) {
1008         char *sample_fmt = NULL;
1009         const char *filters = "anull";
1010
1011         MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1012
1013         MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1014         if (sample_fmt &&
1015             (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1016             av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1017             exit(1);
1018         }
1019
1020         MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1021
1022         MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
1023         ost->avfilter = av_strdup(filters);
1024     }
1025
1026     return ost;
1027 }
1028
1029 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc)
1030 {
1031     OutputStream *ost;
1032
1033     ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA);
1034     if (!ost->stream_copy) {
1035         av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1036         exit(1);
1037     }
1038
1039     return ost;
1040 }
1041
1042 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc)
1043 {
1044     OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT);
1045     ost->stream_copy = 1;
1046     return ost;
1047 }
1048
1049 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc)
1050 {
1051     AVStream *st;
1052     OutputStream *ost;
1053     AVCodecContext *subtitle_enc;
1054
1055     ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE);
1056     st  = ost->st;
1057     subtitle_enc = st->codec;
1058
1059     subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1060
1061     return ost;
1062 }
1063
1064 /* arg format is "output-stream-index:streamid-value". */
1065 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1066 {
1067     OptionsContext *o = optctx;
1068     int idx;
1069     char *p;
1070     char idx_str[16];
1071
1072     av_strlcpy(idx_str, arg, sizeof(idx_str));
1073     p = strchr(idx_str, ':');
1074     if (!p) {
1075         av_log(NULL, AV_LOG_FATAL,
1076                "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1077                arg, opt);
1078         exit(1);
1079     }
1080     *p++ = '\0';
1081     idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, INT_MAX);
1082     o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1083     o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1084     return 0;
1085 }
1086
1087 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1088 {
1089     AVFormatContext *is = ifile->ctx;
1090     AVFormatContext *os = ofile->ctx;
1091     AVChapter **tmp;
1092     int i;
1093
1094     tmp = av_realloc(os->chapters, sizeof(*os->chapters) * (is->nb_chapters + os->nb_chapters));
1095     if (!tmp)
1096         return AVERROR(ENOMEM);
1097     os->chapters = tmp;
1098
1099     for (i = 0; i < is->nb_chapters; i++) {
1100         AVChapter *in_ch = is->chapters[i], *out_ch;
1101         int64_t ts_off   = av_rescale_q(ofile->start_time - ifile->ts_offset,
1102                                        AV_TIME_BASE_Q, in_ch->time_base);
1103         int64_t rt       = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1104                            av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1105
1106
1107         if (in_ch->end < ts_off)
1108             continue;
1109         if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1110             break;
1111
1112         out_ch = av_mallocz(sizeof(AVChapter));
1113         if (!out_ch)
1114             return AVERROR(ENOMEM);
1115
1116         out_ch->id        = in_ch->id;
1117         out_ch->time_base = in_ch->time_base;
1118         out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
1119         out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
1120
1121         if (copy_metadata)
1122             av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1123
1124         os->chapters[os->nb_chapters++] = out_ch;
1125     }
1126     return 0;
1127 }
1128
1129 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1130                                AVFormatContext *oc)
1131 {
1132     OutputStream *ost;
1133
1134     switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1135                                   ofilter->out_tmp->pad_idx)) {
1136     case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
1137     case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
1138     default:
1139         av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1140                "currently.\n");
1141         exit(1);
1142     }
1143
1144     ost->source_index = -1;
1145     ost->filter       = ofilter;
1146
1147     ofilter->ost      = ost;
1148
1149     if (ost->stream_copy) {
1150         av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1151                "which is fed from a complex filtergraph. Filtering and streamcopy "
1152                "cannot be used together.\n", ost->file_index, ost->index);
1153         exit(1);
1154     }
1155
1156     if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
1157         av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
1158         exit(1);
1159     }
1160     avfilter_inout_free(&ofilter->out_tmp);
1161 }
1162
1163 static int configure_complex_filters(void)
1164 {
1165     int i, ret = 0;
1166
1167     for (i = 0; i < nb_filtergraphs; i++)
1168         if (!filtergraphs[i]->graph &&
1169             (ret = configure_filtergraph(filtergraphs[i])) < 0)
1170             return ret;
1171     return 0;
1172 }
1173
1174 static int open_output_file(OptionsContext *o, const char *filename)
1175 {
1176     AVFormatContext *oc;
1177     int i, j, err;
1178     AVOutputFormat *file_oformat;
1179     OutputFile *of;
1180     OutputStream *ost;
1181     InputStream  *ist;
1182
1183     if (configure_complex_filters() < 0) {
1184         av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
1185         exit(1);
1186     }
1187
1188     if (!strcmp(filename, "-"))
1189         filename = "pipe:";
1190
1191     oc = avformat_alloc_context();
1192     if (!oc) {
1193         print_error(filename, AVERROR(ENOMEM));
1194         exit(1);
1195     }
1196
1197     if (o->format) {
1198         file_oformat = av_guess_format(o->format, NULL, NULL);
1199         if (!file_oformat) {
1200             av_log(NULL, AV_LOG_FATAL, "Requested output format '%s' is not a suitable output format\n", o->format);
1201             exit(1);
1202         }
1203     } else {
1204         file_oformat = av_guess_format(NULL, filename, NULL);
1205         if (!file_oformat) {
1206             av_log(NULL, AV_LOG_FATAL, "Unable to find a suitable output format for '%s'\n",
1207                    filename);
1208             exit(1);
1209         }
1210     }
1211
1212     oc->oformat = file_oformat;
1213     oc->interrupt_callback = int_cb;
1214     av_strlcpy(oc->filename, filename, sizeof(oc->filename));
1215
1216     /* create streams for all unlabeled output pads */
1217     for (i = 0; i < nb_filtergraphs; i++) {
1218         FilterGraph *fg = filtergraphs[i];
1219         for (j = 0; j < fg->nb_outputs; j++) {
1220             OutputFilter *ofilter = fg->outputs[j];
1221
1222             if (!ofilter->out_tmp || ofilter->out_tmp->name)
1223                 continue;
1224
1225             switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1226                                           ofilter->out_tmp->pad_idx)) {
1227             case AVMEDIA_TYPE_VIDEO:    o->video_disable    = 1; break;
1228             case AVMEDIA_TYPE_AUDIO:    o->audio_disable    = 1; break;
1229             case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1230             }
1231             init_output_filter(ofilter, o, oc);
1232         }
1233     }
1234
1235     if (!o->nb_stream_maps) {
1236         /* pick the "best" stream of each type */
1237 #define NEW_STREAM(type, index)\
1238         if (index >= 0) {\
1239             ost = new_ ## type ## _stream(o, oc);\
1240             ost->source_index = index;\
1241             ost->sync_ist     = input_streams[index];\
1242             input_streams[index]->discard = 0;\
1243             input_streams[index]->st->discard = AVDISCARD_NONE;\
1244         }
1245
1246         /* video: highest resolution */
1247         if (!o->video_disable && oc->oformat->video_codec != AV_CODEC_ID_NONE) {
1248             int area = 0, idx = -1;
1249             for (i = 0; i < nb_input_streams; i++) {
1250                 ist = input_streams[i];
1251                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1252                     ist->st->codec->width * ist->st->codec->height > area) {
1253                     area = ist->st->codec->width * ist->st->codec->height;
1254                     idx = i;
1255                 }
1256             }
1257             NEW_STREAM(video, idx);
1258         }
1259
1260         /* audio: most channels */
1261         if (!o->audio_disable && oc->oformat->audio_codec != AV_CODEC_ID_NONE) {
1262             int channels = 0, idx = -1;
1263             for (i = 0; i < nb_input_streams; i++) {
1264                 ist = input_streams[i];
1265                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1266                     ist->st->codec->channels > channels) {
1267                     channels = ist->st->codec->channels;
1268                     idx = i;
1269                 }
1270             }
1271             NEW_STREAM(audio, idx);
1272         }
1273
1274         /* subtitles: pick first */
1275         if (!o->subtitle_disable && oc->oformat->subtitle_codec != AV_CODEC_ID_NONE) {
1276             for (i = 0; i < nb_input_streams; i++)
1277                 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1278                     NEW_STREAM(subtitle, i);
1279                     break;
1280                 }
1281         }
1282         /* do something with data? */
1283     } else {
1284         for (i = 0; i < o->nb_stream_maps; i++) {
1285             StreamMap *map = &o->stream_maps[i];
1286
1287             if (map->disabled)
1288                 continue;
1289
1290             if (map->linklabel) {
1291                 FilterGraph *fg;
1292                 OutputFilter *ofilter = NULL;
1293                 int j, k;
1294
1295                 for (j = 0; j < nb_filtergraphs; j++) {
1296                     fg = filtergraphs[j];
1297                     for (k = 0; k < fg->nb_outputs; k++) {
1298                         AVFilterInOut *out = fg->outputs[k]->out_tmp;
1299                         if (out && !strcmp(out->name, map->linklabel)) {
1300                             ofilter = fg->outputs[k];
1301                             goto loop_end;
1302                         }
1303                     }
1304                 }
1305 loop_end:
1306                 if (!ofilter) {
1307                     av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1308                            "in any defined filter graph.\n", map->linklabel);
1309                     exit(1);
1310                 }
1311                 init_output_filter(ofilter, o, oc);
1312             } else {
1313                 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
1314                 switch (ist->st->codec->codec_type) {
1315                 case AVMEDIA_TYPE_VIDEO:    ost = new_video_stream(o, oc);    break;
1316                 case AVMEDIA_TYPE_AUDIO:    ost = new_audio_stream(o, oc);    break;
1317                 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(o, oc); break;
1318                 case AVMEDIA_TYPE_DATA:     ost = new_data_stream(o, oc);     break;
1319                 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc); break;
1320                 default:
1321                     av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
1322                            map->file_index, map->stream_index);
1323                     exit(1);
1324                 }
1325
1326                 ost->source_index = input_files[map->file_index]->ist_index + map->stream_index;
1327                 ost->sync_ist     = input_streams[input_files[map->sync_file_index]->ist_index +
1328                                                map->sync_stream_index];
1329                 ist->discard = 0;
1330                 ist->st->discard = AVDISCARD_NONE;
1331             }
1332         }
1333     }
1334
1335     /* handle attached files */
1336     for (i = 0; i < o->nb_attachments; i++) {
1337         AVIOContext *pb;
1338         uint8_t *attachment;
1339         const char *p;
1340         int64_t len;
1341
1342         if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
1343             av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
1344                    o->attachments[i]);
1345             exit(1);
1346         }
1347         if ((len = avio_size(pb)) <= 0) {
1348             av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
1349                    o->attachments[i]);
1350             exit(1);
1351         }
1352         if (!(attachment = av_malloc(len))) {
1353             av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
1354                    o->attachments[i]);
1355             exit(1);
1356         }
1357         avio_read(pb, attachment, len);
1358
1359         ost = new_attachment_stream(o, oc);
1360         ost->stream_copy               = 0;
1361         ost->source_index              = -1;
1362         ost->attachment_filename       = o->attachments[i];
1363         ost->st->codec->extradata      = attachment;
1364         ost->st->codec->extradata_size = len;
1365
1366         p = strrchr(o->attachments[i], '/');
1367         av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
1368         avio_close(pb);
1369     }
1370
1371     GROW_ARRAY(output_files, nb_output_files);
1372     of = av_mallocz(sizeof(*of));
1373     if (!of)
1374         exit(1);
1375     output_files[nb_output_files - 1] = of;
1376
1377     of->ctx            = oc;
1378     of->ost_index      = nb_output_streams - oc->nb_streams;
1379     of->recording_time = o->recording_time;
1380     if (o->recording_time != INT64_MAX)
1381         oc->duration = o->recording_time;
1382     of->start_time     = o->start_time;
1383     of->limit_filesize = o->limit_filesize;
1384     of->shortest       = o->shortest;
1385     av_dict_copy(&of->opts, o->g->format_opts, 0);
1386
1387     /* check filename in case of an image number is expected */
1388     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
1389         if (!av_filename_number_test(oc->filename)) {
1390             print_error(oc->filename, AVERROR(EINVAL));
1391             exit(1);
1392         }
1393     }
1394
1395     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
1396         /* test if it already exists to avoid losing precious files */
1397         assert_file_overwrite(filename);
1398
1399         /* open the file */
1400         if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
1401                               &oc->interrupt_callback,
1402                               &of->opts)) < 0) {
1403             print_error(filename, err);
1404             exit(1);
1405         }
1406     }
1407
1408     if (o->mux_preload) {
1409         uint8_t buf[64];
1410         snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
1411         av_dict_set(&of->opts, "preload", buf, 0);
1412     }
1413     oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
1414     oc->flags |= AVFMT_FLAG_NONBLOCK;
1415
1416     /* copy metadata */
1417     for (i = 0; i < o->nb_metadata_map; i++) {
1418         char *p;
1419         int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
1420
1421         if (in_file_index >= nb_input_files) {
1422             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
1423             exit(1);
1424         }
1425         copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
1426                       in_file_index >= 0 ?
1427                       input_files[in_file_index]->ctx : NULL, o);
1428     }
1429
1430     /* copy chapters */
1431     if (o->chapters_input_file >= nb_input_files) {
1432         if (o->chapters_input_file == INT_MAX) {
1433             /* copy chapters from the first input file that has them*/
1434             o->chapters_input_file = -1;
1435             for (i = 0; i < nb_input_files; i++)
1436                 if (input_files[i]->ctx->nb_chapters) {
1437                     o->chapters_input_file = i;
1438                     break;
1439                 }
1440         } else {
1441             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
1442                    o->chapters_input_file);
1443             exit(1);
1444         }
1445     }
1446     if (o->chapters_input_file >= 0)
1447         copy_chapters(input_files[o->chapters_input_file], of,
1448                       !o->metadata_chapters_manual);
1449
1450     /* copy global metadata by default */
1451     if (!o->metadata_global_manual && nb_input_files)
1452         av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
1453                      AV_DICT_DONT_OVERWRITE);
1454     if (!o->metadata_streams_manual)
1455         for (i = of->ost_index; i < nb_output_streams; i++) {
1456             InputStream *ist;
1457             if (output_streams[i]->source_index < 0)         /* this is true e.g. for attached files */
1458                 continue;
1459             ist = input_streams[output_streams[i]->source_index];
1460             av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
1461         }
1462
1463     /* process manually set metadata */
1464     for (i = 0; i < o->nb_metadata; i++) {
1465         AVDictionary **m;
1466         char type, *val;
1467         const char *stream_spec;
1468         int index = 0, j, ret;
1469
1470         val = strchr(o->metadata[i].u.str, '=');
1471         if (!val) {
1472             av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
1473                    o->metadata[i].u.str);
1474             exit(1);
1475         }
1476         *val++ = 0;
1477
1478         parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
1479         if (type == 's') {
1480             for (j = 0; j < oc->nb_streams; j++) {
1481                 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
1482                     av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
1483                 } else if (ret < 0)
1484                     exit(1);
1485             }
1486         }
1487         else {
1488             switch (type) {
1489             case 'g':
1490                 m = &oc->metadata;
1491                 break;
1492             case 'c':
1493                 if (index < 0 || index >= oc->nb_chapters) {
1494                     av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
1495                     exit(1);
1496                 }
1497                 m = &oc->chapters[index]->metadata;
1498                 break;
1499             default:
1500                 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
1501                 exit(1);
1502             }
1503             av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
1504         }
1505     }
1506
1507     return 0;
1508 }
1509
1510 static int opt_target(void *optctx, const char *opt, const char *arg)
1511 {
1512     OptionsContext *o = optctx;
1513     enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
1514     static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
1515
1516     if (!strncmp(arg, "pal-", 4)) {
1517         norm = PAL;
1518         arg += 4;
1519     } else if (!strncmp(arg, "ntsc-", 5)) {
1520         norm = NTSC;
1521         arg += 5;
1522     } else if (!strncmp(arg, "film-", 5)) {
1523         norm = FILM;
1524         arg += 5;
1525     } else {
1526         /* Try to determine PAL/NTSC by peeking in the input files */
1527         if (nb_input_files) {
1528             int i, j, fr;
1529             for (j = 0; j < nb_input_files; j++) {
1530                 for (i = 0; i < input_files[j]->nb_streams; i++) {
1531                     AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
1532                     if (c->codec_type != AVMEDIA_TYPE_VIDEO)
1533                         continue;
1534                     fr = c->time_base.den * 1000 / c->time_base.num;
1535                     if (fr == 25000) {
1536                         norm = PAL;
1537                         break;
1538                     } else if ((fr == 29970) || (fr == 23976)) {
1539                         norm = NTSC;
1540                         break;
1541                     }
1542                 }
1543                 if (norm != UNKNOWN)
1544                     break;
1545             }
1546         }
1547         if (norm != UNKNOWN)
1548             av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
1549     }
1550
1551     if (norm == UNKNOWN) {
1552         av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
1553         av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
1554         av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
1555         exit(1);
1556     }
1557
1558     if (!strcmp(arg, "vcd")) {
1559         opt_video_codec(o, "c:v", "mpeg1video");
1560         opt_audio_codec(o, "c:a", "mp2");
1561         parse_option(o, "f", "vcd", options);
1562
1563         parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
1564         parse_option(o, "r", frame_rates[norm], options);
1565         opt_default(NULL, "g", norm == PAL ? "15" : "18");
1566
1567         opt_default(NULL, "b", "1150000");
1568         opt_default(NULL, "maxrate", "1150000");
1569         opt_default(NULL, "minrate", "1150000");
1570         opt_default(NULL, "bufsize", "327680"); // 40*1024*8;
1571
1572         opt_default(NULL, "b:a", "224000");
1573         parse_option(o, "ar", "44100", options);
1574         parse_option(o, "ac", "2", options);
1575
1576         opt_default(NULL, "packetsize", "2324");
1577         opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
1578
1579         /* We have to offset the PTS, so that it is consistent with the SCR.
1580            SCR starts at 36000, but the first two packs contain only padding
1581            and the first pack from the other stream, respectively, may also have
1582            been written before.
1583            So the real data starts at SCR 36000+3*1200. */
1584         o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
1585     } else if (!strcmp(arg, "svcd")) {
1586
1587         opt_video_codec(o, "c:v", "mpeg2video");
1588         opt_audio_codec(o, "c:a", "mp2");
1589         parse_option(o, "f", "svcd", options);
1590
1591         parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
1592         parse_option(o, "r", frame_rates[norm], options);
1593         opt_default(NULL, "g", norm == PAL ? "15" : "18");
1594
1595         opt_default(NULL, "b", "2040000");
1596         opt_default(NULL, "maxrate", "2516000");
1597         opt_default(NULL, "minrate", "0"); // 1145000;
1598         opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
1599         opt_default(NULL, "flags", "+scan_offset");
1600
1601
1602         opt_default(NULL, "b:a", "224000");
1603         parse_option(o, "ar", "44100", options);
1604
1605         opt_default(NULL, "packetsize", "2324");
1606
1607     } else if (!strcmp(arg, "dvd")) {
1608
1609         opt_video_codec(o, "c:v", "mpeg2video");
1610         opt_audio_codec(o, "c:a", "ac3");
1611         parse_option(o, "f", "dvd", options);
1612
1613         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1614         parse_option(o, "r", frame_rates[norm], options);
1615         opt_default(NULL, "g", norm == PAL ? "15" : "18");
1616
1617         opt_default(NULL, "b", "6000000");
1618         opt_default(NULL, "maxrate", "9000000");
1619         opt_default(NULL, "minrate", "0"); // 1500000;
1620         opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
1621
1622         opt_default(NULL, "packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
1623         opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
1624
1625         opt_default(NULL, "b:a", "448000");
1626         parse_option(o, "ar", "48000", options);
1627
1628     } else if (!strncmp(arg, "dv", 2)) {
1629
1630         parse_option(o, "f", "dv", options);
1631
1632         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1633         parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
1634                           norm == PAL ? "yuv420p" : "yuv411p", options);
1635         parse_option(o, "r", frame_rates[norm], options);
1636
1637         parse_option(o, "ar", "48000", options);
1638         parse_option(o, "ac", "2", options);
1639
1640     } else {
1641         av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
1642         return AVERROR(EINVAL);
1643     }
1644     return 0;
1645 }
1646
1647 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
1648 {
1649     av_free (vstats_filename);
1650     vstats_filename = av_strdup (arg);
1651     return 0;
1652 }
1653
1654 static int opt_vstats(void *optctx, const char *opt, const char *arg)
1655 {
1656     char filename[40];
1657     time_t today2 = time(NULL);
1658     struct tm *today = localtime(&today2);
1659
1660     snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
1661              today->tm_sec);
1662     return opt_vstats_file(NULL, opt, filename);
1663 }
1664
1665 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
1666 {
1667     OptionsContext *o = optctx;
1668     return parse_option(o, "frames:v", arg, options);
1669 }
1670
1671 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
1672 {
1673     OptionsContext *o = optctx;
1674     return parse_option(o, "frames:a", arg, options);
1675 }
1676
1677 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
1678 {
1679     OptionsContext *o = optctx;
1680     return parse_option(o, "frames:d", arg, options);
1681 }
1682
1683 static int opt_video_tag(void *optctx, const char *opt, const char *arg)
1684 {
1685     OptionsContext *o = optctx;
1686     return parse_option(o, "tag:v", arg, options);
1687 }
1688
1689 static int opt_audio_tag(void *optctx, const char *opt, const char *arg)
1690 {
1691     OptionsContext *o = optctx;
1692     return parse_option(o, "tag:a", arg, options);
1693 }
1694
1695 static int opt_subtitle_tag(void *optctx, const char *opt, const char *arg)
1696 {
1697     OptionsContext *o = optctx;
1698     return parse_option(o, "tag:s", arg, options);
1699 }
1700
1701 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
1702 {
1703     OptionsContext *o = optctx;
1704     return parse_option(o, "filter:v", arg, options);
1705 }
1706
1707 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
1708 {
1709     OptionsContext *o = optctx;
1710     return parse_option(o, "filter:a", arg, options);
1711 }
1712
1713 static int opt_vsync(void *optctx, const char *opt, const char *arg)
1714 {
1715     if      (!av_strcasecmp(arg, "cfr"))         video_sync_method = VSYNC_CFR;
1716     else if (!av_strcasecmp(arg, "vfr"))         video_sync_method = VSYNC_VFR;
1717     else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
1718
1719     if (video_sync_method == VSYNC_AUTO)
1720         video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
1721     return 0;
1722 }
1723
1724 #if FF_API_DEINTERLACE
1725 static int opt_deinterlace(void *optctx, const char *opt, const char *arg)
1726 {
1727     av_log(NULL, AV_LOG_WARNING, "-%s is deprecated, use -filter:v yadif instead\n", opt);
1728     do_deinterlace = 1;
1729     return 0;
1730 }
1731 #endif
1732
1733 int opt_cpuflags(void *optctx, const char *opt, const char *arg)
1734 {
1735     int flags = av_parse_cpu_flags(arg);
1736
1737     if (flags < 0)
1738         return flags;
1739
1740     av_set_cpu_flags_mask(flags);
1741     return 0;
1742 }
1743
1744 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
1745 {
1746     OptionsContext *o = optctx;
1747     char layout_str[32];
1748     char *stream_str;
1749     char *ac_str;
1750     int ret, channels, ac_str_size;
1751     uint64_t layout;
1752
1753     layout = av_get_channel_layout(arg);
1754     if (!layout) {
1755         av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
1756         return AVERROR(EINVAL);
1757     }
1758     snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
1759     ret = opt_default(NULL, opt, layout_str);
1760     if (ret < 0)
1761         return ret;
1762
1763     /* set 'ac' option based on channel layout */
1764     channels = av_get_channel_layout_nb_channels(layout);
1765     snprintf(layout_str, sizeof(layout_str), "%d", channels);
1766     stream_str = strchr(opt, ':');
1767     ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
1768     ac_str = av_mallocz(ac_str_size);
1769     if (!ac_str)
1770         return AVERROR(ENOMEM);
1771     av_strlcpy(ac_str, "ac", 3);
1772     if (stream_str)
1773         av_strlcat(ac_str, stream_str, ac_str_size);
1774     ret = parse_option(o, ac_str, layout_str, options);
1775     av_free(ac_str);
1776
1777     return ret;
1778 }
1779
1780 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
1781 {
1782     OptionsContext *o = optctx;
1783     return parse_option(o, "q:a", arg, options);
1784 }
1785
1786 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
1787 {
1788     GROW_ARRAY(filtergraphs, nb_filtergraphs);
1789     if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
1790         return AVERROR(ENOMEM);
1791     filtergraphs[nb_filtergraphs - 1]->index       = nb_filtergraphs - 1;
1792     filtergraphs[nb_filtergraphs - 1]->graph_desc = arg;
1793     return 0;
1794 }
1795
1796 void show_help_default(const char *opt, const char *arg)
1797 {
1798     /* per-file options have at least one of those set */
1799     const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
1800     int show_advanced = 0, show_avoptions = 0;
1801
1802     if (opt && *opt) {
1803         if (!strcmp(opt, "long"))
1804             show_advanced = 1;
1805         else if (!strcmp(opt, "full"))
1806             show_advanced = show_avoptions = 1;
1807         else
1808             av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
1809     }
1810
1811     show_usage();
1812
1813     printf("Getting help:\n"
1814            "    -h      -- print basic options\n"
1815            "    -h long -- print more options\n"
1816            "    -h full -- print all options (including all format and codec specific options, very long)\n"
1817            "    See man %s for detailed description of the options.\n"
1818            "\n", program_name);
1819
1820     show_help_options(options, "Print help / information / capabilities:",
1821                       OPT_EXIT, 0, 0);
1822
1823     show_help_options(options, "Global options (affect whole program "
1824                       "instead of just one file:",
1825                       0, per_file | OPT_EXIT | OPT_EXPERT, 0);
1826     if (show_advanced)
1827         show_help_options(options, "Advanced global options:", OPT_EXPERT,
1828                           per_file | OPT_EXIT, 0);
1829
1830     show_help_options(options, "Per-file main options:", 0,
1831                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
1832                       OPT_EXIT, per_file);
1833     if (show_advanced)
1834         show_help_options(options, "Advanced per-file options:",
1835                           OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
1836
1837     show_help_options(options, "Video options:",
1838                       OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
1839     if (show_advanced)
1840         show_help_options(options, "Advanced Video options:",
1841                           OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
1842
1843     show_help_options(options, "Audio options:",
1844                       OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
1845     if (show_advanced)
1846         show_help_options(options, "Advanced Audio options:",
1847                           OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
1848     show_help_options(options, "Subtitle options:",
1849                       OPT_SUBTITLE, 0, 0);
1850     printf("\n");
1851
1852     if (show_avoptions) {
1853         int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
1854         show_help_children(avcodec_get_class(), flags);
1855         show_help_children(avformat_get_class(), flags);
1856         show_help_children(sws_get_class(), flags);
1857     }
1858 }
1859
1860 void show_usage(void)
1861 {
1862     printf("Hyper fast Audio and Video encoder\n");
1863     printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
1864     printf("\n");
1865 }
1866
1867 enum OptGroup {
1868     GROUP_OUTFILE,
1869     GROUP_INFILE,
1870 };
1871
1872 static const OptionGroupDef groups[] = {
1873     [GROUP_OUTFILE] = { "output file",  NULL, OPT_OUTPUT },
1874     [GROUP_INFILE]  = { "input file",   "i",  OPT_INPUT },
1875 };
1876
1877 static int open_files(OptionGroupList *l, const char *inout,
1878                       int (*open_file)(OptionsContext*, const char*))
1879 {
1880     int i, ret;
1881
1882     for (i = 0; i < l->nb_groups; i++) {
1883         OptionGroup *g = &l->groups[i];
1884         OptionsContext o;
1885
1886         init_options(&o);
1887         o.g = g;
1888
1889         ret = parse_optgroup(&o, g);
1890         if (ret < 0) {
1891             av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
1892                    "%s.\n", inout, g->arg);
1893             return ret;
1894         }
1895
1896         av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
1897         ret = open_file(&o, g->arg);
1898         uninit_options(&o);
1899         if (ret < 0) {
1900             av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
1901                    inout, g->arg);
1902             return ret;
1903         }
1904         av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
1905     }
1906
1907     return 0;
1908 }
1909
1910 int avconv_parse_options(int argc, char **argv)
1911 {
1912     OptionParseContext octx;
1913     uint8_t error[128];
1914     int ret;
1915
1916     memset(&octx, 0, sizeof(octx));
1917
1918     /* split the commandline into an internal representation */
1919     ret = split_commandline(&octx, argc, argv, options, groups,
1920                             FF_ARRAY_ELEMS(groups));
1921     if (ret < 0) {
1922         av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
1923         goto fail;
1924     }
1925
1926     /* apply global options */
1927     ret = parse_optgroup(NULL, &octx.global_opts);
1928     if (ret < 0) {
1929         av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
1930         goto fail;
1931     }
1932
1933     /* open input files */
1934     ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
1935     if (ret < 0) {
1936         av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
1937         goto fail;
1938     }
1939
1940     /* open output files */
1941     ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
1942     if (ret < 0) {
1943         av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
1944         goto fail;
1945     }
1946
1947 fail:
1948     uninit_parse_context(&octx);
1949     if (ret < 0) {
1950         av_strerror(ret, error, sizeof(error));
1951         av_log(NULL, AV_LOG_FATAL, "%s\n", error);
1952     }
1953     return ret;
1954 }
1955
1956 #define OFFSET(x) offsetof(OptionsContext, x)
1957 const OptionDef options[] = {
1958     /* main options */
1959 #include "cmdutils_common_opts.h"
1960     { "f",              HAS_ARG | OPT_STRING | OPT_OFFSET |
1961                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(format) },
1962         "force format", "fmt" },
1963     { "y",              OPT_BOOL,                                    {              &file_overwrite },
1964         "overwrite output files" },
1965     { "c",              HAS_ARG | OPT_STRING | OPT_SPEC |
1966                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(codec_names) },
1967         "codec name", "codec" },
1968     { "codec",          HAS_ARG | OPT_STRING | OPT_SPEC |
1969                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(codec_names) },
1970         "codec name", "codec" },
1971     { "pre",            HAS_ARG | OPT_STRING | OPT_SPEC |
1972                         OPT_OUTPUT,                                  { .off       = OFFSET(presets) },
1973         "preset name", "preset" },
1974     { "map",            HAS_ARG | OPT_EXPERT | OPT_PERFILE |
1975                         OPT_OUTPUT,                                  { .func_arg = opt_map },
1976         "set input stream mapping",
1977         "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
1978     { "map_metadata",   HAS_ARG | OPT_STRING | OPT_SPEC |
1979                         OPT_OUTPUT,                                  { .off       = OFFSET(metadata_map) },
1980         "set metadata information of outfile from infile",
1981         "outfile[,metadata]:infile[,metadata]" },
1982     { "map_chapters",   HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
1983                         OPT_OUTPUT,                                  { .off = OFFSET(chapters_input_file) },
1984         "set chapters mapping", "input_file_index" },
1985     { "t",              HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(recording_time) },
1986         "record or transcode \"duration\" seconds of audio/video",
1987         "duration" },
1988     { "fs",             HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
1989         "set the limit file size in bytes", "limit_size" },
1990     { "ss",             HAS_ARG | OPT_TIME | OPT_OFFSET |
1991                         OPT_INPUT | OPT_OUTPUT,                      { .off = OFFSET(start_time) },
1992         "set the start time offset", "time_off" },
1993     { "itsoffset",      HAS_ARG | OPT_TIME | OPT_OFFSET |
1994                         OPT_EXPERT | OPT_INPUT,                      { .off = OFFSET(input_ts_offset) },
1995         "set the input ts offset", "time_off" },
1996     { "itsscale",       HAS_ARG | OPT_DOUBLE | OPT_SPEC |
1997                         OPT_EXPERT | OPT_INPUT,                      { .off = OFFSET(ts_scale) },
1998         "set the input ts scale", "scale" },
1999     { "metadata",       HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
2000         "add metadata", "string=string" },
2001     { "dframes",        HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2002                         OPT_OUTPUT,                                  { .func_arg = opt_data_frames },
2003         "set the number of data frames to record", "number" },
2004     { "benchmark",      OPT_BOOL | OPT_EXPERT,                       { &do_benchmark },
2005         "add timings for benchmarking" },
2006     { "timelimit",      HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_timelimit },
2007         "set max runtime in seconds", "limit" },
2008     { "dump",           OPT_BOOL | OPT_EXPERT,                       { &do_pkt_dump },
2009         "dump each input packet" },
2010     { "hex",            OPT_BOOL | OPT_EXPERT,                       { &do_hex_dump },
2011         "when dumping packets, also dump the payload" },
2012     { "re",             OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2013                         OPT_INPUT,                                   { .off = OFFSET(rate_emu) },
2014         "read input at native frame rate", "" },
2015     { "target",         HAS_ARG | OPT_PERFILE | OPT_OUTPUT,          { .func_arg = opt_target },
2016         "specify target file type (\"vcd\", \"svcd\", \"dvd\","
2017         " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2018     { "vsync",          HAS_ARG | OPT_EXPERT,                        { opt_vsync },
2019         "video sync method", "" },
2020     { "async",          HAS_ARG | OPT_INT | OPT_EXPERT,              { &audio_sync_method },
2021         "audio sync method", "" },
2022     { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,          { &audio_drift_threshold },
2023         "audio drift threshold", "threshold" },
2024     { "copyts",         OPT_BOOL | OPT_EXPERT,                       { &copy_ts },
2025         "copy timestamps" },
2026     { "copytb",         OPT_BOOL | OPT_EXPERT,                       { &copy_tb },
2027         "copy input stream time base when stream copying" },
2028     { "shortest",       OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2029                         OPT_OUTPUT,                                  { .off = OFFSET(shortest) },
2030         "finish encoding within shortest input" },
2031     { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,       { &dts_delta_threshold },
2032         "timestamp discontinuity delta threshold", "threshold" },
2033     { "xerror",         OPT_BOOL | OPT_EXPERT,                       { &exit_on_error },
2034         "exit on error", "error" },
2035     { "copyinkf",       OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2036                         OPT_OUTPUT,                                  { .off = OFFSET(copy_initial_nonkeyframes) },
2037         "copy initial non-keyframes" },
2038     { "frames",         OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
2039         "set the number of frames to record", "number" },
2040     { "tag",            OPT_STRING | HAS_ARG | OPT_SPEC |
2041                         OPT_EXPERT | OPT_OUTPUT,                     { .off = OFFSET(codec_tags) },
2042         "force codec tag/fourcc", "fourcc/tag" },
2043     { "q",              HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
2044                         OPT_SPEC | OPT_OUTPUT,                       { .off = OFFSET(qscale) },
2045         "use fixed quality scale (VBR)", "q" },
2046     { "qscale",         HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
2047                         OPT_SPEC | OPT_OUTPUT,                       { .off = OFFSET(qscale) },
2048         "use fixed quality scale (VBR)", "q" },
2049     { "filter",         HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
2050         "set stream filterchain", "filter_list" },
2051     { "filter_complex", HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_filter_complex },
2052         "create a complex filtergraph", "graph_description" },
2053     { "stats",          OPT_BOOL,                                    { &print_stats },
2054         "print progress report during encoding", },
2055     { "attach",         HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2056                         OPT_OUTPUT,                                  { .func_arg = opt_attach },
2057         "add an attachment to the output file", "filename" },
2058     { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
2059                          OPT_EXPERT | OPT_INPUT,                     { .off = OFFSET(dump_attachment) },
2060         "extract an attachment into a file", "filename" },
2061     { "cpuflags",       HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_cpuflags },
2062         "set CPU flags mask", "mask" },
2063
2064     /* video options */
2065     { "vframes",      OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_video_frames },
2066         "set the number of video frames to record", "number" },
2067     { "r",            OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC |
2068                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_rates) },
2069         "set frame rate (Hz value, fraction or abbreviation)", "rate" },
2070     { "s",            OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC |
2071                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_sizes) },
2072         "set frame size (WxH or abbreviation)", "size" },
2073     { "aspect",       OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC |
2074                       OPT_OUTPUT,                                                { .off = OFFSET(frame_aspect_ratios) },
2075         "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
2076     { "pix_fmt",      OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
2077                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_pix_fmts) },
2078         "set pixel format", "format" },
2079     { "vn",           OPT_VIDEO | OPT_BOOL  | OPT_OFFSET | OPT_OUTPUT,           { .off = OFFSET(video_disable) },
2080         "disable video" },
2081     { "vdt",          OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT ,               { &video_discard },
2082         "discard threshold", "n" },
2083     { "rc_override",  OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
2084                       OPT_OUTPUT,                                                { .off = OFFSET(rc_overrides) },
2085         "rate control override for specific intervals", "override" },
2086     { "vcodec",       OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_INPUT |
2087                       OPT_OUTPUT,                                                { .func_arg = opt_video_codec },
2088         "force video codec ('copy' to copy stream)", "codec" },
2089     { "pass",         OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT,     { .off = OFFSET(pass) },
2090         "select the pass number (1 or 2)", "n" },
2091     { "passlogfile",  OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
2092                       OPT_OUTPUT,                                                { .off = OFFSET(passlogfiles) },
2093         "select two pass log file name prefix", "prefix" },
2094 #if FF_API_DEINTERLACE
2095     { "deinterlace",  OPT_VIDEO | OPT_EXPERT ,                                   { .func_arg = opt_deinterlace },
2096         "this option is deprecated, use the yadif filter instead" },
2097 #endif
2098     { "vstats",       OPT_VIDEO | OPT_EXPERT ,                                   { &opt_vstats },
2099         "dump video coding statistics to file" },
2100     { "vstats_file",  OPT_VIDEO | HAS_ARG | OPT_EXPERT ,                         { opt_vstats_file },
2101         "dump video coding statistics to file", "file" },
2102     { "vf",           OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_video_filters },
2103         "video filters", "filter list" },
2104     { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
2105                       OPT_OUTPUT,                                                { .off = OFFSET(intra_matrices) },
2106         "specify intra matrix coeffs", "matrix" },
2107     { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
2108                       OPT_OUTPUT,                                                { .off = OFFSET(inter_matrices) },
2109         "specify inter matrix coeffs", "matrix" },
2110     { "top",          OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_INT| OPT_SPEC |
2111                       OPT_OUTPUT,                                                { .off = OFFSET(top_field_first) },
2112         "top=1/bottom=0/auto=-1 field first", "" },
2113     { "dc",           OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT ,               { &intra_dc_precision },
2114         "intra_dc_precision", "precision" },
2115     { "vtag",         OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_PERFILE |
2116                       OPT_OUTPUT,                                                { .func_arg = opt_video_tag },
2117         "force video tag/fourcc", "fourcc/tag" },
2118     { "qphist",       OPT_VIDEO | OPT_BOOL | OPT_EXPERT ,                        { &qp_hist },
2119         "show QP histogram" },
2120     { "force_fps",    OPT_VIDEO | OPT_BOOL | OPT_EXPERT  | OPT_SPEC |
2121                       OPT_OUTPUT,                                                { .off = OFFSET(force_fps) },
2122         "force the selected framerate, disable the best supported framerate selection" },
2123     { "streamid",     OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2124                       OPT_OUTPUT,                                                { .func_arg = opt_streamid },
2125         "set the value of an outfile streamid", "streamIndex:value" },
2126     { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2127                           OPT_SPEC | OPT_OUTPUT,                                 { .off = OFFSET(forced_key_frames) },
2128         "force key frames at specified timestamps", "timestamps" },
2129
2130     /* audio options */
2131     { "aframes",        OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_frames },
2132         "set the number of audio frames to record", "number" },
2133     { "aq",             OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_qscale },
2134         "set audio quality (codec-specific)", "quality", },
2135     { "ar",             OPT_AUDIO | HAS_ARG  | OPT_INT | OPT_SPEC |
2136                         OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(audio_sample_rate) },
2137         "set audio sampling rate (in Hz)", "rate" },
2138     { "ac",             OPT_AUDIO | HAS_ARG  | OPT_INT | OPT_SPEC |
2139                         OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(audio_channels) },
2140         "set number of audio channels", "channels" },
2141     { "an",             OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_OUTPUT,            { .off = OFFSET(audio_disable) },
2142         "disable audio" },
2143     { "acodec",         OPT_AUDIO | HAS_ARG  | OPT_PERFILE |
2144                         OPT_INPUT | OPT_OUTPUT,                                    { .func_arg = opt_audio_codec },
2145         "force audio codec ('copy' to copy stream)", "codec" },
2146     { "atag",           OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_PERFILE |
2147                         OPT_OUTPUT,                                                { .func_arg = opt_audio_tag },
2148         "force audio tag/fourcc", "fourcc/tag" },
2149     { "vol",            OPT_AUDIO | HAS_ARG  | OPT_INT,                            { &audio_volume },
2150         "change audio volume (256=normal)" , "volume" },
2151     { "sample_fmt",     OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_SPEC |
2152                         OPT_STRING | OPT_INPUT | OPT_OUTPUT,                       { .off = OFFSET(sample_fmts) },
2153         "set sample format", "format" },
2154     { "channel_layout", OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_PERFILE |
2155                         OPT_INPUT | OPT_OUTPUT,                                    { .func_arg = opt_channel_layout },
2156         "set channel layout", "layout" },
2157     { "af",             OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_filters },
2158         "audio filters", "filter list" },
2159
2160     /* subtitle options */
2161     { "sn",     OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
2162         "disable subtitle" },
2163     { "scodec", OPT_SUBTITLE | HAS_ARG  | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
2164         "force subtitle codec ('copy' to copy stream)", "codec" },
2165     { "stag",   OPT_SUBTITLE | HAS_ARG  | OPT_EXPERT  | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_subtitle_tag }
2166         , "force subtitle tag/fourcc", "fourcc/tag" },
2167
2168     /* grab options */
2169     { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
2170
2171     /* muxer options */
2172     { "muxdelay",   OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
2173         "set the maximum demux-decode delay", "seconds" },
2174     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
2175         "set the initial demux-decode delay", "seconds" },
2176
2177     { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
2178         "A comma-separated list of bitstream filters", "bitstream_filters" },
2179
2180     /* data codec support */
2181     { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
2182         "force data codec ('copy' to copy stream)", "codec" },
2183
2184     { NULL, },
2185 };