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