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