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