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