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