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