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