ffmpeg_opt: Remove support for specifying -t anywhere to set the duration
[ffmpeg.git] / ffmpeg_opt.c
1 /*
2  * ffmpeg option parsing
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg 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  * FFmpeg 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 FFmpeg; 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 "ffmpeg.h"
24 #include "cmdutils.h"
25
26 #include "libavformat/avformat.h"
27
28 #include "libavcodec/avcodec.h"
29
30 #include "libavfilter/avfilter.h"
31
32 #include "libavutil/avassert.h"
33 #include "libavutil/avstring.h"
34 #include "libavutil/avutil.h"
35 #include "libavutil/channel_layout.h"
36 #include "libavutil/intreadwrite.h"
37 #include "libavutil/fifo.h"
38 #include "libavutil/mathematics.h"
39 #include "libavutil/opt.h"
40 #include "libavutil/parseutils.h"
41 #include "libavutil/pixdesc.h"
42 #include "libavutil/pixfmt.h"
43
44 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
45 {\
46     int i, ret;\
47     for (i = 0; i < o->nb_ ## name; i++) {\
48         char *spec = o->name[i].specifier;\
49         if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
50             outvar = o->name[i].u.type;\
51         else if (ret < 0)\
52             exit_program(1);\
53     }\
54 }
55
56 #define MATCH_PER_TYPE_OPT(name, type, outvar, fmtctx, mediatype)\
57 {\
58     int i;\
59     for (i = 0; i < o->nb_ ## name; i++) {\
60         char *spec = o->name[i].specifier;\
61         if (!strcmp(spec, mediatype))\
62             outvar = o->name[i].u.type;\
63     }\
64 }
65 char *vstats_filename;
66
67 float audio_drift_threshold = 0.1;
68 float dts_delta_threshold   = 10;
69 float dts_error_threshold   = 3600*30;
70
71 int audio_volume      = 256;
72 int audio_sync_method = 0;
73 int video_sync_method = VSYNC_AUTO;
74 int do_deinterlace    = 0;
75 int do_benchmark      = 0;
76 int do_benchmark_all  = 0;
77 int do_hex_dump       = 0;
78 int do_pkt_dump       = 0;
79 int copy_ts           = 0;
80 int copy_tb           = -1;
81 int debug_ts          = 0;
82 int exit_on_error     = 0;
83 int print_stats       = -1;
84 int qp_hist           = 0;
85 int stdin_interaction = 1;
86 int frame_bits_per_raw_sample = 0;
87
88
89 static int intra_only         = 0;
90 static int file_overwrite     = 0;
91 static int no_file_overwrite  = 0;
92 static int video_discard      = 0;
93 static int intra_dc_precision = 8;
94 static int do_psnr            = 0;
95 static int input_sync;
96 static int override_ffserver  = 0;
97
98 static void uninit_options(OptionsContext *o)
99 {
100     const OptionDef *po = options;
101     int i;
102
103     /* all OPT_SPEC and OPT_STRING can be freed in generic way */
104     while (po->name) {
105         void *dst = (uint8_t*)o + po->u.off;
106
107         if (po->flags & OPT_SPEC) {
108             SpecifierOpt **so = dst;
109             int i, *count = (int*)(so + 1);
110             for (i = 0; i < *count; i++) {
111                 av_freep(&(*so)[i].specifier);
112                 if (po->flags & OPT_STRING)
113                     av_freep(&(*so)[i].u.str);
114             }
115             av_freep(so);
116             *count = 0;
117         } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
118             av_freep(dst);
119         po++;
120     }
121
122     for (i = 0; i < o->nb_stream_maps; i++)
123         av_freep(&o->stream_maps[i].linklabel);
124     av_freep(&o->stream_maps);
125     av_freep(&o->audio_channel_maps);
126     av_freep(&o->streamid_map);
127     av_freep(&o->attachments);
128 }
129
130 static void init_options(OptionsContext *o)
131 {
132     memset(o, 0, sizeof(*o));
133
134     o->stop_time = INT64_MAX;
135     o->mux_max_delay  = 0.7;
136     o->start_time     = AV_NOPTS_VALUE;
137     o->recording_time = INT64_MAX;
138     o->limit_filesize = UINT64_MAX;
139     o->chapters_input_file = INT_MAX;
140     o->accurate_seek  = 1;
141 }
142
143 /* return a copy of the input with the stream specifiers removed from the keys */
144 static AVDictionary *strip_specifiers(AVDictionary *dict)
145 {
146     AVDictionaryEntry *e = NULL;
147     AVDictionary    *ret = NULL;
148
149     while ((e = av_dict_get(dict, "", e, AV_DICT_IGNORE_SUFFIX))) {
150         char *p = strchr(e->key, ':');
151
152         if (p)
153             *p = 0;
154         av_dict_set(&ret, e->key, e->value, 0);
155         if (p)
156             *p = ':';
157     }
158     return ret;
159 }
160
161 static int opt_sameq(void *optctx, const char *opt, const char *arg)
162 {
163     av_log(NULL, AV_LOG_ERROR, "Option '%s' was removed. "
164            "If you are looking for an option to preserve the quality (which is not "
165            "what -%s was for), use -qscale 0 or an equivalent quality factor option.\n",
166            opt, opt);
167     return AVERROR(EINVAL);
168 }
169
170 static int opt_video_channel(void *optctx, const char *opt, const char *arg)
171 {
172     av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
173     return opt_default(optctx, "channel", arg);
174 }
175
176 static int opt_video_standard(void *optctx, const char *opt, const char *arg)
177 {
178     av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
179     return opt_default(optctx, "standard", arg);
180 }
181
182 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
183 {
184     OptionsContext *o = optctx;
185     return parse_option(o, "codec:a", arg, options);
186 }
187
188 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
189 {
190     OptionsContext *o = optctx;
191     return parse_option(o, "codec:v", arg, options);
192 }
193
194 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
195 {
196     OptionsContext *o = optctx;
197     return parse_option(o, "codec:s", arg, options);
198 }
199
200 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
201 {
202     OptionsContext *o = optctx;
203     return parse_option(o, "codec:d", arg, options);
204 }
205
206 static int opt_map(void *optctx, const char *opt, const char *arg)
207 {
208     OptionsContext *o = optctx;
209     StreamMap *m = NULL;
210     int i, negative = 0, file_idx;
211     int sync_file_idx = -1, sync_stream_idx = 0;
212     char *p, *sync;
213     char *map;
214
215     if (*arg == '-') {
216         negative = 1;
217         arg++;
218     }
219     map = av_strdup(arg);
220
221     /* parse sync stream first, just pick first matching stream */
222     if (sync = strchr(map, ',')) {
223         *sync = 0;
224         sync_file_idx = strtol(sync + 1, &sync, 0);
225         if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
226             av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
227             exit_program(1);
228         }
229         if (*sync)
230             sync++;
231         for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
232             if (check_stream_specifier(input_files[sync_file_idx]->ctx,
233                                        input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
234                 sync_stream_idx = i;
235                 break;
236             }
237         if (i == input_files[sync_file_idx]->nb_streams) {
238             av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
239                                        "match any streams.\n", arg);
240             exit_program(1);
241         }
242     }
243
244
245     if (map[0] == '[') {
246         /* this mapping refers to lavfi output */
247         const char *c = map + 1;
248         GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
249         m = &o->stream_maps[o->nb_stream_maps - 1];
250         m->linklabel = av_get_token(&c, "]");
251         if (!m->linklabel) {
252             av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
253             exit_program(1);
254         }
255     } else {
256         file_idx = strtol(map, &p, 0);
257         if (file_idx >= nb_input_files || file_idx < 0) {
258             av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
259             exit_program(1);
260         }
261         if (negative)
262             /* disable some already defined maps */
263             for (i = 0; i < o->nb_stream_maps; i++) {
264                 m = &o->stream_maps[i];
265                 if (file_idx == m->file_index &&
266                     check_stream_specifier(input_files[m->file_index]->ctx,
267                                            input_files[m->file_index]->ctx->streams[m->stream_index],
268                                            *p == ':' ? p + 1 : p) > 0)
269                     m->disabled = 1;
270             }
271         else
272             for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
273                 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
274                             *p == ':' ? p + 1 : p) <= 0)
275                     continue;
276                 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
277                 m = &o->stream_maps[o->nb_stream_maps - 1];
278
279                 m->file_index   = file_idx;
280                 m->stream_index = i;
281
282                 if (sync_file_idx >= 0) {
283                     m->sync_file_index   = sync_file_idx;
284                     m->sync_stream_index = sync_stream_idx;
285                 } else {
286                     m->sync_file_index   = file_idx;
287                     m->sync_stream_index = i;
288                 }
289             }
290     }
291
292     if (!m) {
293         av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
294         exit_program(1);
295     }
296
297     av_freep(&map);
298     return 0;
299 }
300
301 static int opt_attach(void *optctx, const char *opt, const char *arg)
302 {
303     OptionsContext *o = optctx;
304     GROW_ARRAY(o->attachments, o->nb_attachments);
305     o->attachments[o->nb_attachments - 1] = arg;
306     return 0;
307 }
308
309 static int opt_map_channel(void *optctx, const char *opt, const char *arg)
310 {
311     OptionsContext *o = optctx;
312     int n;
313     AVStream *st;
314     AudioChannelMap *m;
315
316     GROW_ARRAY(o->audio_channel_maps, o->nb_audio_channel_maps);
317     m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];
318
319     /* muted channel syntax */
320     n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
321     if ((n == 1 || n == 3) && m->channel_idx == -1) {
322         m->file_idx = m->stream_idx = -1;
323         if (n == 1)
324             m->ofile_idx = m->ostream_idx = -1;
325         return 0;
326     }
327
328     /* normal syntax */
329     n = sscanf(arg, "%d.%d.%d:%d.%d",
330                &m->file_idx,  &m->stream_idx, &m->channel_idx,
331                &m->ofile_idx, &m->ostream_idx);
332
333     if (n != 3 && n != 5) {
334         av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
335                "[file.stream.channel|-1][:syncfile:syncstream]\n");
336         exit_program(1);
337     }
338
339     if (n != 5) // only file.stream.channel specified
340         m->ofile_idx = m->ostream_idx = -1;
341
342     /* check input */
343     if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
344         av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
345                m->file_idx);
346         exit_program(1);
347     }
348     if (m->stream_idx < 0 ||
349         m->stream_idx >= input_files[m->file_idx]->nb_streams) {
350         av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
351                m->file_idx, m->stream_idx);
352         exit_program(1);
353     }
354     st = input_files[m->file_idx]->ctx->streams[m->stream_idx];
355     if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO) {
356         av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
357                m->file_idx, m->stream_idx);
358         exit_program(1);
359     }
360     if (m->channel_idx < 0 || m->channel_idx >= st->codec->channels) {
361         av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n",
362                m->file_idx, m->stream_idx, m->channel_idx);
363         exit_program(1);
364     }
365     return 0;
366 }
367
368 /**
369  * Parse a metadata specifier passed as 'arg' parameter.
370  * @param arg  metadata string to parse
371  * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
372  * @param index for type c/p, chapter/program index is written here
373  * @param stream_spec for type s, the stream specifier is written here
374  */
375 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
376 {
377     if (*arg) {
378         *type = *arg;
379         switch (*arg) {
380         case 'g':
381             break;
382         case 's':
383             if (*(++arg) && *arg != ':') {
384                 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
385                 exit_program(1);
386             }
387             *stream_spec = *arg == ':' ? arg + 1 : "";
388             break;
389         case 'c':
390         case 'p':
391             if (*(++arg) == ':')
392                 *index = strtol(++arg, NULL, 0);
393             break;
394         default:
395             av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
396             exit_program(1);
397         }
398     } else
399         *type = 'g';
400 }
401
402 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
403 {
404     AVDictionary **meta_in = NULL;
405     AVDictionary **meta_out = NULL;
406     int i, ret = 0;
407     char type_in, type_out;
408     const char *istream_spec = NULL, *ostream_spec = NULL;
409     int idx_in = 0, idx_out = 0;
410
411     parse_meta_type(inspec,  &type_in,  &idx_in,  &istream_spec);
412     parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
413
414     if (!ic) {
415         if (type_out == 'g' || !*outspec)
416             o->metadata_global_manual = 1;
417         if (type_out == 's' || !*outspec)
418             o->metadata_streams_manual = 1;
419         if (type_out == 'c' || !*outspec)
420             o->metadata_chapters_manual = 1;
421         return 0;
422     }
423
424     if (type_in == 'g' || type_out == 'g')
425         o->metadata_global_manual = 1;
426     if (type_in == 's' || type_out == 's')
427         o->metadata_streams_manual = 1;
428     if (type_in == 'c' || type_out == 'c')
429         o->metadata_chapters_manual = 1;
430
431     /* ic is NULL when just disabling automatic mappings */
432     if (!ic)
433         return 0;
434
435 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
436     if ((index) < 0 || (index) >= (nb_elems)) {\
437         av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
438                 (desc), (index));\
439         exit_program(1);\
440     }
441
442 #define SET_DICT(type, meta, context, index)\
443         switch (type) {\
444         case 'g':\
445             meta = &context->metadata;\
446             break;\
447         case 'c':\
448             METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
449             meta = &context->chapters[index]->metadata;\
450             break;\
451         case 'p':\
452             METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
453             meta = &context->programs[index]->metadata;\
454             break;\
455         case 's':\
456             break; /* handled separately below */ \
457         default: av_assert0(0);\
458         }\
459
460     SET_DICT(type_in, meta_in, ic, idx_in);
461     SET_DICT(type_out, meta_out, oc, idx_out);
462
463     /* for input streams choose first matching stream */
464     if (type_in == 's') {
465         for (i = 0; i < ic->nb_streams; i++) {
466             if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
467                 meta_in = &ic->streams[i]->metadata;
468                 break;
469             } else if (ret < 0)
470                 exit_program(1);
471         }
472         if (!meta_in) {
473             av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match  any streams.\n", istream_spec);
474             exit_program(1);
475         }
476     }
477
478     if (type_out == 's') {
479         for (i = 0; i < oc->nb_streams; i++) {
480             if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
481                 meta_out = &oc->streams[i]->metadata;
482                 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
483             } else if (ret < 0)
484                 exit_program(1);
485         }
486     } else
487         av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
488
489     return 0;
490 }
491
492 static int opt_recording_timestamp(void *optctx, const char *opt, const char *arg)
493 {
494     OptionsContext *o = optctx;
495     char buf[128];
496     int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
497     struct tm time = *gmtime((time_t*)&recording_timestamp);
498     strftime(buf, sizeof(buf), "creation_time=%FT%T%z", &time);
499     parse_option(o, "metadata", buf, options);
500
501     av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
502                                  "tag instead.\n", opt);
503     return 0;
504 }
505
506 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
507 {
508     const AVCodecDescriptor *desc;
509     const char *codec_string = encoder ? "encoder" : "decoder";
510     AVCodec *codec;
511
512     codec = encoder ?
513         avcodec_find_encoder_by_name(name) :
514         avcodec_find_decoder_by_name(name);
515
516     if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
517         codec = encoder ? avcodec_find_encoder(desc->id) :
518                           avcodec_find_decoder(desc->id);
519         if (codec)
520             av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
521                    codec_string, codec->name, desc->name);
522     }
523
524     if (!codec) {
525         av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
526         exit_program(1);
527     }
528     if (codec->type != type) {
529         av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
530         exit_program(1);
531     }
532     return codec;
533 }
534
535 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
536 {
537     char *codec_name = NULL;
538
539     MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
540     if (codec_name) {
541         AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
542         st->codec->codec_id = codec->id;
543         return codec;
544     } else
545         return avcodec_find_decoder(st->codec->codec_id);
546 }
547
548 /* Add all the streams from the given input file to the global
549  * list of input streams. */
550 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
551 {
552     int i;
553     char *next, *codec_tag = NULL;
554
555     for (i = 0; i < ic->nb_streams; i++) {
556         AVStream *st = ic->streams[i];
557         AVCodecContext *dec = st->codec;
558         InputStream *ist = av_mallocz(sizeof(*ist));
559         char *framerate = NULL;
560
561         if (!ist)
562             exit_program(1);
563
564         GROW_ARRAY(input_streams, nb_input_streams);
565         input_streams[nb_input_streams - 1] = ist;
566
567         ist->st = st;
568         ist->file_index = nb_input_files;
569         ist->discard = 1;
570         st->discard  = AVDISCARD_ALL;
571
572         ist->ts_scale = 1.0;
573         MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
574
575         MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
576         if (codec_tag) {
577             uint32_t tag = strtol(codec_tag, &next, 0);
578             if (*next)
579                 tag = AV_RL32(codec_tag);
580             st->codec->codec_tag = tag;
581         }
582
583         ist->dec = choose_decoder(o, ic, st);
584         ist->opts = filter_codec_opts(o->g->codec_opts, ist->st->codec->codec_id, ic, st, ist->dec);
585
586         ist->reinit_filters = -1;
587         MATCH_PER_STREAM_OPT(reinit_filters, i, ist->reinit_filters, ic, st);
588
589         ist->filter_in_rescale_delta_last = AV_NOPTS_VALUE;
590
591         switch (dec->codec_type) {
592         case AVMEDIA_TYPE_VIDEO:
593             if(!ist->dec)
594                 ist->dec = avcodec_find_decoder(dec->codec_id);
595             if (dec->lowres) {
596                 dec->flags |= CODEC_FLAG_EMU_EDGE;
597             }
598
599             ist->resample_height  = dec->height;
600             ist->resample_width   = dec->width;
601             ist->resample_pix_fmt = dec->pix_fmt;
602
603             MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
604             if (framerate && av_parse_video_rate(&ist->framerate,
605                                                  framerate) < 0) {
606                 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
607                        framerate);
608                 exit_program(1);
609             }
610
611             ist->top_field_first = -1;
612             MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);
613
614             break;
615         case AVMEDIA_TYPE_AUDIO:
616             ist->guess_layout_max = INT_MAX;
617             MATCH_PER_STREAM_OPT(guess_layout_max, i, ist->guess_layout_max, ic, st);
618             guess_input_channel_layout(ist);
619
620             ist->resample_sample_fmt     = dec->sample_fmt;
621             ist->resample_sample_rate    = dec->sample_rate;
622             ist->resample_channels       = dec->channels;
623             ist->resample_channel_layout = dec->channel_layout;
624
625             break;
626         case AVMEDIA_TYPE_DATA:
627         case AVMEDIA_TYPE_SUBTITLE: {
628             char *canvas_size = NULL;
629             if(!ist->dec)
630                 ist->dec = avcodec_find_decoder(dec->codec_id);
631             MATCH_PER_STREAM_OPT(fix_sub_duration, i, ist->fix_sub_duration, ic, st);
632             MATCH_PER_STREAM_OPT(canvas_sizes, str, canvas_size, ic, st);
633             if (canvas_size &&
634                 av_parse_video_size(&dec->width, &dec->height, canvas_size) < 0) {
635                 av_log(NULL, AV_LOG_FATAL, "Invalid canvas size: %s.\n", canvas_size);
636                 exit_program(1);
637             }
638             break;
639         }
640         case AVMEDIA_TYPE_ATTACHMENT:
641         case AVMEDIA_TYPE_UNKNOWN:
642             break;
643         default:
644             abort();
645         }
646     }
647 }
648
649 static void assert_file_overwrite(const char *filename)
650 {
651     if (file_overwrite && no_file_overwrite) {
652         fprintf(stderr, "Error, both -y and -n supplied. Exiting.\n");
653         exit_program(1);
654     }
655
656     if (!file_overwrite &&
657         (strchr(filename, ':') == NULL || filename[1] == ':' ||
658          av_strstart(filename, "file:", NULL))) {
659         if (avio_check(filename, 0) == 0) {
660             if (stdin_interaction && !no_file_overwrite) {
661                 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
662                 fflush(stderr);
663                 term_exit();
664                 signal(SIGINT, SIG_DFL);
665                 if (!read_yesno()) {
666                     av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
667                     exit_program(1);
668                 }
669                 term_init();
670             }
671             else {
672                 av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
673                 exit_program(1);
674             }
675         }
676     }
677 }
678
679 static void dump_attachment(AVStream *st, const char *filename)
680 {
681     int ret;
682     AVIOContext *out = NULL;
683     AVDictionaryEntry *e;
684
685     if (!st->codec->extradata_size) {
686         av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
687                nb_input_files - 1, st->index);
688         return;
689     }
690     if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
691         filename = e->value;
692     if (!*filename) {
693         av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
694                "in stream #%d:%d.\n", nb_input_files - 1, st->index);
695         exit_program(1);
696     }
697
698     assert_file_overwrite(filename);
699
700     if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
701         av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
702                filename);
703         exit_program(1);
704     }
705
706     avio_write(out, st->codec->extradata, st->codec->extradata_size);
707     avio_flush(out);
708     avio_close(out);
709 }
710
711 static int open_input_file(OptionsContext *o, const char *filename)
712 {
713     InputFile *f;
714     AVFormatContext *ic;
715     AVInputFormat *file_iformat = NULL;
716     int err, i, ret;
717     int64_t timestamp;
718     uint8_t buf[128];
719     AVDictionary **opts;
720     AVDictionary *unused_opts = NULL;
721     AVDictionaryEntry *e = NULL;
722     int orig_nb_streams;                     // number of streams before avformat_find_stream_info
723     char *   video_codec_name = NULL;
724     char *   audio_codec_name = NULL;
725     char *subtitle_codec_name = NULL;
726
727     if (o->format) {
728         if (!(file_iformat = av_find_input_format(o->format))) {
729             av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
730             exit_program(1);
731         }
732     }
733
734     if (!strcmp(filename, "-"))
735         filename = "pipe:";
736
737     stdin_interaction &= strncmp(filename, "pipe:", 5) &&
738                          strcmp(filename, "/dev/stdin");
739
740     /* get default parameters from command line */
741     ic = avformat_alloc_context();
742     if (!ic) {
743         print_error(filename, AVERROR(ENOMEM));
744         exit_program(1);
745     }
746     if (o->nb_audio_sample_rate) {
747         snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
748         av_dict_set(&o->g->format_opts, "sample_rate", buf, 0);
749     }
750     if (o->nb_audio_channels) {
751         /* because we set audio_channels based on both the "ac" and
752          * "channel_layout" options, we need to check that the specified
753          * demuxer actually has the "channels" option before setting it */
754         if (file_iformat && file_iformat->priv_class &&
755             av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
756                         AV_OPT_SEARCH_FAKE_OBJ)) {
757             snprintf(buf, sizeof(buf), "%d",
758                      o->audio_channels[o->nb_audio_channels - 1].u.i);
759             av_dict_set(&o->g->format_opts, "channels", buf, 0);
760         }
761     }
762     if (o->nb_frame_rates) {
763         /* set the format-level framerate option;
764          * this is important for video grabbers, e.g. x11 */
765         if (file_iformat && file_iformat->priv_class &&
766             av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
767                         AV_OPT_SEARCH_FAKE_OBJ)) {
768             av_dict_set(&o->g->format_opts, "framerate",
769                         o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
770         }
771     }
772     if (o->nb_frame_sizes) {
773         av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
774     }
775     if (o->nb_frame_pix_fmts)
776         av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
777
778     MATCH_PER_TYPE_OPT(codec_names, str,    video_codec_name, ic, "v");
779     MATCH_PER_TYPE_OPT(codec_names, str,    audio_codec_name, ic, "a");
780     MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, ic, "s");
781
782     ic->video_codec_id   = video_codec_name ?
783         find_codec_or_die(video_codec_name   , AVMEDIA_TYPE_VIDEO   , 0)->id : AV_CODEC_ID_NONE;
784     ic->audio_codec_id   = audio_codec_name ?
785         find_codec_or_die(audio_codec_name   , AVMEDIA_TYPE_AUDIO   , 0)->id : AV_CODEC_ID_NONE;
786     ic->subtitle_codec_id= subtitle_codec_name ?
787         find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : AV_CODEC_ID_NONE;
788     ic->flags |= AVFMT_FLAG_NONBLOCK;
789     ic->interrupt_callback = int_cb;
790
791     /* open the input file with generic avformat function */
792     err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
793     if (err < 0) {
794         print_error(filename, err);
795         exit_program(1);
796     }
797     assert_avoptions(o->g->format_opts);
798
799     /* apply forced codec ids */
800     for (i = 0; i < ic->nb_streams; i++)
801         choose_decoder(o, ic, ic->streams[i]);
802
803     /* Set AVCodecContext options for avformat_find_stream_info */
804     opts = setup_find_stream_info_opts(ic, o->g->codec_opts);
805     orig_nb_streams = ic->nb_streams;
806
807     /* If not enough info to get the stream parameters, we decode the
808        first frames to get it. (used in mpeg case for example) */
809     ret = avformat_find_stream_info(ic, opts);
810     if (ret < 0) {
811         av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
812         avformat_close_input(&ic);
813         exit_program(1);
814     }
815
816     timestamp = (o->start_time == AV_NOPTS_VALUE) ? 0 : o->start_time;
817     /* add the stream start time */
818     if (ic->start_time != AV_NOPTS_VALUE)
819         timestamp += ic->start_time;
820
821     /* if seeking requested, we execute it */
822     if (o->start_time != AV_NOPTS_VALUE) {
823         ret = avformat_seek_file(ic, -1, INT64_MIN, timestamp, timestamp, 0);
824         if (ret < 0) {
825             av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
826                    filename, (double)timestamp / AV_TIME_BASE);
827         }
828     }
829
830     /* update the current parameters so that they match the one of the input stream */
831     add_input_streams(o, ic);
832
833     /* dump the file content */
834     av_dump_format(ic, nb_input_files, filename, 0);
835
836     GROW_ARRAY(input_files, nb_input_files);
837     f = av_mallocz(sizeof(*f));
838     if (!f)
839         exit_program(1);
840     input_files[nb_input_files - 1] = f;
841
842     f->ctx        = ic;
843     f->ist_index  = nb_input_streams - ic->nb_streams;
844     f->start_time = o->start_time;
845     f->ts_offset  = o->input_ts_offset - (copy_ts ? 0 : timestamp);
846     f->nb_streams = ic->nb_streams;
847     f->rate_emu   = o->rate_emu;
848     f->accurate_seek = o->accurate_seek;
849
850     /* check if all codec options have been used */
851     unused_opts = strip_specifiers(o->g->codec_opts);
852     for (i = f->ist_index; i < nb_input_streams; i++) {
853         e = NULL;
854         while ((e = av_dict_get(input_streams[i]->opts, "", e,
855                                 AV_DICT_IGNORE_SUFFIX)))
856             av_dict_set(&unused_opts, e->key, NULL, 0);
857     }
858
859     e = NULL;
860     while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
861         const AVClass *class = avcodec_get_class();
862         const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
863                                              AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
864         if (!option)
865             continue;
866         if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) {
867             av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
868                    "input file #%d (%s) is not a decoding option.\n", e->key,
869                    option->help ? option->help : "", nb_input_files - 1,
870                    filename);
871             exit_program(1);
872         }
873
874         av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
875                "input file #%d (%s) has not been used for any stream. The most "
876                "likely reason is either wrong type (e.g. a video option with "
877                "no video streams) or that it is a private option of some decoder "
878                "which was not actually used for any stream.\n", e->key,
879                option->help ? option->help : "", nb_input_files - 1, filename);
880     }
881     av_dict_free(&unused_opts);
882
883     for (i = 0; i < o->nb_dump_attachment; i++) {
884         int j;
885
886         for (j = 0; j < ic->nb_streams; j++) {
887             AVStream *st = ic->streams[j];
888
889             if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
890                 dump_attachment(st, o->dump_attachment[i].u.str);
891         }
892     }
893
894     for (i = 0; i < orig_nb_streams; i++)
895         av_dict_free(&opts[i]);
896     av_freep(&opts);
897
898     return 0;
899 }
900
901 static uint8_t *get_line(AVIOContext *s)
902 {
903     AVIOContext *line;
904     uint8_t *buf;
905     char c;
906
907     if (avio_open_dyn_buf(&line) < 0) {
908         av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
909         exit_program(1);
910     }
911
912     while ((c = avio_r8(s)) && c != '\n')
913         avio_w8(line, c);
914     avio_w8(line, 0);
915     avio_close_dyn_buf(line, &buf);
916
917     return buf;
918 }
919
920 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
921 {
922     int i, ret = 1;
923     char filename[1000];
924     const char *base[3] = { getenv("AVCONV_DATADIR"),
925                             getenv("HOME"),
926                             AVCONV_DATADIR,
927                             };
928
929     for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
930         if (!base[i])
931             continue;
932         if (codec_name) {
933             snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
934                      i != 1 ? "" : "/.avconv", codec_name, preset_name);
935             ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
936         }
937         if (ret) {
938             snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
939                      i != 1 ? "" : "/.avconv", preset_name);
940             ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
941         }
942     }
943     return ret;
944 }
945
946 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
947 {
948     char *codec_name = NULL;
949
950     MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
951     if (!codec_name) {
952         ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
953                                                   NULL, ost->st->codec->codec_type);
954         ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
955     } else if (!strcmp(codec_name, "copy"))
956         ost->stream_copy = 1;
957     else {
958         ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
959         ost->st->codec->codec_id = ost->enc->id;
960     }
961 }
962
963 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
964 {
965     OutputStream *ost;
966     AVStream *st = avformat_new_stream(oc, NULL);
967     int idx      = oc->nb_streams - 1, ret = 0;
968     char *bsf = NULL, *next, *codec_tag = NULL;
969     AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
970     double qscale = -1;
971     int i;
972
973     if (!st) {
974         av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
975         exit_program(1);
976     }
977
978     if (oc->nb_streams - 1 < o->nb_streamid_map)
979         st->id = o->streamid_map[oc->nb_streams - 1];
980
981     GROW_ARRAY(output_streams, nb_output_streams);
982     if (!(ost = av_mallocz(sizeof(*ost))))
983         exit_program(1);
984     output_streams[nb_output_streams - 1] = ost;
985
986     ost->file_index = nb_output_files - 1;
987     ost->index      = idx;
988     ost->st         = st;
989     st->codec->codec_type = type;
990     choose_encoder(o, oc, ost);
991     if (ost->enc) {
992         AVIOContext *s = NULL;
993         char *buf = NULL, *arg = NULL, *preset = NULL;
994
995         ost->opts  = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
996
997         MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
998         if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
999             do  {
1000                 buf = get_line(s);
1001                 if (!buf[0] || buf[0] == '#') {
1002                     av_free(buf);
1003                     continue;
1004                 }
1005                 if (!(arg = strchr(buf, '='))) {
1006                     av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
1007                     exit_program(1);
1008                 }
1009                 *arg++ = 0;
1010                 av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
1011                 av_free(buf);
1012             } while (!s->eof_reached);
1013             avio_close(s);
1014         }
1015         if (ret) {
1016             av_log(NULL, AV_LOG_FATAL,
1017                    "Preset %s specified for stream %d:%d, but could not be opened.\n",
1018                    preset, ost->file_index, ost->index);
1019             exit_program(1);
1020         }
1021     } else {
1022         ost->opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
1023     }
1024
1025     avcodec_get_context_defaults3(st->codec, ost->enc);
1026     st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
1027
1028     ost->max_frames = INT64_MAX;
1029     MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
1030     for (i = 0; i<o->nb_max_frames; i++) {
1031         char *p = o->max_frames[i].specifier;
1032         if (!*p && type != AVMEDIA_TYPE_VIDEO) {
1033             av_log(NULL, AV_LOG_WARNING, "Applying unspecific -frames to non video streams, maybe you meant -vframes ?\n");
1034             break;
1035         }
1036     }
1037
1038     ost->copy_prior_start = -1;
1039     MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
1040
1041     MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
1042     while (bsf) {
1043         if (next = strchr(bsf, ','))
1044             *next++ = 0;
1045         if (!(bsfc = av_bitstream_filter_init(bsf))) {
1046             av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
1047             exit_program(1);
1048         }
1049         if (bsfc_prev)
1050             bsfc_prev->next = bsfc;
1051         else
1052             ost->bitstream_filters = bsfc;
1053
1054         bsfc_prev = bsfc;
1055         bsf       = next;
1056     }
1057
1058     MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1059     if (codec_tag) {
1060         uint32_t tag = strtol(codec_tag, &next, 0);
1061         if (*next)
1062             tag = AV_RL32(codec_tag);
1063         st->codec->codec_tag = tag;
1064     }
1065
1066     MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1067     if (qscale >= 0) {
1068         st->codec->flags |= CODEC_FLAG_QSCALE;
1069         st->codec->global_quality = FF_QP2LAMBDA * qscale;
1070     }
1071
1072     if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1073         st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
1074
1075     av_opt_get_int(o->g->sws_opts, "sws_flags", 0, &ost->sws_flags);
1076
1077     av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0);
1078     if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24)
1079         av_dict_set(&ost->swr_opts, "output_sample_bits", "24", 0);
1080
1081     av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1082
1083     ost->source_index = source_index;
1084     if (source_index >= 0) {
1085         ost->sync_ist = input_streams[source_index];
1086         input_streams[source_index]->discard = 0;
1087         input_streams[source_index]->st->discard = AVDISCARD_NONE;
1088     }
1089     ost->last_mux_dts = AV_NOPTS_VALUE;
1090
1091     return ost;
1092 }
1093
1094 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1095 {
1096     int i;
1097     const char *p = str;
1098     for (i = 0;; i++) {
1099         dest[i] = atoi(p);
1100         if (i == 63)
1101             break;
1102         p = strchr(p, ',');
1103         if (!p) {
1104             av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1105             exit_program(1);
1106         }
1107         p++;
1108     }
1109 }
1110
1111 /* read file contents into a string */
1112 static uint8_t *read_file(const char *filename)
1113 {
1114     AVIOContext *pb      = NULL;
1115     AVIOContext *dyn_buf = NULL;
1116     int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1117     uint8_t buf[1024], *str;
1118
1119     if (ret < 0) {
1120         av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1121         return NULL;
1122     }
1123
1124     ret = avio_open_dyn_buf(&dyn_buf);
1125     if (ret < 0) {
1126         avio_closep(&pb);
1127         return NULL;
1128     }
1129     while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1130         avio_write(dyn_buf, buf, ret);
1131     avio_w8(dyn_buf, 0);
1132     avio_closep(&pb);
1133
1134     ret = avio_close_dyn_buf(dyn_buf, &str);
1135     if (ret < 0)
1136         return NULL;
1137     return str;
1138 }
1139
1140 static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
1141                              OutputStream *ost)
1142 {
1143     AVStream *st = ost->st;
1144     char *filter = NULL, *filter_script = NULL;
1145
1146     MATCH_PER_STREAM_OPT(filter_scripts, str, filter_script, oc, st);
1147     MATCH_PER_STREAM_OPT(filters, str, filter, oc, st);
1148
1149     if (filter_script && filter) {
1150         av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1151                "output stream #%d:%d.\n", nb_output_files, st->index);
1152         exit_program(1);
1153     }
1154
1155     if (filter_script)
1156         return read_file(filter_script);
1157     else if (filter)
1158         return av_strdup(filter);
1159
1160     return av_strdup(st->codec->codec_type == AVMEDIA_TYPE_VIDEO ?
1161                      "null" : "anull");
1162 }
1163
1164 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1165 {
1166     AVStream *st;
1167     OutputStream *ost;
1168     AVCodecContext *video_enc;
1169     char *frame_rate = NULL, *frame_aspect_ratio = NULL;
1170
1171     ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1172     st  = ost->st;
1173     video_enc = st->codec;
1174
1175     MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1176     if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1177         av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1178         exit_program(1);
1179     }
1180
1181     MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1182     if (frame_aspect_ratio) {
1183         AVRational q;
1184         if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1185             q.num <= 0 || q.den <= 0) {
1186             av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1187             exit_program(1);
1188         }
1189         ost->frame_aspect_ratio = q;
1190     }
1191
1192     if (!ost->stream_copy) {
1193         const char *p = NULL;
1194         char *frame_size = NULL;
1195         char *frame_pix_fmt = NULL;
1196         char *intra_matrix = NULL, *inter_matrix = NULL;
1197         int do_pass = 0;
1198         int i;
1199
1200         MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1201         if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1202             av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1203             exit_program(1);
1204         }
1205
1206         video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1207         MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1208         if (frame_pix_fmt && *frame_pix_fmt == '+') {
1209             ost->keep_pix_fmt = 1;
1210             if (!*++frame_pix_fmt)
1211                 frame_pix_fmt = NULL;
1212         }
1213         if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1214             av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1215             exit_program(1);
1216         }
1217         st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1218
1219         if (intra_only)
1220             video_enc->gop_size = 0;
1221         MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1222         if (intra_matrix) {
1223             if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1224                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1225                 exit_program(1);
1226             }
1227             parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1228         }
1229         MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1230         if (inter_matrix) {
1231             if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1232                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1233                 exit_program(1);
1234             }
1235             parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1236         }
1237
1238         MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1239         for (i = 0; p; i++) {
1240             int start, end, q;
1241             int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1242             if (e != 3) {
1243                 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1244                 exit_program(1);
1245             }
1246             /* FIXME realloc failure */
1247             video_enc->rc_override =
1248                 av_realloc(video_enc->rc_override,
1249                            sizeof(RcOverride) * (i + 1));
1250             video_enc->rc_override[i].start_frame = start;
1251             video_enc->rc_override[i].end_frame   = end;
1252             if (q > 0) {
1253                 video_enc->rc_override[i].qscale         = q;
1254                 video_enc->rc_override[i].quality_factor = 1.0;
1255             }
1256             else {
1257                 video_enc->rc_override[i].qscale         = 0;
1258                 video_enc->rc_override[i].quality_factor = -q/100.0;
1259             }
1260             p = strchr(p, '/');
1261             if (p) p++;
1262         }
1263         video_enc->rc_override_count = i;
1264         video_enc->intra_dc_precision = intra_dc_precision - 8;
1265
1266         if (do_psnr)
1267             video_enc->flags|= CODEC_FLAG_PSNR;
1268
1269         /* two pass mode */
1270         MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1271         if (do_pass) {
1272             if (do_pass & 1) {
1273                 video_enc->flags |= CODEC_FLAG_PASS1;
1274                 av_dict_set(&ost->opts, "flags", "+pass1", AV_DICT_APPEND);
1275             }
1276             if (do_pass & 2) {
1277                 video_enc->flags |= CODEC_FLAG_PASS2;
1278                 av_dict_set(&ost->opts, "flags", "+pass2", AV_DICT_APPEND);
1279             }
1280         }
1281
1282         MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1283         if (ost->logfile_prefix &&
1284             !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1285             exit_program(1);
1286
1287         MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1288         if (ost->forced_keyframes)
1289             ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1290
1291         MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1292
1293         ost->top_field_first = -1;
1294         MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1295
1296
1297         ost->avfilter = get_ost_filters(o, oc, ost);
1298         if (!ost->avfilter)
1299             exit_program(1);
1300     } else {
1301         MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1302     }
1303
1304     return ost;
1305 }
1306
1307 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1308 {
1309     int n;
1310     AVStream *st;
1311     OutputStream *ost;
1312     AVCodecContext *audio_enc;
1313
1314     ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1315     st  = ost->st;
1316
1317     audio_enc = st->codec;
1318     audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1319
1320     if (!ost->stream_copy) {
1321         char *sample_fmt = NULL;
1322
1323         MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1324
1325         MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1326         if (sample_fmt &&
1327             (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1328             av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1329             exit_program(1);
1330         }
1331
1332         MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1333
1334         MATCH_PER_STREAM_OPT(apad, str, ost->apad, oc, st);
1335         ost->apad = av_strdup(ost->apad);
1336
1337         ost->avfilter = get_ost_filters(o, oc, ost);
1338         if (!ost->avfilter)
1339             exit_program(1);
1340
1341         /* check for channel mapping for this audio stream */
1342         for (n = 0; n < o->nb_audio_channel_maps; n++) {
1343             AudioChannelMap *map = &o->audio_channel_maps[n];
1344             InputStream *ist = input_streams[ost->source_index];
1345             if ((map->channel_idx == -1 || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) &&
1346                 (map->ofile_idx   == -1 || ost->file_index == map->ofile_idx) &&
1347                 (map->ostream_idx == -1 || ost->st->index  == map->ostream_idx)) {
1348                 if (ost->audio_channels_mapped < FF_ARRAY_ELEMS(ost->audio_channels_map))
1349                     ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1350                 else
1351                     av_log(NULL, AV_LOG_FATAL, "Max channel mapping for output %d.%d reached\n",
1352                            ost->file_index, ost->st->index);
1353             }
1354         }
1355     }
1356
1357     return ost;
1358 }
1359
1360 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1361 {
1362     OutputStream *ost;
1363
1364     ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1365     if (!ost->stream_copy) {
1366         av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1367         exit_program(1);
1368     }
1369
1370     return ost;
1371 }
1372
1373 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1374 {
1375     OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1376     ost->stream_copy = 1;
1377     ost->finished    = 1;
1378     return ost;
1379 }
1380
1381 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1382 {
1383     AVStream *st;
1384     OutputStream *ost;
1385     AVCodecContext *subtitle_enc;
1386
1387     ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1388     st  = ost->st;
1389     subtitle_enc = st->codec;
1390
1391     subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1392
1393     MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1394
1395     if (!ost->stream_copy) {
1396         char *frame_size = NULL;
1397
1398         MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1399         if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1400             av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1401             exit_program(1);
1402         }
1403     }
1404
1405     return ost;
1406 }
1407
1408 /* arg format is "output-stream-index:streamid-value". */
1409 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1410 {
1411     OptionsContext *o = optctx;
1412     int idx;
1413     char *p;
1414     char idx_str[16];
1415
1416     av_strlcpy(idx_str, arg, sizeof(idx_str));
1417     p = strchr(idx_str, ':');
1418     if (!p) {
1419         av_log(NULL, AV_LOG_FATAL,
1420                "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1421                arg, opt);
1422         exit_program(1);
1423     }
1424     *p++ = '\0';
1425     idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1426     o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1427     o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1428     return 0;
1429 }
1430
1431 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1432 {
1433     AVFormatContext *is = ifile->ctx;
1434     AVFormatContext *os = ofile->ctx;
1435     AVChapter **tmp;
1436     int i;
1437
1438     tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1439     if (!tmp)
1440         return AVERROR(ENOMEM);
1441     os->chapters = tmp;
1442
1443     for (i = 0; i < is->nb_chapters; i++) {
1444         AVChapter *in_ch = is->chapters[i], *out_ch;
1445         int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
1446         int64_t ts_off   = av_rescale_q(start_time - ifile->ts_offset,
1447                                        AV_TIME_BASE_Q, in_ch->time_base);
1448         int64_t rt       = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1449                            av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1450
1451
1452         if (in_ch->end < ts_off)
1453             continue;
1454         if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1455             break;
1456
1457         out_ch = av_mallocz(sizeof(AVChapter));
1458         if (!out_ch)
1459             return AVERROR(ENOMEM);
1460
1461         out_ch->id        = in_ch->id;
1462         out_ch->time_base = in_ch->time_base;
1463         out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
1464         out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
1465
1466         if (copy_metadata)
1467             av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1468
1469         os->chapters[os->nb_chapters++] = out_ch;
1470     }
1471     return 0;
1472 }
1473
1474 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
1475 {
1476     int i, err;
1477     AVFormatContext *ic = avformat_alloc_context();
1478
1479     ic->interrupt_callback = int_cb;
1480     err = avformat_open_input(&ic, filename, NULL, NULL);
1481     if (err < 0)
1482         return err;
1483     /* copy stream format */
1484     for(i=0;i<ic->nb_streams;i++) {
1485         AVStream *st;
1486         OutputStream *ost;
1487         AVCodec *codec;
1488         AVCodecContext *avctx;
1489
1490         codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
1491         ost   = new_output_stream(o, s, codec->type, -1);
1492         st    = ost->st;
1493         avctx = st->codec;
1494         ost->enc = codec;
1495
1496         // FIXME: a more elegant solution is needed
1497         memcpy(st, ic->streams[i], sizeof(AVStream));
1498         st->cur_dts = 0;
1499         st->info = av_malloc(sizeof(*st->info));
1500         memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
1501         st->codec= avctx;
1502         avcodec_copy_context(st->codec, ic->streams[i]->codec);
1503
1504         if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
1505             choose_sample_fmt(st, codec);
1506         else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
1507             choose_pixel_fmt(st, codec, st->codec->pix_fmt);
1508     }
1509
1510     avformat_close_input(&ic);
1511     return err;
1512 }
1513
1514 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1515                                AVFormatContext *oc)
1516 {
1517     OutputStream *ost;
1518
1519     switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1520                                   ofilter->out_tmp->pad_idx)) {
1521     case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
1522     case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
1523     default:
1524         av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1525                "currently.\n");
1526         exit_program(1);
1527     }
1528
1529     ost->source_index = -1;
1530     ost->filter       = ofilter;
1531
1532     ofilter->ost      = ost;
1533
1534     if (ost->stream_copy) {
1535         av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1536                "which is fed from a complex filtergraph. Filtering and streamcopy "
1537                "cannot be used together.\n", ost->file_index, ost->index);
1538         exit_program(1);
1539     }
1540
1541     if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
1542         av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
1543         exit_program(1);
1544     }
1545     avfilter_inout_free(&ofilter->out_tmp);
1546 }
1547
1548 static int configure_complex_filters(void)
1549 {
1550     int i, ret = 0;
1551
1552     for (i = 0; i < nb_filtergraphs; i++)
1553         if (!filtergraphs[i]->graph &&
1554             (ret = configure_filtergraph(filtergraphs[i])) < 0)
1555             return ret;
1556     return 0;
1557 }
1558
1559 static int open_output_file(OptionsContext *o, const char *filename)
1560 {
1561     AVFormatContext *oc;
1562     int i, j, err;
1563     AVOutputFormat *file_oformat;
1564     OutputFile *of;
1565     OutputStream *ost;
1566     InputStream  *ist;
1567     AVDictionary *unused_opts = NULL;
1568     AVDictionaryEntry *e = NULL;
1569
1570     if (configure_complex_filters() < 0) {
1571         av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
1572         exit_program(1);
1573     }
1574
1575     if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
1576         o->stop_time = INT64_MAX;
1577         av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
1578     }
1579
1580     if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
1581         int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
1582         if (o->stop_time <= start_time) {
1583             av_log(NULL, AV_LOG_WARNING, "-to value smaller than -ss; ignoring -to.\n");
1584             o->stop_time = INT64_MAX;
1585         } else {
1586             o->recording_time = o->stop_time - start_time;
1587         }
1588     }
1589
1590     GROW_ARRAY(output_files, nb_output_files);
1591     of = av_mallocz(sizeof(*of));
1592     if (!of)
1593         exit_program(1);
1594     output_files[nb_output_files - 1] = of;
1595
1596     of->ost_index      = nb_output_streams;
1597     of->recording_time = o->recording_time;
1598     of->start_time     = o->start_time;
1599     of->limit_filesize = o->limit_filesize;
1600     of->shortest       = o->shortest;
1601     av_dict_copy(&of->opts, o->g->format_opts, 0);
1602
1603     if (!strcmp(filename, "-"))
1604         filename = "pipe:";
1605
1606     err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
1607     if (!oc) {
1608         print_error(filename, err);
1609         exit_program(1);
1610     }
1611
1612     of->ctx = oc;
1613     if (o->recording_time != INT64_MAX)
1614         oc->duration = o->recording_time;
1615
1616     file_oformat= oc->oformat;
1617     oc->interrupt_callback = int_cb;
1618
1619     /* create streams for all unlabeled output pads */
1620     for (i = 0; i < nb_filtergraphs; i++) {
1621         FilterGraph *fg = filtergraphs[i];
1622         for (j = 0; j < fg->nb_outputs; j++) {
1623             OutputFilter *ofilter = fg->outputs[j];
1624
1625             if (!ofilter->out_tmp || ofilter->out_tmp->name)
1626                 continue;
1627
1628             switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1629                                           ofilter->out_tmp->pad_idx)) {
1630             case AVMEDIA_TYPE_VIDEO:    o->video_disable    = 1; break;
1631             case AVMEDIA_TYPE_AUDIO:    o->audio_disable    = 1; break;
1632             case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1633             }
1634             init_output_filter(ofilter, o, oc);
1635         }
1636     }
1637
1638     /* ffserver seeking with date=... needs a date reference */
1639     if (!strcmp(file_oformat->name, "ffm") &&
1640         av_strstart(filename, "http:", NULL)) {
1641         int err = parse_option(o, "metadata", "creation_time=now", options);
1642         if (err < 0) {
1643             print_error(filename, err);
1644             exit_program(1);
1645         }
1646     }
1647
1648     if (!strcmp(file_oformat->name, "ffm") && !override_ffserver &&
1649         av_strstart(filename, "http:", NULL)) {
1650         int j;
1651         /* special case for files sent to ffserver: we get the stream
1652            parameters from ffserver */
1653         int err = read_ffserver_streams(o, oc, filename);
1654         if (err < 0) {
1655             print_error(filename, err);
1656             exit_program(1);
1657         }
1658         for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
1659             ost = output_streams[j];
1660             for (i = 0; i < nb_input_streams; i++) {
1661                 ist = input_streams[i];
1662                 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
1663                     ost->sync_ist= ist;
1664                     ost->source_index= i;
1665                     if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
1666                     if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
1667                     ist->discard = 0;
1668                     ist->st->discard = AVDISCARD_NONE;
1669                     break;
1670                 }
1671             }
1672             if(!ost->sync_ist){
1673                 av_log(NULL, AV_LOG_FATAL, "Missing %s stream which is required by this ffm\n", av_get_media_type_string(ost->st->codec->codec_type));
1674                 exit_program(1);
1675             }
1676         }
1677     } else if (!o->nb_stream_maps) {
1678         char *subtitle_codec_name = NULL;
1679         /* pick the "best" stream of each type */
1680
1681         /* video: highest resolution */
1682         if (!o->video_disable && oc->oformat->video_codec != AV_CODEC_ID_NONE) {
1683             int area = 0, idx = -1;
1684             int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
1685             for (i = 0; i < nb_input_streams; i++) {
1686                 int new_area;
1687                 ist = input_streams[i];
1688                 new_area = ist->st->codec->width * ist->st->codec->height;
1689                 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1690                     new_area = 1;
1691                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1692                     new_area > area) {
1693                     if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1694                         continue;
1695                     area = new_area;
1696                     idx = i;
1697                 }
1698             }
1699             if (idx >= 0)
1700                 new_video_stream(o, oc, idx);
1701         }
1702
1703         /* audio: most channels */
1704         if (!o->audio_disable && oc->oformat->audio_codec != AV_CODEC_ID_NONE) {
1705             int channels = 0, idx = -1;
1706             for (i = 0; i < nb_input_streams; i++) {
1707                 ist = input_streams[i];
1708                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1709                     ist->st->codec->channels > channels) {
1710                     channels = ist->st->codec->channels;
1711                     idx = i;
1712                 }
1713             }
1714             if (idx >= 0)
1715                 new_audio_stream(o, oc, idx);
1716         }
1717
1718         /* subtitles: pick first */
1719         MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
1720         if (!o->subtitle_disable && (oc->oformat->subtitle_codec != AV_CODEC_ID_NONE || subtitle_codec_name)) {
1721             for (i = 0; i < nb_input_streams; i++)
1722                 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1723                     new_subtitle_stream(o, oc, i);
1724                     break;
1725                 }
1726         }
1727         /* do something with data? */
1728     } else {
1729         for (i = 0; i < o->nb_stream_maps; i++) {
1730             StreamMap *map = &o->stream_maps[i];
1731
1732             if (map->disabled)
1733                 continue;
1734
1735             if (map->linklabel) {
1736                 FilterGraph *fg;
1737                 OutputFilter *ofilter = NULL;
1738                 int j, k;
1739
1740                 for (j = 0; j < nb_filtergraphs; j++) {
1741                     fg = filtergraphs[j];
1742                     for (k = 0; k < fg->nb_outputs; k++) {
1743                         AVFilterInOut *out = fg->outputs[k]->out_tmp;
1744                         if (out && !strcmp(out->name, map->linklabel)) {
1745                             ofilter = fg->outputs[k];
1746                             goto loop_end;
1747                         }
1748                     }
1749                 }
1750 loop_end:
1751                 if (!ofilter) {
1752                     av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1753                            "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
1754                     exit_program(1);
1755                 }
1756                 init_output_filter(ofilter, o, oc);
1757             } else {
1758                 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
1759
1760                 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
1761                 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
1762                     continue;
1763                 if(o->   audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1764                     continue;
1765                 if(o->   video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
1766                     continue;
1767                 if(o->    data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
1768                     continue;
1769
1770                 switch (ist->st->codec->codec_type) {
1771                 case AVMEDIA_TYPE_VIDEO:      ost = new_video_stream     (o, oc, src_idx); break;
1772                 case AVMEDIA_TYPE_AUDIO:      ost = new_audio_stream     (o, oc, src_idx); break;
1773                 case AVMEDIA_TYPE_SUBTITLE:   ost = new_subtitle_stream  (o, oc, src_idx); break;
1774                 case AVMEDIA_TYPE_DATA:       ost = new_data_stream      (o, oc, src_idx); break;
1775                 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
1776                 default:
1777                     av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
1778                            map->file_index, map->stream_index);
1779                     exit_program(1);
1780                 }
1781             }
1782         }
1783     }
1784
1785     /* handle attached files */
1786     for (i = 0; i < o->nb_attachments; i++) {
1787         AVIOContext *pb;
1788         uint8_t *attachment;
1789         const char *p;
1790         int64_t len;
1791
1792         if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
1793             av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
1794                    o->attachments[i]);
1795             exit_program(1);
1796         }
1797         if ((len = avio_size(pb)) <= 0) {
1798             av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
1799                    o->attachments[i]);
1800             exit_program(1);
1801         }
1802         if (!(attachment = av_malloc(len))) {
1803             av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
1804                    o->attachments[i]);
1805             exit_program(1);
1806         }
1807         avio_read(pb, attachment, len);
1808
1809         ost = new_attachment_stream(o, oc, -1);
1810         ost->stream_copy               = 0;
1811         ost->attachment_filename       = o->attachments[i];
1812         ost->finished                  = 1;
1813         ost->st->codec->extradata      = attachment;
1814         ost->st->codec->extradata_size = len;
1815
1816         p = strrchr(o->attachments[i], '/');
1817         av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
1818         avio_close(pb);
1819     }
1820
1821     for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
1822         AVDictionaryEntry *e;
1823         ost = output_streams[i];
1824
1825         if ((ost->stream_copy || ost->attachment_filename)
1826             && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
1827             && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
1828             if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
1829                 exit_program(1);
1830     }
1831
1832     /* check if all codec options have been used */
1833     unused_opts = strip_specifiers(o->g->codec_opts);
1834     for (i = of->ost_index; i < nb_output_streams; i++) {
1835         e = NULL;
1836         while ((e = av_dict_get(output_streams[i]->opts, "", e,
1837                                 AV_DICT_IGNORE_SUFFIX)))
1838             av_dict_set(&unused_opts, e->key, NULL, 0);
1839     }
1840
1841     e = NULL;
1842     while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
1843         const AVClass *class = avcodec_get_class();
1844         const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
1845                                              AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1846         if (!option)
1847             continue;
1848         if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
1849             av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
1850                    "output file #%d (%s) is not an encoding option.\n", e->key,
1851                    option->help ? option->help : "", nb_output_files - 1,
1852                    filename);
1853             exit_program(1);
1854         }
1855
1856         // gop_timecode is injected by generic code but not always used
1857         if (!strcmp(e->key, "gop_timecode"))
1858             continue;
1859
1860         av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
1861                "output file #%d (%s) has not been used for any stream. The most "
1862                "likely reason is either wrong type (e.g. a video option with "
1863                "no video streams) or that it is a private option of some encoder "
1864                "which was not actually used for any stream.\n", e->key,
1865                option->help ? option->help : "", nb_output_files - 1, filename);
1866     }
1867     av_dict_free(&unused_opts);
1868
1869     /* check filename in case of an image number is expected */
1870     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
1871         if (!av_filename_number_test(oc->filename)) {
1872             print_error(oc->filename, AVERROR(EINVAL));
1873             exit_program(1);
1874         }
1875     }
1876
1877     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
1878         /* test if it already exists to avoid losing precious files */
1879         assert_file_overwrite(filename);
1880
1881         /* open the file */
1882         if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
1883                               &oc->interrupt_callback,
1884                               &of->opts)) < 0) {
1885             print_error(filename, err);
1886             exit_program(1);
1887         }
1888     } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
1889         assert_file_overwrite(filename);
1890
1891     if (o->mux_preload) {
1892         uint8_t buf[64];
1893         snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
1894         av_dict_set(&of->opts, "preload", buf, 0);
1895     }
1896     oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
1897
1898     /* copy metadata */
1899     for (i = 0; i < o->nb_metadata_map; i++) {
1900         char *p;
1901         int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
1902
1903         if (in_file_index >= nb_input_files) {
1904             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
1905             exit_program(1);
1906         }
1907         copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
1908                       in_file_index >= 0 ?
1909                       input_files[in_file_index]->ctx : NULL, o);
1910     }
1911
1912     /* copy chapters */
1913     if (o->chapters_input_file >= nb_input_files) {
1914         if (o->chapters_input_file == INT_MAX) {
1915             /* copy chapters from the first input file that has them*/
1916             o->chapters_input_file = -1;
1917             for (i = 0; i < nb_input_files; i++)
1918                 if (input_files[i]->ctx->nb_chapters) {
1919                     o->chapters_input_file = i;
1920                     break;
1921                 }
1922         } else {
1923             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
1924                    o->chapters_input_file);
1925             exit_program(1);
1926         }
1927     }
1928     if (o->chapters_input_file >= 0)
1929         copy_chapters(input_files[o->chapters_input_file], of,
1930                       !o->metadata_chapters_manual);
1931
1932     /* copy global metadata by default */
1933     if (!o->metadata_global_manual && nb_input_files){
1934         av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
1935                      AV_DICT_DONT_OVERWRITE);
1936         if(o->recording_time != INT64_MAX)
1937             av_dict_set(&oc->metadata, "duration", NULL, 0);
1938         av_dict_set(&oc->metadata, "creation_time", NULL, 0);
1939     }
1940     if (!o->metadata_streams_manual)
1941         for (i = of->ost_index; i < nb_output_streams; i++) {
1942             InputStream *ist;
1943             if (output_streams[i]->source_index < 0)         /* this is true e.g. for attached files */
1944                 continue;
1945             ist = input_streams[output_streams[i]->source_index];
1946             av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
1947         }
1948
1949     /* process manually set metadata */
1950     for (i = 0; i < o->nb_metadata; i++) {
1951         AVDictionary **m;
1952         char type, *val;
1953         const char *stream_spec;
1954         int index = 0, j, ret = 0;
1955
1956         val = strchr(o->metadata[i].u.str, '=');
1957         if (!val) {
1958             av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
1959                    o->metadata[i].u.str);
1960             exit_program(1);
1961         }
1962         *val++ = 0;
1963
1964         parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
1965         if (type == 's') {
1966             for (j = 0; j < oc->nb_streams; j++) {
1967                 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
1968                     av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
1969                 } else if (ret < 0)
1970                     exit_program(1);
1971             }
1972         }
1973         else {
1974             switch (type) {
1975             case 'g':
1976                 m = &oc->metadata;
1977                 break;
1978             case 'c':
1979                 if (index < 0 || index >= oc->nb_chapters) {
1980                     av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
1981                     exit_program(1);
1982                 }
1983                 m = &oc->chapters[index]->metadata;
1984                 break;
1985             default:
1986                 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
1987                 exit_program(1);
1988             }
1989             av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
1990         }
1991     }
1992
1993     return 0;
1994 }
1995
1996 static int opt_target(void *optctx, const char *opt, const char *arg)
1997 {
1998     OptionsContext *o = optctx;
1999     enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2000     static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2001
2002     if (!strncmp(arg, "pal-", 4)) {
2003         norm = PAL;
2004         arg += 4;
2005     } else if (!strncmp(arg, "ntsc-", 5)) {
2006         norm = NTSC;
2007         arg += 5;
2008     } else if (!strncmp(arg, "film-", 5)) {
2009         norm = FILM;
2010         arg += 5;
2011     } else {
2012         /* Try to determine PAL/NTSC by peeking in the input files */
2013         if (nb_input_files) {
2014             int i, j, fr;
2015             for (j = 0; j < nb_input_files; j++) {
2016                 for (i = 0; i < input_files[j]->nb_streams; i++) {
2017                     AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
2018                     if (c->codec_type != AVMEDIA_TYPE_VIDEO)
2019                         continue;
2020                     fr = c->time_base.den * 1000 / c->time_base.num;
2021                     if (fr == 25000) {
2022                         norm = PAL;
2023                         break;
2024                     } else if ((fr == 29970) || (fr == 23976)) {
2025                         norm = NTSC;
2026                         break;
2027                     }
2028                 }
2029                 if (norm != UNKNOWN)
2030                     break;
2031             }
2032         }
2033         if (norm != UNKNOWN)
2034             av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2035     }
2036
2037     if (norm == UNKNOWN) {
2038         av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2039         av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2040         av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2041         exit_program(1);
2042     }
2043
2044     if (!strcmp(arg, "vcd")) {
2045         opt_video_codec(o, "c:v", "mpeg1video");
2046         opt_audio_codec(o, "c:a", "mp2");
2047         parse_option(o, "f", "vcd", options);
2048         av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2049
2050         parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2051         parse_option(o, "r", frame_rates[norm], options);
2052         av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", 0);
2053
2054         av_dict_set(&o->g->codec_opts, "b:v", "1150000", 0);
2055         av_dict_set(&o->g->codec_opts, "maxrate", "1150000", 0);
2056         av_dict_set(&o->g->codec_opts, "minrate", "1150000", 0);
2057         av_dict_set(&o->g->codec_opts, "bufsize", "327680", 0); // 40*1024*8;
2058
2059         av_dict_set(&o->g->codec_opts, "b:a", "224000", 0);
2060         parse_option(o, "ar", "44100", options);
2061         parse_option(o, "ac", "2", options);
2062
2063         av_dict_set(&o->g->format_opts, "packetsize", "2324", 0);
2064         av_dict_set(&o->g->format_opts, "muxrate", "1411200", 0); // 2352 * 75 * 8;
2065
2066         /* We have to offset the PTS, so that it is consistent with the SCR.
2067            SCR starts at 36000, but the first two packs contain only padding
2068            and the first pack from the other stream, respectively, may also have
2069            been written before.
2070            So the real data starts at SCR 36000+3*1200. */
2071         o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2072     } else if (!strcmp(arg, "svcd")) {
2073
2074         opt_video_codec(o, "c:v", "mpeg2video");
2075         opt_audio_codec(o, "c:a", "mp2");
2076         parse_option(o, "f", "svcd", options);
2077
2078         parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2079         parse_option(o, "r", frame_rates[norm], options);
2080         parse_option(o, "pix_fmt", "yuv420p", options);
2081         av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", 0);
2082
2083         av_dict_set(&o->g->codec_opts, "b:v", "2040000", 0);
2084         av_dict_set(&o->g->codec_opts, "maxrate", "2516000", 0);
2085         av_dict_set(&o->g->codec_opts, "minrate", "0", 0); // 1145000;
2086         av_dict_set(&o->g->codec_opts, "bufsize", "1835008", 0); // 224*1024*8;
2087         av_dict_set(&o->g->codec_opts, "scan_offset", "1", 0);
2088
2089         av_dict_set(&o->g->codec_opts, "b:a", "224000", 0);
2090         parse_option(o, "ar", "44100", options);
2091
2092         av_dict_set(&o->g->format_opts, "packetsize", "2324", 0);
2093
2094     } else if (!strcmp(arg, "dvd")) {
2095
2096         opt_video_codec(o, "c:v", "mpeg2video");
2097         opt_audio_codec(o, "c:a", "ac3");
2098         parse_option(o, "f", "dvd", options);
2099
2100         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2101         parse_option(o, "r", frame_rates[norm], options);
2102         parse_option(o, "pix_fmt", "yuv420p", options);
2103         av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", 0);
2104
2105         av_dict_set(&o->g->codec_opts, "b:v", "6000000", 0);
2106         av_dict_set(&o->g->codec_opts, "maxrate", "9000000", 0);
2107         av_dict_set(&o->g->codec_opts, "minrate", "0", 0); // 1500000;
2108         av_dict_set(&o->g->codec_opts, "bufsize", "1835008", 0); // 224*1024*8;
2109
2110         av_dict_set(&o->g->format_opts, "packetsize", "2048", 0);  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
2111         av_dict_set(&o->g->format_opts, "muxrate", "10080000", 0); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2112
2113         av_dict_set(&o->g->codec_opts, "b:a", "448000", 0);
2114         parse_option(o, "ar", "48000", options);
2115
2116     } else if (!strncmp(arg, "dv", 2)) {
2117
2118         parse_option(o, "f", "dv", options);
2119
2120         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2121         parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2122                           norm == PAL ? "yuv420p" : "yuv411p", options);
2123         parse_option(o, "r", frame_rates[norm], options);
2124
2125         parse_option(o, "ar", "48000", options);
2126         parse_option(o, "ac", "2", options);
2127
2128     } else {
2129         av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2130         return AVERROR(EINVAL);
2131     }
2132     return 0;
2133 }
2134
2135 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2136 {
2137     av_free (vstats_filename);
2138     vstats_filename = av_strdup (arg);
2139     return 0;
2140 }
2141
2142 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2143 {
2144     char filename[40];
2145     time_t today2 = time(NULL);
2146     struct tm *today = localtime(&today2);
2147
2148     snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2149              today->tm_sec);
2150     return opt_vstats_file(NULL, opt, filename);
2151 }
2152
2153 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2154 {
2155     OptionsContext *o = optctx;
2156     return parse_option(o, "frames:v", arg, options);
2157 }
2158
2159 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2160 {
2161     OptionsContext *o = optctx;
2162     return parse_option(o, "frames:a", arg, options);
2163 }
2164
2165 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2166 {
2167     OptionsContext *o = optctx;
2168     return parse_option(o, "frames:d", arg, options);
2169 }
2170
2171 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2172 {
2173     int ret;
2174     AVDictionary *cbak = codec_opts;
2175     AVDictionary *fbak = format_opts;
2176     codec_opts = NULL;
2177     format_opts = NULL;
2178
2179     ret = opt_default(NULL, opt, arg);
2180
2181     av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2182     av_dict_copy(&o->g->format_opts, format_opts, 0);
2183     av_dict_free(&codec_opts);
2184     av_dict_free(&format_opts);
2185     codec_opts = cbak;
2186     format_opts = fbak;
2187
2188     return ret;
2189 }
2190
2191 static int opt_preset(void *optctx, const char *opt, const char *arg)
2192 {
2193     OptionsContext *o = optctx;
2194     FILE *f=NULL;
2195     char filename[1000], line[1000], tmp_line[1000];
2196     const char *codec_name = NULL;
2197
2198     tmp_line[0] = *opt;
2199     tmp_line[1] = 0;
2200     MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2201
2202     if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2203         if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2204             av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2205         }else
2206             av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2207         exit_program(1);
2208     }
2209
2210     while (fgets(line, sizeof(line), f)) {
2211         char *key = tmp_line, *value, *endptr;
2212
2213         if (strcspn(line, "#\n\r") == 0)
2214             continue;
2215         av_strlcpy(tmp_line, line, sizeof(tmp_line));
2216         if (!av_strtok(key,   "=",    &value) ||
2217             !av_strtok(value, "\r\n", &endptr)) {
2218             av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2219             exit_program(1);
2220         }
2221         av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2222
2223         if      (!strcmp(key, "acodec")) opt_audio_codec   (o, key, value);
2224         else if (!strcmp(key, "vcodec")) opt_video_codec   (o, key, value);
2225         else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2226         else if (!strcmp(key, "dcodec")) opt_data_codec    (o, key, value);
2227         else if (opt_default_new(o, key, value) < 0) {
2228             av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2229                    filename, line, key, value);
2230             exit_program(1);
2231         }
2232     }
2233
2234     fclose(f);
2235
2236     return 0;
2237 }
2238
2239 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2240 {
2241     OptionsContext *o = optctx;
2242     char *s = av_asprintf("%s:%c", opt + 1, *opt);
2243     int ret = parse_option(o, s, arg, options);
2244     av_free(s);
2245     return ret;
2246 }
2247
2248 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2249 {
2250     OptionsContext *o = optctx;
2251     if(!strcmp(opt, "b")){
2252         av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2253         av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2254         return 0;
2255     }
2256     av_dict_set(&o->g->codec_opts, opt, arg, 0);
2257     return 0;
2258 }
2259
2260 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2261 {
2262     OptionsContext *o = optctx;
2263     char *s;
2264     int ret;
2265     if(!strcmp(opt, "qscale")){
2266         av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2267         return parse_option(o, "q:v", arg, options);
2268     }
2269     s = av_asprintf("q%s", opt + 6);
2270     ret = parse_option(o, s, arg, options);
2271     av_free(s);
2272     return ret;
2273 }
2274
2275 static int opt_profile(void *optctx, const char *opt, const char *arg)
2276 {
2277     OptionsContext *o = optctx;
2278     if(!strcmp(opt, "profile")){
2279         av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2280         av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
2281         return 0;
2282     }
2283     av_dict_set(&o->g->codec_opts, opt, arg, 0);
2284     return 0;
2285 }
2286
2287 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2288 {
2289     OptionsContext *o = optctx;
2290     return parse_option(o, "filter:v", arg, options);
2291 }
2292
2293 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2294 {
2295     OptionsContext *o = optctx;
2296     return parse_option(o, "filter:a", arg, options);
2297 }
2298
2299 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2300 {
2301     if      (!av_strcasecmp(arg, "cfr"))         video_sync_method = VSYNC_CFR;
2302     else if (!av_strcasecmp(arg, "vfr"))         video_sync_method = VSYNC_VFR;
2303     else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2304     else if (!av_strcasecmp(arg, "drop"))        video_sync_method = VSYNC_DROP;
2305
2306     if (video_sync_method == VSYNC_AUTO)
2307         video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
2308     return 0;
2309 }
2310
2311 static int opt_timecode(void *optctx, const char *opt, const char *arg)
2312 {
2313     OptionsContext *o = optctx;
2314     char *tcr = av_asprintf("timecode=%s", arg);
2315     int ret = parse_option(o, "metadata:g", tcr, options);
2316     if (ret >= 0)
2317         ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
2318     av_free(tcr);
2319     return 0;
2320 }
2321
2322 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2323 {
2324     OptionsContext *o = optctx;
2325     char layout_str[32];
2326     char *stream_str;
2327     char *ac_str;
2328     int ret, channels, ac_str_size;
2329     uint64_t layout;
2330
2331     layout = av_get_channel_layout(arg);
2332     if (!layout) {
2333         av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2334         return AVERROR(EINVAL);
2335     }
2336     snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2337     ret = opt_default_new(o, opt, layout_str);
2338     if (ret < 0)
2339         return ret;
2340
2341     /* set 'ac' option based on channel layout */
2342     channels = av_get_channel_layout_nb_channels(layout);
2343     snprintf(layout_str, sizeof(layout_str), "%d", channels);
2344     stream_str = strchr(opt, ':');
2345     ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2346     ac_str = av_mallocz(ac_str_size);
2347     if (!ac_str)
2348         return AVERROR(ENOMEM);
2349     av_strlcpy(ac_str, "ac", 3);
2350     if (stream_str)
2351         av_strlcat(ac_str, stream_str, ac_str_size);
2352     ret = parse_option(o, ac_str, layout_str, options);
2353     av_free(ac_str);
2354
2355     return ret;
2356 }
2357
2358 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2359 {
2360     OptionsContext *o = optctx;
2361     return parse_option(o, "q:a", arg, options);
2362 }
2363
2364 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2365 {
2366     GROW_ARRAY(filtergraphs, nb_filtergraphs);
2367     if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2368         return AVERROR(ENOMEM);
2369     filtergraphs[nb_filtergraphs - 1]->index      = nb_filtergraphs - 1;
2370     filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
2371     if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
2372         return AVERROR(ENOMEM);
2373     return 0;
2374 }
2375
2376 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
2377 {
2378     uint8_t *graph_desc = read_file(arg);
2379     if (!graph_desc)
2380         return AVERROR(EINVAL);
2381
2382     GROW_ARRAY(filtergraphs, nb_filtergraphs);
2383     if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2384         return AVERROR(ENOMEM);
2385     filtergraphs[nb_filtergraphs - 1]->index      = nb_filtergraphs - 1;
2386     filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
2387     return 0;
2388 }
2389
2390 void show_help_default(const char *opt, const char *arg)
2391 {
2392     /* per-file options have at least one of those set */
2393     const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2394     int show_advanced = 0, show_avoptions = 0;
2395
2396     if (opt && *opt) {
2397         if (!strcmp(opt, "long"))
2398             show_advanced = 1;
2399         else if (!strcmp(opt, "full"))
2400             show_advanced = show_avoptions = 1;
2401         else
2402             av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2403     }
2404
2405     show_usage();
2406
2407     printf("Getting help:\n"
2408            "    -h      -- print basic options\n"
2409            "    -h long -- print more options\n"
2410            "    -h full -- print all options (including all format and codec specific options, very long)\n"
2411            "    See man %s for detailed description of the options.\n"
2412            "\n", program_name);
2413
2414     show_help_options(options, "Print help / information / capabilities:",
2415                       OPT_EXIT, 0, 0);
2416
2417     show_help_options(options, "Global options (affect whole program "
2418                       "instead of just one file:",
2419                       0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2420     if (show_advanced)
2421         show_help_options(options, "Advanced global options:", OPT_EXPERT,
2422                           per_file | OPT_EXIT, 0);
2423
2424     show_help_options(options, "Per-file main options:", 0,
2425                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
2426                       OPT_EXIT, per_file);
2427     if (show_advanced)
2428         show_help_options(options, "Advanced per-file options:",
2429                           OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2430
2431     show_help_options(options, "Video options:",
2432                       OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
2433     if (show_advanced)
2434         show_help_options(options, "Advanced Video options:",
2435                           OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2436
2437     show_help_options(options, "Audio options:",
2438                       OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2439     if (show_advanced)
2440         show_help_options(options, "Advanced Audio options:",
2441                           OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2442     show_help_options(options, "Subtitle options:",
2443                       OPT_SUBTITLE, 0, 0);
2444     printf("\n");
2445
2446     if (show_avoptions) {
2447         int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2448         show_help_children(avcodec_get_class(), flags);
2449         show_help_children(avformat_get_class(), flags);
2450         show_help_children(sws_get_class(), flags);
2451         show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
2452         show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM);
2453     }
2454 }
2455
2456 void show_usage(void)
2457 {
2458     av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
2459     av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2460     av_log(NULL, AV_LOG_INFO, "\n");
2461 }
2462
2463 enum OptGroup {
2464     GROUP_OUTFILE,
2465     GROUP_INFILE,
2466 };
2467
2468 static const OptionGroupDef groups[] = {
2469     [GROUP_OUTFILE] = { "output file",  NULL, OPT_OUTPUT },
2470     [GROUP_INFILE]  = { "input file",   "i",  OPT_INPUT },
2471 };
2472
2473 static int open_files(OptionGroupList *l, const char *inout,
2474                       int (*open_file)(OptionsContext*, const char*))
2475 {
2476     int i, ret;
2477
2478     for (i = 0; i < l->nb_groups; i++) {
2479         OptionGroup *g = &l->groups[i];
2480         OptionsContext o;
2481
2482         init_options(&o);
2483         o.g = g;
2484
2485         ret = parse_optgroup(&o, g);
2486         if (ret < 0) {
2487             av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
2488                    "%s.\n", inout, g->arg);
2489             return ret;
2490         }
2491
2492         av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
2493         ret = open_file(&o, g->arg);
2494         uninit_options(&o);
2495         if (ret < 0) {
2496             av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
2497                    inout, g->arg);
2498             return ret;
2499         }
2500         av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
2501     }
2502
2503     return 0;
2504 }
2505
2506 int ffmpeg_parse_options(int argc, char **argv)
2507 {
2508     OptionParseContext octx;
2509     uint8_t error[128];
2510     int ret;
2511
2512     memset(&octx, 0, sizeof(octx));
2513
2514     /* split the commandline into an internal representation */
2515     ret = split_commandline(&octx, argc, argv, options, groups,
2516                             FF_ARRAY_ELEMS(groups));
2517     if (ret < 0) {
2518         av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
2519         goto fail;
2520     }
2521
2522     /* apply global options */
2523     ret = parse_optgroup(NULL, &octx.global_opts);
2524     if (ret < 0) {
2525         av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
2526         goto fail;
2527     }
2528
2529     /* open input files */
2530     ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
2531     if (ret < 0) {
2532         av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
2533         goto fail;
2534     }
2535
2536     /* open output files */
2537     ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
2538     if (ret < 0) {
2539         av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
2540         goto fail;
2541     }
2542
2543 fail:
2544     uninit_parse_context(&octx);
2545     if (ret < 0) {
2546         av_strerror(ret, error, sizeof(error));
2547         av_log(NULL, AV_LOG_FATAL, "%s\n", error);
2548     }
2549     return ret;
2550 }
2551
2552 static int opt_progress(void *optctx, const char *opt, const char *arg)
2553 {
2554     AVIOContext *avio = NULL;
2555     int ret;
2556
2557     if (!strcmp(arg, "-"))
2558         arg = "pipe:";
2559     ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
2560     if (ret < 0) {
2561         av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
2562                arg, av_err2str(ret));
2563         return ret;
2564     }
2565     progress_avio = avio;
2566     return 0;
2567 }
2568
2569 #define OFFSET(x) offsetof(OptionsContext, x)
2570 const OptionDef options[] = {
2571     /* main options */
2572 #include "cmdutils_common_opts.h"
2573     { "f",              HAS_ARG | OPT_STRING | OPT_OFFSET |
2574                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(format) },
2575         "force format", "fmt" },
2576     { "y",              OPT_BOOL,                                    {              &file_overwrite },
2577         "overwrite output files" },
2578     { "n",              OPT_BOOL,                                    {              &no_file_overwrite },
2579         "never overwrite output files" },
2580     { "c",              HAS_ARG | OPT_STRING | OPT_SPEC |
2581                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(codec_names) },
2582         "codec name", "codec" },
2583     { "codec",          HAS_ARG | OPT_STRING | OPT_SPEC |
2584                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(codec_names) },
2585         "codec name", "codec" },
2586     { "pre",            HAS_ARG | OPT_STRING | OPT_SPEC |
2587                         OPT_OUTPUT,                                  { .off       = OFFSET(presets) },
2588         "preset name", "preset" },
2589     { "map",            HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2590                         OPT_OUTPUT,                                  { .func_arg = opt_map },
2591         "set input stream mapping",
2592         "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
2593     { "map_channel",    HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
2594         "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
2595     { "map_metadata",   HAS_ARG | OPT_STRING | OPT_SPEC |
2596                         OPT_OUTPUT,                                  { .off       = OFFSET(metadata_map) },
2597         "set metadata information of outfile from infile",
2598         "outfile[,metadata]:infile[,metadata]" },
2599     { "map_chapters",   HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
2600                         OPT_OUTPUT,                                  { .off = OFFSET(chapters_input_file) },
2601         "set chapters mapping", "input_file_index" },
2602     { "t",              HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(recording_time) },
2603         "record or transcode \"duration\" seconds of audio/video",
2604         "duration" },
2605     { "to",             HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_OUTPUT,  { .off = OFFSET(stop_time) },
2606         "record or transcode stop time", "time_stop" },
2607     { "fs",             HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
2608         "set the limit file size in bytes", "limit_size" },
2609     { "ss",             HAS_ARG | OPT_TIME | OPT_OFFSET |
2610                         OPT_INPUT | OPT_OUTPUT,                      { .off = OFFSET(start_time) },
2611         "set the start time offset", "time_off" },
2612     { "accurate_seek",  OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
2613                         OPT_INPUT,                                   { .off = OFFSET(accurate_seek) },
2614         "enable/disable accurate seeking with -ss" },
2615     { "itsoffset",      HAS_ARG | OPT_TIME | OPT_OFFSET |
2616                         OPT_EXPERT | OPT_INPUT,                      { .off = OFFSET(input_ts_offset) },
2617         "set the input ts offset", "time_off" },
2618     { "itsscale",       HAS_ARG | OPT_DOUBLE | OPT_SPEC |
2619                         OPT_EXPERT | OPT_INPUT,                      { .off = OFFSET(ts_scale) },
2620         "set the input ts scale", "scale" },
2621     { "timestamp",      HAS_ARG | OPT_PERFILE,                       { .func_arg = opt_recording_timestamp },
2622         "set the recording timestamp ('now' to set the current time)", "time" },
2623     { "metadata",       HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
2624         "add metadata", "string=string" },
2625     { "dframes",        HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2626                         OPT_OUTPUT,                                  { .func_arg = opt_data_frames },
2627         "set the number of data frames to record", "number" },
2628     { "benchmark",      OPT_BOOL | OPT_EXPERT,                       { &do_benchmark },
2629         "add timings for benchmarking" },
2630     { "benchmark_all",  OPT_BOOL | OPT_EXPERT,                       { &do_benchmark_all },
2631       "add timings for each task" },
2632     { "progress",       HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_progress },
2633       "write program-readable progress information", "url" },
2634     { "stdin",          OPT_BOOL | OPT_EXPERT,                       { &stdin_interaction },
2635       "enable or disable interaction on standard input" },
2636     { "timelimit",      HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_timelimit },
2637         "set max runtime in seconds", "limit" },
2638     { "dump",           OPT_BOOL | OPT_EXPERT,                       { &do_pkt_dump },
2639         "dump each input packet" },
2640     { "hex",            OPT_BOOL | OPT_EXPERT,                       { &do_hex_dump },
2641         "when dumping packets, also dump the payload" },
2642     { "re",             OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2643                         OPT_INPUT,                                   { .off = OFFSET(rate_emu) },
2644         "read input at native frame rate", "" },
2645     { "target",         HAS_ARG | OPT_PERFILE | OPT_OUTPUT,          { .func_arg = opt_target },
2646         "specify target file type (\"vcd\", \"svcd\", \"dvd\","
2647         " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2648     { "vsync",          HAS_ARG | OPT_EXPERT,                        { opt_vsync },
2649         "video sync method", "" },
2650     { "async",          HAS_ARG | OPT_INT | OPT_EXPERT,              { &audio_sync_method },
2651         "audio sync method", "" },
2652     { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,          { &audio_drift_threshold },
2653         "audio drift threshold", "threshold" },
2654     { "copyts",         OPT_BOOL | OPT_EXPERT,                       { &copy_ts },
2655         "copy timestamps" },
2656     { "copytb",         HAS_ARG | OPT_INT | OPT_EXPERT,              { &copy_tb },
2657         "copy input stream time base when stream copying", "mode" },
2658     { "shortest",       OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2659                         OPT_OUTPUT,                                  { .off = OFFSET(shortest) },
2660         "finish encoding within shortest input" },
2661     { "apad",           OPT_STRING | HAS_ARG | OPT_SPEC |
2662                         OPT_OUTPUT,                                  { .off = OFFSET(apad) },
2663         "audio pad", "" },
2664     { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,       { &dts_delta_threshold },
2665         "timestamp discontinuity delta threshold", "threshold" },
2666     { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,       { &dts_error_threshold },
2667         "timestamp error delta threshold", "threshold" },
2668     { "xerror",         OPT_BOOL | OPT_EXPERT,                       { &exit_on_error },
2669         "exit on error", "error" },
2670     { "copyinkf",       OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2671                         OPT_OUTPUT,                                  { .off = OFFSET(copy_initial_nonkeyframes) },
2672         "copy initial non-keyframes" },
2673     { "copypriorss",    OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT,   { .off = OFFSET(copy_prior_start) },
2674         "copy or discard frames before start time" },
2675     { "frames",         OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
2676         "set the number of frames to record", "number" },
2677     { "tag",            OPT_STRING | HAS_ARG | OPT_SPEC |
2678                         OPT_EXPERT | OPT_OUTPUT,                     { .off = OFFSET(codec_tags) },
2679         "force codec tag/fourcc", "fourcc/tag" },
2680     { "q",              HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
2681                         OPT_SPEC | OPT_OUTPUT,                       { .off = OFFSET(qscale) },
2682         "use fixed quality scale (VBR)", "q" },
2683     { "qscale",         HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2684                         OPT_OUTPUT,                                  { .func_arg = opt_qscale },
2685         "use fixed quality scale (VBR)", "q" },
2686     { "profile",        HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
2687         "set profile", "profile" },
2688     { "filter",         HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
2689         "set stream filtergraph", "filter_graph" },
2690     { "filter_script",  HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
2691         "read stream filtergraph description from a file", "filename" },
2692     { "reinit_filter",  HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT,    { .off = OFFSET(reinit_filters) },
2693         "reinit filtergraph on input parameter changes", "" },
2694     { "filter_complex", HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_filter_complex },
2695         "create a complex filtergraph", "graph_description" },
2696     { "lavfi",          HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_filter_complex },
2697         "create a complex filtergraph", "graph_description" },
2698     { "filter_complex_script", HAS_ARG | OPT_EXPERT,                 { .func_arg = opt_filter_complex_script },
2699         "read complex filtergraph description from a file", "filename" },
2700     { "stats",          OPT_BOOL,                                    { &print_stats },
2701         "print progress report during encoding", },
2702     { "attach",         HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2703                         OPT_OUTPUT,                                  { .func_arg = opt_attach },
2704         "add an attachment to the output file", "filename" },
2705     { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
2706                          OPT_EXPERT | OPT_INPUT,                     { .off = OFFSET(dump_attachment) },
2707         "extract an attachment into a file", "filename" },
2708     { "debug_ts",       OPT_BOOL | OPT_EXPERT,                       { &debug_ts },
2709         "print timestamp debugging info" },
2710
2711     /* video options */
2712     { "vframes",      OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_video_frames },
2713         "set the number of video frames to record", "number" },
2714     { "r",            OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC |
2715                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_rates) },
2716         "set frame rate (Hz value, fraction or abbreviation)", "rate" },
2717     { "s",            OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC |
2718                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_sizes) },
2719         "set frame size (WxH or abbreviation)", "size" },
2720     { "aspect",       OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC |
2721                       OPT_OUTPUT,                                                { .off = OFFSET(frame_aspect_ratios) },
2722         "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
2723     { "pix_fmt",      OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
2724                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_pix_fmts) },
2725         "set pixel format", "format" },
2726     { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG,                      { &frame_bits_per_raw_sample },
2727         "set the number of bits per raw sample", "number" },
2728     { "intra",        OPT_VIDEO | OPT_BOOL | OPT_EXPERT,                         { &intra_only },
2729         "deprecated use -g 1" },
2730     { "vn",           OPT_VIDEO | OPT_BOOL  | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) },
2731         "disable video" },
2732     { "vdt",          OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT ,               { &video_discard },
2733         "discard threshold", "n" },
2734     { "rc_override",  OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
2735                       OPT_OUTPUT,                                                { .off = OFFSET(rc_overrides) },
2736         "rate control override for specific intervals", "override" },
2737     { "vcodec",       OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_INPUT |
2738                       OPT_OUTPUT,                                                { .func_arg = opt_video_codec },
2739         "force video codec ('copy' to copy stream)", "codec" },
2740     { "sameq",        OPT_VIDEO | OPT_EXPERT ,                                   { .func_arg = opt_sameq },
2741         "Removed" },
2742     { "same_quant",   OPT_VIDEO | OPT_EXPERT ,                                   { .func_arg = opt_sameq },
2743         "Removed" },
2744     { "timecode",     OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT,            { .func_arg = opt_timecode },
2745         "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
2746     { "pass",         OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT,     { .off = OFFSET(pass) },
2747         "select the pass number (1 to 3)", "n" },
2748     { "passlogfile",  OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
2749                       OPT_OUTPUT,                                                { .off = OFFSET(passlogfiles) },
2750         "select two pass log file name prefix", "prefix" },
2751     { "deinterlace",  OPT_VIDEO | OPT_BOOL | OPT_EXPERT,                         { &do_deinterlace },
2752         "this option is deprecated, use the yadif filter instead" },
2753     { "psnr",         OPT_VIDEO | OPT_BOOL | OPT_EXPERT,                         { &do_psnr },
2754         "calculate PSNR of compressed frames" },
2755     { "vstats",       OPT_VIDEO | OPT_EXPERT ,                                   { &opt_vstats },
2756         "dump video coding statistics to file" },
2757     { "vstats_file",  OPT_VIDEO | HAS_ARG | OPT_EXPERT ,                         { opt_vstats_file },
2758         "dump video coding statistics to file", "file" },
2759     { "vf",           OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_video_filters },
2760         "set video filters", "filter_graph" },
2761     { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
2762                       OPT_OUTPUT,                                                { .off = OFFSET(intra_matrices) },
2763         "specify intra matrix coeffs", "matrix" },
2764     { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
2765                       OPT_OUTPUT,                                                { .off = OFFSET(inter_matrices) },
2766         "specify inter matrix coeffs", "matrix" },
2767     { "top",          OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_INT| OPT_SPEC |
2768                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(top_field_first) },
2769         "top=1/bottom=0/auto=-1 field first", "" },
2770     { "dc",           OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT ,               { &intra_dc_precision },
2771         "intra_dc_precision", "precision" },
2772     { "vtag",         OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_PERFILE |
2773                       OPT_OUTPUT,                                                { .func_arg = opt_old2new },
2774         "force video tag/fourcc", "fourcc/tag" },
2775     { "qphist",       OPT_VIDEO | OPT_BOOL | OPT_EXPERT ,                        { &qp_hist },
2776         "show QP histogram" },
2777     { "force_fps",    OPT_VIDEO | OPT_BOOL | OPT_EXPERT  | OPT_SPEC |
2778                       OPT_OUTPUT,                                                { .off = OFFSET(force_fps) },
2779         "force the selected framerate, disable the best supported framerate selection" },
2780     { "streamid",     OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2781                       OPT_OUTPUT,                                                { .func_arg = opt_streamid },
2782         "set the value of an outfile streamid", "streamIndex:value" },
2783     { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2784                           OPT_SPEC | OPT_OUTPUT,                                 { .off = OFFSET(forced_key_frames) },
2785         "force key frames at specified timestamps", "timestamps" },
2786     { "b",            OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT,            { .func_arg = opt_bitrate },
2787         "video bitrate (please use -b:v)", "bitrate" },
2788
2789     /* audio options */
2790     { "aframes",        OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_frames },
2791         "set the number of audio frames to record", "number" },
2792     { "aq",             OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_qscale },
2793         "set audio quality (codec-specific)", "quality", },
2794     { "ar",             OPT_AUDIO | HAS_ARG  | OPT_INT | OPT_SPEC |
2795                         OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(audio_sample_rate) },
2796         "set audio sampling rate (in Hz)", "rate" },
2797     { "ac",             OPT_AUDIO | HAS_ARG  | OPT_INT | OPT_SPEC |
2798                         OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(audio_channels) },
2799         "set number of audio channels", "channels" },
2800     { "an",             OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) },
2801         "disable audio" },
2802     { "acodec",         OPT_AUDIO | HAS_ARG  | OPT_PERFILE |
2803                         OPT_INPUT | OPT_OUTPUT,                                    { .func_arg = opt_audio_codec },
2804         "force audio codec ('copy' to copy stream)", "codec" },
2805     { "atag",           OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_PERFILE |
2806                         OPT_OUTPUT,                                                { .func_arg = opt_old2new },
2807         "force audio tag/fourcc", "fourcc/tag" },
2808     { "vol",            OPT_AUDIO | HAS_ARG  | OPT_INT,                            { &audio_volume },
2809         "change audio volume (256=normal)" , "volume" },
2810     { "sample_fmt",     OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_SPEC |
2811                         OPT_STRING | OPT_INPUT | OPT_OUTPUT,                       { .off = OFFSET(sample_fmts) },
2812         "set sample format", "format" },
2813     { "channel_layout", OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_PERFILE |
2814                         OPT_INPUT | OPT_OUTPUT,                                    { .func_arg = opt_channel_layout },
2815         "set channel layout", "layout" },
2816     { "af",             OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_filters },
2817         "set audio filters", "filter_graph" },
2818     { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
2819       "set the maximum number of channels to try to guess the channel layout" },
2820
2821     /* subtitle options */
2822     { "sn",     OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
2823         "disable subtitle" },
2824     { "scodec", OPT_SUBTITLE | HAS_ARG  | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
2825         "force subtitle codec ('copy' to copy stream)", "codec" },
2826     { "stag",   OPT_SUBTITLE | HAS_ARG  | OPT_EXPERT  | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
2827         , "force subtitle tag/fourcc", "fourcc/tag" },
2828     { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
2829         "fix subtitles duration" },
2830     { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
2831         "set canvas size (WxH or abbreviation)", "size" },
2832
2833     /* grab options */
2834     { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
2835         "deprecated, use -channel", "channel" },
2836     { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
2837         "deprecated, use -standard", "standard" },
2838     { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
2839
2840     /* muxer options */
2841     { "muxdelay",   OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
2842         "set the maximum demux-decode delay", "seconds" },
2843     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
2844         "set the initial demux-decode delay", "seconds" },
2845     { "override_ffserver", OPT_BOOL | OPT_EXPERT | OPT_OUTPUT, { &override_ffserver },
2846         "override the options from ffserver", "" },
2847
2848     { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
2849         "A comma-separated list of bitstream filters", "bitstream_filters" },
2850     { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
2851         "deprecated", "audio bitstream_filters" },
2852     { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
2853         "deprecated", "video bitstream_filters" },
2854
2855     { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT,    { .func_arg = opt_preset },
2856         "set the audio options to the indicated preset", "preset" },
2857     { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT,    { .func_arg = opt_preset },
2858         "set the video options to the indicated preset", "preset" },
2859     { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
2860         "set the subtitle options to the indicated preset", "preset" },
2861     { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT,                { .func_arg = opt_preset },
2862         "set options from indicated preset file", "filename" },
2863     /* data codec support */
2864     { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
2865         "force data codec ('copy' to copy stream)", "codec" },
2866     { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },
2867         "disable data" },
2868
2869     { NULL, },
2870 };