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