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