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