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