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