ffmpeg: support setting the chroma intra matrix
[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         char *chroma_intra_matrix = NULL;
1269         int do_pass = 0;
1270         int i;
1271
1272         MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1273         if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1274             av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1275             exit_program(1);
1276         }
1277
1278         video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1279         MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1280         if (frame_pix_fmt && *frame_pix_fmt == '+') {
1281             ost->keep_pix_fmt = 1;
1282             if (!*++frame_pix_fmt)
1283                 frame_pix_fmt = NULL;
1284         }
1285         if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1286             av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1287             exit_program(1);
1288         }
1289         st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1290
1291         if (intra_only)
1292             video_enc->gop_size = 0;
1293         MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1294         if (intra_matrix) {
1295             if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1296                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1297                 exit_program(1);
1298             }
1299             parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1300         }
1301         MATCH_PER_STREAM_OPT(chroma_intra_matrices, str, chroma_intra_matrix, oc, st);
1302         if (chroma_intra_matrix) {
1303             uint16_t *p = av_mallocz(sizeof(*video_enc->chroma_intra_matrix) * 64);
1304             if (!p) {
1305                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1306                 exit_program(1);
1307             }
1308             av_codec_set_chroma_intra_matrix(video_enc, p);
1309             parse_matrix_coeffs(p, chroma_intra_matrix);
1310         }
1311         MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1312         if (inter_matrix) {
1313             if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1314                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1315                 exit_program(1);
1316             }
1317             parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1318         }
1319
1320         MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1321         for (i = 0; p; i++) {
1322             int start, end, q;
1323             int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1324             if (e != 3) {
1325                 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1326                 exit_program(1);
1327             }
1328             /* FIXME realloc failure */
1329             video_enc->rc_override =
1330                 av_realloc(video_enc->rc_override,
1331                            sizeof(RcOverride) * (i + 1));
1332             video_enc->rc_override[i].start_frame = start;
1333             video_enc->rc_override[i].end_frame   = end;
1334             if (q > 0) {
1335                 video_enc->rc_override[i].qscale         = q;
1336                 video_enc->rc_override[i].quality_factor = 1.0;
1337             }
1338             else {
1339                 video_enc->rc_override[i].qscale         = 0;
1340                 video_enc->rc_override[i].quality_factor = -q/100.0;
1341             }
1342             p = strchr(p, '/');
1343             if (p) p++;
1344         }
1345         video_enc->rc_override_count = i;
1346         video_enc->intra_dc_precision = intra_dc_precision - 8;
1347
1348         if (do_psnr)
1349             video_enc->flags|= CODEC_FLAG_PSNR;
1350
1351         /* two pass mode */
1352         MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1353         if (do_pass) {
1354             if (do_pass & 1) {
1355                 video_enc->flags |= CODEC_FLAG_PASS1;
1356                 av_dict_set(&ost->opts, "flags", "+pass1", AV_DICT_APPEND);
1357             }
1358             if (do_pass & 2) {
1359                 video_enc->flags |= CODEC_FLAG_PASS2;
1360                 av_dict_set(&ost->opts, "flags", "+pass2", AV_DICT_APPEND);
1361             }
1362         }
1363
1364         MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1365         if (ost->logfile_prefix &&
1366             !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1367             exit_program(1);
1368
1369         MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1370         if (ost->forced_keyframes)
1371             ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1372
1373         MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1374
1375         ost->top_field_first = -1;
1376         MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1377
1378
1379         ost->avfilter = get_ost_filters(o, oc, ost);
1380         if (!ost->avfilter)
1381             exit_program(1);
1382     } else {
1383         MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1384     }
1385
1386     if (ost->stream_copy)
1387         check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_VIDEO);
1388
1389     return ost;
1390 }
1391
1392 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1393 {
1394     int n;
1395     AVStream *st;
1396     OutputStream *ost;
1397     AVCodecContext *audio_enc;
1398
1399     ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1400     st  = ost->st;
1401
1402     audio_enc = st->codec;
1403     audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1404
1405     MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1406     MATCH_PER_STREAM_OPT(filters,        str, ost->filters,        oc, st);
1407
1408     if (!ost->stream_copy) {
1409         char *sample_fmt = NULL;
1410
1411         MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1412
1413         MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1414         if (sample_fmt &&
1415             (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1416             av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1417             exit_program(1);
1418         }
1419
1420         MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1421
1422         MATCH_PER_STREAM_OPT(apad, str, ost->apad, oc, st);
1423         ost->apad = av_strdup(ost->apad);
1424
1425         ost->avfilter = get_ost_filters(o, oc, ost);
1426         if (!ost->avfilter)
1427             exit_program(1);
1428
1429         /* check for channel mapping for this audio stream */
1430         for (n = 0; n < o->nb_audio_channel_maps; n++) {
1431             AudioChannelMap *map = &o->audio_channel_maps[n];
1432             InputStream *ist = input_streams[ost->source_index];
1433             if ((map->channel_idx == -1 || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) &&
1434                 (map->ofile_idx   == -1 || ost->file_index == map->ofile_idx) &&
1435                 (map->ostream_idx == -1 || ost->st->index  == map->ostream_idx)) {
1436                 if (ost->audio_channels_mapped < FF_ARRAY_ELEMS(ost->audio_channels_map))
1437                     ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1438                 else
1439                     av_log(NULL, AV_LOG_FATAL, "Max channel mapping for output %d.%d reached\n",
1440                            ost->file_index, ost->st->index);
1441             }
1442         }
1443     }
1444
1445     if (ost->stream_copy)
1446         check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_AUDIO);
1447
1448     return ost;
1449 }
1450
1451 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1452 {
1453     OutputStream *ost;
1454
1455     ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1456     if (!ost->stream_copy) {
1457         av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1458         exit_program(1);
1459     }
1460
1461     return ost;
1462 }
1463
1464 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1465 {
1466     OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1467     ost->stream_copy = 1;
1468     ost->finished    = 1;
1469     return ost;
1470 }
1471
1472 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1473 {
1474     AVStream *st;
1475     OutputStream *ost;
1476     AVCodecContext *subtitle_enc;
1477
1478     ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1479     st  = ost->st;
1480     subtitle_enc = st->codec;
1481
1482     subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1483
1484     MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1485
1486     if (!ost->stream_copy) {
1487         char *frame_size = NULL;
1488
1489         MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1490         if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1491             av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1492             exit_program(1);
1493         }
1494     }
1495
1496     return ost;
1497 }
1498
1499 /* arg format is "output-stream-index:streamid-value". */
1500 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1501 {
1502     OptionsContext *o = optctx;
1503     int idx;
1504     char *p;
1505     char idx_str[16];
1506
1507     av_strlcpy(idx_str, arg, sizeof(idx_str));
1508     p = strchr(idx_str, ':');
1509     if (!p) {
1510         av_log(NULL, AV_LOG_FATAL,
1511                "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1512                arg, opt);
1513         exit_program(1);
1514     }
1515     *p++ = '\0';
1516     idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1517     o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1518     o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1519     return 0;
1520 }
1521
1522 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1523 {
1524     AVFormatContext *is = ifile->ctx;
1525     AVFormatContext *os = ofile->ctx;
1526     AVChapter **tmp;
1527     int i;
1528
1529     tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1530     if (!tmp)
1531         return AVERROR(ENOMEM);
1532     os->chapters = tmp;
1533
1534     for (i = 0; i < is->nb_chapters; i++) {
1535         AVChapter *in_ch = is->chapters[i], *out_ch;
1536         int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
1537         int64_t ts_off   = av_rescale_q(start_time - ifile->ts_offset,
1538                                        AV_TIME_BASE_Q, in_ch->time_base);
1539         int64_t rt       = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1540                            av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1541
1542
1543         if (in_ch->end < ts_off)
1544             continue;
1545         if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1546             break;
1547
1548         out_ch = av_mallocz(sizeof(AVChapter));
1549         if (!out_ch)
1550             return AVERROR(ENOMEM);
1551
1552         out_ch->id        = in_ch->id;
1553         out_ch->time_base = in_ch->time_base;
1554         out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
1555         out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
1556
1557         if (copy_metadata)
1558             av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1559
1560         os->chapters[os->nb_chapters++] = out_ch;
1561     }
1562     return 0;
1563 }
1564
1565 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
1566 {
1567     int i, err;
1568     AVFormatContext *ic = avformat_alloc_context();
1569
1570     ic->interrupt_callback = int_cb;
1571     err = avformat_open_input(&ic, filename, NULL, NULL);
1572     if (err < 0)
1573         return err;
1574     /* copy stream format */
1575     for(i=0;i<ic->nb_streams;i++) {
1576         AVStream *st;
1577         OutputStream *ost;
1578         AVCodec *codec;
1579         AVCodecContext *avctx;
1580
1581         codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
1582         ost   = new_output_stream(o, s, codec->type, -1);
1583         st    = ost->st;
1584         avctx = st->codec;
1585         ost->enc = codec;
1586
1587         // FIXME: a more elegant solution is needed
1588         memcpy(st, ic->streams[i], sizeof(AVStream));
1589         st->cur_dts = 0;
1590         st->info = av_malloc(sizeof(*st->info));
1591         memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
1592         st->codec= avctx;
1593         avcodec_copy_context(st->codec, ic->streams[i]->codec);
1594
1595         if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
1596             choose_sample_fmt(st, codec);
1597         else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
1598             choose_pixel_fmt(st, codec, st->codec->pix_fmt);
1599     }
1600
1601     avformat_close_input(&ic);
1602     return err;
1603 }
1604
1605 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1606                                AVFormatContext *oc)
1607 {
1608     OutputStream *ost;
1609
1610     switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1611                                   ofilter->out_tmp->pad_idx)) {
1612     case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
1613     case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
1614     default:
1615         av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1616                "currently.\n");
1617         exit_program(1);
1618     }
1619
1620     ost->source_index = -1;
1621     ost->filter       = ofilter;
1622
1623     ofilter->ost      = ost;
1624
1625     if (ost->stream_copy) {
1626         av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1627                "which is fed from a complex filtergraph. Filtering and streamcopy "
1628                "cannot be used together.\n", ost->file_index, ost->index);
1629         exit_program(1);
1630     }
1631
1632     if (ost->avfilter && (ost->filters || ost->filters_script)) {
1633         const char *opt = ost->filters ? "-vf/-af/-filter" : "-filter_script";
1634         av_log(NULL, AV_LOG_ERROR,
1635                "%s '%s' was specified through the %s option "
1636                "for output stream %d:%d, which is fed from a complex filtergraph.\n"
1637                "%s and -filter_complex cannot be used together for the same stream.\n",
1638                ost->filters ? "Filtergraph" : "Filtergraph script",
1639                ost->filters ? ost->filters : ost->filters_script,
1640                opt, ost->file_index, ost->index, opt);
1641         exit_program(1);
1642     }
1643
1644     if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
1645         av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
1646         exit_program(1);
1647     }
1648     avfilter_inout_free(&ofilter->out_tmp);
1649 }
1650
1651 static int configure_complex_filters(void)
1652 {
1653     int i, ret = 0;
1654
1655     for (i = 0; i < nb_filtergraphs; i++)
1656         if (!filtergraphs[i]->graph &&
1657             (ret = configure_filtergraph(filtergraphs[i])) < 0)
1658             return ret;
1659     return 0;
1660 }
1661
1662 static int open_output_file(OptionsContext *o, const char *filename)
1663 {
1664     AVFormatContext *oc;
1665     int i, j, err;
1666     AVOutputFormat *file_oformat;
1667     OutputFile *of;
1668     OutputStream *ost;
1669     InputStream  *ist;
1670     AVDictionary *unused_opts = NULL;
1671     AVDictionaryEntry *e = NULL;
1672
1673     if (configure_complex_filters() < 0) {
1674         av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
1675         exit_program(1);
1676     }
1677
1678     if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
1679         o->stop_time = INT64_MAX;
1680         av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
1681     }
1682
1683     if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
1684         int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
1685         if (o->stop_time <= start_time) {
1686             av_log(NULL, AV_LOG_WARNING, "-to value smaller than -ss; ignoring -to.\n");
1687             o->stop_time = INT64_MAX;
1688         } else {
1689             o->recording_time = o->stop_time - start_time;
1690         }
1691     }
1692
1693     GROW_ARRAY(output_files, nb_output_files);
1694     of = av_mallocz(sizeof(*of));
1695     if (!of)
1696         exit_program(1);
1697     output_files[nb_output_files - 1] = of;
1698
1699     of->ost_index      = nb_output_streams;
1700     of->recording_time = o->recording_time;
1701     of->start_time     = o->start_time;
1702     of->limit_filesize = o->limit_filesize;
1703     of->shortest       = o->shortest;
1704     av_dict_copy(&of->opts, o->g->format_opts, 0);
1705
1706     if (!strcmp(filename, "-"))
1707         filename = "pipe:";
1708
1709     err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
1710     if (!oc) {
1711         print_error(filename, err);
1712         exit_program(1);
1713     }
1714
1715     of->ctx = oc;
1716     if (o->recording_time != INT64_MAX)
1717         oc->duration = o->recording_time;
1718
1719     file_oformat= oc->oformat;
1720     oc->interrupt_callback = int_cb;
1721
1722     /* create streams for all unlabeled output pads */
1723     for (i = 0; i < nb_filtergraphs; i++) {
1724         FilterGraph *fg = filtergraphs[i];
1725         for (j = 0; j < fg->nb_outputs; j++) {
1726             OutputFilter *ofilter = fg->outputs[j];
1727
1728             if (!ofilter->out_tmp || ofilter->out_tmp->name)
1729                 continue;
1730
1731             switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1732                                           ofilter->out_tmp->pad_idx)) {
1733             case AVMEDIA_TYPE_VIDEO:    o->video_disable    = 1; break;
1734             case AVMEDIA_TYPE_AUDIO:    o->audio_disable    = 1; break;
1735             case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1736             }
1737             init_output_filter(ofilter, o, oc);
1738         }
1739     }
1740
1741     /* ffserver seeking with date=... needs a date reference */
1742     if (!strcmp(file_oformat->name, "ffm") &&
1743         av_strstart(filename, "http:", NULL)) {
1744         int err = parse_option(o, "metadata", "creation_time=now", options);
1745         if (err < 0) {
1746             print_error(filename, err);
1747             exit_program(1);
1748         }
1749     }
1750
1751     if (!strcmp(file_oformat->name, "ffm") && !override_ffserver &&
1752         av_strstart(filename, "http:", NULL)) {
1753         int j;
1754         /* special case for files sent to ffserver: we get the stream
1755            parameters from ffserver */
1756         int err = read_ffserver_streams(o, oc, filename);
1757         if (err < 0) {
1758             print_error(filename, err);
1759             exit_program(1);
1760         }
1761         for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
1762             ost = output_streams[j];
1763             for (i = 0; i < nb_input_streams; i++) {
1764                 ist = input_streams[i];
1765                 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
1766                     ost->sync_ist= ist;
1767                     ost->source_index= i;
1768                     if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
1769                     if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
1770                     ist->discard = 0;
1771                     ist->st->discard = AVDISCARD_NONE;
1772                     break;
1773                 }
1774             }
1775             if(!ost->sync_ist){
1776                 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));
1777                 exit_program(1);
1778             }
1779         }
1780     } else if (!o->nb_stream_maps) {
1781         char *subtitle_codec_name = NULL;
1782         /* pick the "best" stream of each type */
1783
1784         /* video: highest resolution */
1785         if (!o->video_disable && oc->oformat->video_codec != AV_CODEC_ID_NONE) {
1786             int area = 0, idx = -1;
1787             int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
1788             for (i = 0; i < nb_input_streams; i++) {
1789                 int new_area;
1790                 ist = input_streams[i];
1791                 new_area = ist->st->codec->width * ist->st->codec->height;
1792                 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1793                     new_area = 1;
1794                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1795                     new_area > area) {
1796                     if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1797                         continue;
1798                     area = new_area;
1799                     idx = i;
1800                 }
1801             }
1802             if (idx >= 0)
1803                 new_video_stream(o, oc, idx);
1804         }
1805
1806         /* audio: most channels */
1807         if (!o->audio_disable && oc->oformat->audio_codec != AV_CODEC_ID_NONE) {
1808             int channels = 0, idx = -1;
1809             for (i = 0; i < nb_input_streams; i++) {
1810                 ist = input_streams[i];
1811                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1812                     ist->st->codec->channels > channels) {
1813                     channels = ist->st->codec->channels;
1814                     idx = i;
1815                 }
1816             }
1817             if (idx >= 0)
1818                 new_audio_stream(o, oc, idx);
1819         }
1820
1821         /* subtitles: pick first */
1822         MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
1823         if (!o->subtitle_disable && (oc->oformat->subtitle_codec != AV_CODEC_ID_NONE || subtitle_codec_name)) {
1824             for (i = 0; i < nb_input_streams; i++)
1825                 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1826                     new_subtitle_stream(o, oc, i);
1827                     break;
1828                 }
1829         }
1830         /* do something with data? */
1831     } else {
1832         for (i = 0; i < o->nb_stream_maps; i++) {
1833             StreamMap *map = &o->stream_maps[i];
1834
1835             if (map->disabled)
1836                 continue;
1837
1838             if (map->linklabel) {
1839                 FilterGraph *fg;
1840                 OutputFilter *ofilter = NULL;
1841                 int j, k;
1842
1843                 for (j = 0; j < nb_filtergraphs; j++) {
1844                     fg = filtergraphs[j];
1845                     for (k = 0; k < fg->nb_outputs; k++) {
1846                         AVFilterInOut *out = fg->outputs[k]->out_tmp;
1847                         if (out && !strcmp(out->name, map->linklabel)) {
1848                             ofilter = fg->outputs[k];
1849                             goto loop_end;
1850                         }
1851                     }
1852                 }
1853 loop_end:
1854                 if (!ofilter) {
1855                     av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1856                            "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
1857                     exit_program(1);
1858                 }
1859                 init_output_filter(ofilter, o, oc);
1860             } else {
1861                 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
1862
1863                 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
1864                 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
1865                     continue;
1866                 if(o->   audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1867                     continue;
1868                 if(o->   video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
1869                     continue;
1870                 if(o->    data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
1871                     continue;
1872
1873                 switch (ist->st->codec->codec_type) {
1874                 case AVMEDIA_TYPE_VIDEO:      ost = new_video_stream     (o, oc, src_idx); break;
1875                 case AVMEDIA_TYPE_AUDIO:      ost = new_audio_stream     (o, oc, src_idx); break;
1876                 case AVMEDIA_TYPE_SUBTITLE:   ost = new_subtitle_stream  (o, oc, src_idx); break;
1877                 case AVMEDIA_TYPE_DATA:       ost = new_data_stream      (o, oc, src_idx); break;
1878                 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
1879                 default:
1880                     av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
1881                            map->file_index, map->stream_index);
1882                     exit_program(1);
1883                 }
1884             }
1885         }
1886     }
1887
1888     /* handle attached files */
1889     for (i = 0; i < o->nb_attachments; i++) {
1890         AVIOContext *pb;
1891         uint8_t *attachment;
1892         const char *p;
1893         int64_t len;
1894
1895         if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
1896             av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
1897                    o->attachments[i]);
1898             exit_program(1);
1899         }
1900         if ((len = avio_size(pb)) <= 0) {
1901             av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
1902                    o->attachments[i]);
1903             exit_program(1);
1904         }
1905         if (!(attachment = av_malloc(len))) {
1906             av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
1907                    o->attachments[i]);
1908             exit_program(1);
1909         }
1910         avio_read(pb, attachment, len);
1911
1912         ost = new_attachment_stream(o, oc, -1);
1913         ost->stream_copy               = 0;
1914         ost->attachment_filename       = o->attachments[i];
1915         ost->finished                  = 1;
1916         ost->st->codec->extradata      = attachment;
1917         ost->st->codec->extradata_size = len;
1918
1919         p = strrchr(o->attachments[i], '/');
1920         av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
1921         avio_close(pb);
1922     }
1923
1924     for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
1925         AVDictionaryEntry *e;
1926         ost = output_streams[i];
1927
1928         if ((ost->stream_copy || ost->attachment_filename)
1929             && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
1930             && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
1931             if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
1932                 exit_program(1);
1933     }
1934
1935     /* check if all codec options have been used */
1936     unused_opts = strip_specifiers(o->g->codec_opts);
1937     for (i = of->ost_index; i < nb_output_streams; i++) {
1938         e = NULL;
1939         while ((e = av_dict_get(output_streams[i]->opts, "", e,
1940                                 AV_DICT_IGNORE_SUFFIX)))
1941             av_dict_set(&unused_opts, e->key, NULL, 0);
1942     }
1943
1944     e = NULL;
1945     while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
1946         const AVClass *class = avcodec_get_class();
1947         const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
1948                                              AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1949         if (!option)
1950             continue;
1951         if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
1952             av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
1953                    "output file #%d (%s) is not an encoding option.\n", e->key,
1954                    option->help ? option->help : "", nb_output_files - 1,
1955                    filename);
1956             exit_program(1);
1957         }
1958
1959         // gop_timecode is injected by generic code but not always used
1960         if (!strcmp(e->key, "gop_timecode"))
1961             continue;
1962
1963         av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
1964                "output file #%d (%s) has not been used for any stream. The most "
1965                "likely reason is either wrong type (e.g. a video option with "
1966                "no video streams) or that it is a private option of some encoder "
1967                "which was not actually used for any stream.\n", e->key,
1968                option->help ? option->help : "", nb_output_files - 1, filename);
1969     }
1970     av_dict_free(&unused_opts);
1971
1972     /* check filename in case of an image number is expected */
1973     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
1974         if (!av_filename_number_test(oc->filename)) {
1975             print_error(oc->filename, AVERROR(EINVAL));
1976             exit_program(1);
1977         }
1978     }
1979
1980     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
1981         /* test if it already exists to avoid losing precious files */
1982         assert_file_overwrite(filename);
1983
1984         /* open the file */
1985         if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
1986                               &oc->interrupt_callback,
1987                               &of->opts)) < 0) {
1988             print_error(filename, err);
1989             exit_program(1);
1990         }
1991     } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
1992         assert_file_overwrite(filename);
1993
1994     if (o->mux_preload) {
1995         uint8_t buf[64];
1996         snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
1997         av_dict_set(&of->opts, "preload", buf, 0);
1998     }
1999     oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
2000
2001     /* copy metadata */
2002     for (i = 0; i < o->nb_metadata_map; i++) {
2003         char *p;
2004         int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
2005
2006         if (in_file_index >= nb_input_files) {
2007             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
2008             exit_program(1);
2009         }
2010         copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
2011                       in_file_index >= 0 ?
2012                       input_files[in_file_index]->ctx : NULL, o);
2013     }
2014
2015     /* copy chapters */
2016     if (o->chapters_input_file >= nb_input_files) {
2017         if (o->chapters_input_file == INT_MAX) {
2018             /* copy chapters from the first input file that has them*/
2019             o->chapters_input_file = -1;
2020             for (i = 0; i < nb_input_files; i++)
2021                 if (input_files[i]->ctx->nb_chapters) {
2022                     o->chapters_input_file = i;
2023                     break;
2024                 }
2025         } else {
2026             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
2027                    o->chapters_input_file);
2028             exit_program(1);
2029         }
2030     }
2031     if (o->chapters_input_file >= 0)
2032         copy_chapters(input_files[o->chapters_input_file], of,
2033                       !o->metadata_chapters_manual);
2034
2035     /* copy global metadata by default */
2036     if (!o->metadata_global_manual && nb_input_files){
2037         av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
2038                      AV_DICT_DONT_OVERWRITE);
2039         if(o->recording_time != INT64_MAX)
2040             av_dict_set(&oc->metadata, "duration", NULL, 0);
2041         av_dict_set(&oc->metadata, "creation_time", NULL, 0);
2042     }
2043     if (!o->metadata_streams_manual)
2044         for (i = of->ost_index; i < nb_output_streams; i++) {
2045             InputStream *ist;
2046             if (output_streams[i]->source_index < 0)         /* this is true e.g. for attached files */
2047                 continue;
2048             ist = input_streams[output_streams[i]->source_index];
2049             av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
2050         }
2051
2052     /* process manually set metadata */
2053     for (i = 0; i < o->nb_metadata; i++) {
2054         AVDictionary **m;
2055         char type, *val;
2056         const char *stream_spec;
2057         int index = 0, j, ret = 0;
2058
2059         val = strchr(o->metadata[i].u.str, '=');
2060         if (!val) {
2061             av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
2062                    o->metadata[i].u.str);
2063             exit_program(1);
2064         }
2065         *val++ = 0;
2066
2067         parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
2068         if (type == 's') {
2069             for (j = 0; j < oc->nb_streams; j++) {
2070                 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2071                     av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2072                 } else if (ret < 0)
2073                     exit_program(1);
2074             }
2075         }
2076         else {
2077             switch (type) {
2078             case 'g':
2079                 m = &oc->metadata;
2080                 break;
2081             case 'c':
2082                 if (index < 0 || index >= oc->nb_chapters) {
2083                     av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2084                     exit_program(1);
2085                 }
2086                 m = &oc->chapters[index]->metadata;
2087                 break;
2088             default:
2089                 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2090                 exit_program(1);
2091             }
2092             av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2093         }
2094     }
2095
2096     return 0;
2097 }
2098
2099 static int opt_target(void *optctx, const char *opt, const char *arg)
2100 {
2101     OptionsContext *o = optctx;
2102     enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2103     static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2104
2105     if (!strncmp(arg, "pal-", 4)) {
2106         norm = PAL;
2107         arg += 4;
2108     } else if (!strncmp(arg, "ntsc-", 5)) {
2109         norm = NTSC;
2110         arg += 5;
2111     } else if (!strncmp(arg, "film-", 5)) {
2112         norm = FILM;
2113         arg += 5;
2114     } else {
2115         /* Try to determine PAL/NTSC by peeking in the input files */
2116         if (nb_input_files) {
2117             int i, j, fr;
2118             for (j = 0; j < nb_input_files; j++) {
2119                 for (i = 0; i < input_files[j]->nb_streams; i++) {
2120                     AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
2121                     if (c->codec_type != AVMEDIA_TYPE_VIDEO)
2122                         continue;
2123                     fr = c->time_base.den * 1000 / c->time_base.num;
2124                     if (fr == 25000) {
2125                         norm = PAL;
2126                         break;
2127                     } else if ((fr == 29970) || (fr == 23976)) {
2128                         norm = NTSC;
2129                         break;
2130                     }
2131                 }
2132                 if (norm != UNKNOWN)
2133                     break;
2134             }
2135         }
2136         if (norm != UNKNOWN)
2137             av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2138     }
2139
2140     if (norm == UNKNOWN) {
2141         av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2142         av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2143         av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2144         exit_program(1);
2145     }
2146
2147     if (!strcmp(arg, "vcd")) {
2148         opt_video_codec(o, "c:v", "mpeg1video");
2149         opt_audio_codec(o, "c:a", "mp2");
2150         parse_option(o, "f", "vcd", options);
2151
2152         parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2153         parse_option(o, "r", frame_rates[norm], options);
2154         av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", AV_DICT_DONT_OVERWRITE);
2155
2156         av_dict_set(&o->g->codec_opts, "b:v", "1150000", AV_DICT_DONT_OVERWRITE);
2157         av_dict_set(&o->g->codec_opts, "maxrate", "1150000", AV_DICT_DONT_OVERWRITE);
2158         av_dict_set(&o->g->codec_opts, "minrate", "1150000", AV_DICT_DONT_OVERWRITE);
2159         av_dict_set(&o->g->codec_opts, "bufsize", "327680", AV_DICT_DONT_OVERWRITE); // 40*1024*8;
2160
2161         av_dict_set(&o->g->codec_opts, "b:a", "224000", AV_DICT_DONT_OVERWRITE);
2162         parse_option(o, "ar", "44100", options);
2163         parse_option(o, "ac", "2", options);
2164
2165         av_dict_set(&o->g->format_opts, "packetsize", "2324", AV_DICT_DONT_OVERWRITE);
2166         av_dict_set(&o->g->format_opts, "muxrate", "1411200", AV_DICT_DONT_OVERWRITE); // 2352 * 75 * 8;
2167
2168         /* We have to offset the PTS, so that it is consistent with the SCR.
2169            SCR starts at 36000, but the first two packs contain only padding
2170            and the first pack from the other stream, respectively, may also have
2171            been written before.
2172            So the real data starts at SCR 36000+3*1200. */
2173         o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2174     } else if (!strcmp(arg, "svcd")) {
2175
2176         opt_video_codec(o, "c:v", "mpeg2video");
2177         opt_audio_codec(o, "c:a", "mp2");
2178         parse_option(o, "f", "svcd", options);
2179
2180         parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2181         parse_option(o, "r", frame_rates[norm], options);
2182         parse_option(o, "pix_fmt", "yuv420p", options);
2183         av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", AV_DICT_DONT_OVERWRITE);
2184
2185         av_dict_set(&o->g->codec_opts, "b:v", "2040000", AV_DICT_DONT_OVERWRITE);
2186         av_dict_set(&o->g->codec_opts, "maxrate", "2516000", AV_DICT_DONT_OVERWRITE);
2187         av_dict_set(&o->g->codec_opts, "minrate", "0", AV_DICT_DONT_OVERWRITE); // 1145000;
2188         av_dict_set(&o->g->codec_opts, "bufsize", "1835008", AV_DICT_DONT_OVERWRITE); // 224*1024*8;
2189         av_dict_set(&o->g->codec_opts, "scan_offset", "1", AV_DICT_DONT_OVERWRITE);
2190
2191         av_dict_set(&o->g->codec_opts, "b:a", "224000", AV_DICT_DONT_OVERWRITE);
2192         parse_option(o, "ar", "44100", options);
2193
2194         av_dict_set(&o->g->format_opts, "packetsize", "2324", AV_DICT_DONT_OVERWRITE);
2195
2196     } else if (!strcmp(arg, "dvd")) {
2197
2198         opt_video_codec(o, "c:v", "mpeg2video");
2199         opt_audio_codec(o, "c:a", "ac3");
2200         parse_option(o, "f", "dvd", options);
2201
2202         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2203         parse_option(o, "r", frame_rates[norm], options);
2204         parse_option(o, "pix_fmt", "yuv420p", options);
2205         av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", AV_DICT_DONT_OVERWRITE);
2206
2207         av_dict_set(&o->g->codec_opts, "b:v", "6000000", AV_DICT_DONT_OVERWRITE);
2208         av_dict_set(&o->g->codec_opts, "maxrate", "9000000", AV_DICT_DONT_OVERWRITE);
2209         av_dict_set(&o->g->codec_opts, "minrate", "0", AV_DICT_DONT_OVERWRITE); // 1500000;
2210         av_dict_set(&o->g->codec_opts, "bufsize", "1835008", AV_DICT_DONT_OVERWRITE); // 224*1024*8;
2211
2212         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.
2213         av_dict_set(&o->g->format_opts, "muxrate", "10080000", AV_DICT_DONT_OVERWRITE); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2214
2215         av_dict_set(&o->g->codec_opts, "b:a", "448000", AV_DICT_DONT_OVERWRITE);
2216         parse_option(o, "ar", "48000", options);
2217
2218     } else if (!strncmp(arg, "dv", 2)) {
2219
2220         parse_option(o, "f", "dv", options);
2221
2222         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2223         parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2224                           norm == PAL ? "yuv420p" : "yuv411p", options);
2225         parse_option(o, "r", frame_rates[norm], options);
2226
2227         parse_option(o, "ar", "48000", options);
2228         parse_option(o, "ac", "2", options);
2229
2230     } else {
2231         av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2232         return AVERROR(EINVAL);
2233     }
2234     return 0;
2235 }
2236
2237 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2238 {
2239     av_free (vstats_filename);
2240     vstats_filename = av_strdup (arg);
2241     return 0;
2242 }
2243
2244 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2245 {
2246     char filename[40];
2247     time_t today2 = time(NULL);
2248     struct tm *today = localtime(&today2);
2249
2250     snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2251              today->tm_sec);
2252     return opt_vstats_file(NULL, opt, filename);
2253 }
2254
2255 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2256 {
2257     OptionsContext *o = optctx;
2258     return parse_option(o, "frames:v", arg, options);
2259 }
2260
2261 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2262 {
2263     OptionsContext *o = optctx;
2264     return parse_option(o, "frames:a", arg, options);
2265 }
2266
2267 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2268 {
2269     OptionsContext *o = optctx;
2270     return parse_option(o, "frames:d", arg, options);
2271 }
2272
2273 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2274 {
2275     int ret;
2276     AVDictionary *cbak = codec_opts;
2277     AVDictionary *fbak = format_opts;
2278     codec_opts = NULL;
2279     format_opts = NULL;
2280
2281     ret = opt_default(NULL, opt, arg);
2282
2283     av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2284     av_dict_copy(&o->g->format_opts, format_opts, 0);
2285     av_dict_free(&codec_opts);
2286     av_dict_free(&format_opts);
2287     codec_opts = cbak;
2288     format_opts = fbak;
2289
2290     return ret;
2291 }
2292
2293 static int opt_preset(void *optctx, const char *opt, const char *arg)
2294 {
2295     OptionsContext *o = optctx;
2296     FILE *f=NULL;
2297     char filename[1000], line[1000], tmp_line[1000];
2298     const char *codec_name = NULL;
2299
2300     tmp_line[0] = *opt;
2301     tmp_line[1] = 0;
2302     MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2303
2304     if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2305         if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2306             av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2307         }else
2308             av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2309         exit_program(1);
2310     }
2311
2312     while (fgets(line, sizeof(line), f)) {
2313         char *key = tmp_line, *value, *endptr;
2314
2315         if (strcspn(line, "#\n\r") == 0)
2316             continue;
2317         av_strlcpy(tmp_line, line, sizeof(tmp_line));
2318         if (!av_strtok(key,   "=",    &value) ||
2319             !av_strtok(value, "\r\n", &endptr)) {
2320             av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2321             exit_program(1);
2322         }
2323         av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2324
2325         if      (!strcmp(key, "acodec")) opt_audio_codec   (o, key, value);
2326         else if (!strcmp(key, "vcodec")) opt_video_codec   (o, key, value);
2327         else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2328         else if (!strcmp(key, "dcodec")) opt_data_codec    (o, key, value);
2329         else if (opt_default_new(o, key, value) < 0) {
2330             av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2331                    filename, line, key, value);
2332             exit_program(1);
2333         }
2334     }
2335
2336     fclose(f);
2337
2338     return 0;
2339 }
2340
2341 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2342 {
2343     OptionsContext *o = optctx;
2344     char *s = av_asprintf("%s:%c", opt + 1, *opt);
2345     int ret = parse_option(o, s, arg, options);
2346     av_free(s);
2347     return ret;
2348 }
2349
2350 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2351 {
2352     OptionsContext *o = optctx;
2353     if(!strcmp(opt, "b")){
2354         av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2355         av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2356         return 0;
2357     }
2358     av_dict_set(&o->g->codec_opts, opt, arg, 0);
2359     return 0;
2360 }
2361
2362 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2363 {
2364     OptionsContext *o = optctx;
2365     char *s;
2366     int ret;
2367     if(!strcmp(opt, "qscale")){
2368         av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2369         return parse_option(o, "q:v", arg, options);
2370     }
2371     s = av_asprintf("q%s", opt + 6);
2372     ret = parse_option(o, s, arg, options);
2373     av_free(s);
2374     return ret;
2375 }
2376
2377 static int opt_profile(void *optctx, const char *opt, const char *arg)
2378 {
2379     OptionsContext *o = optctx;
2380     if(!strcmp(opt, "profile")){
2381         av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2382         av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
2383         return 0;
2384     }
2385     av_dict_set(&o->g->codec_opts, opt, arg, 0);
2386     return 0;
2387 }
2388
2389 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2390 {
2391     OptionsContext *o = optctx;
2392     return parse_option(o, "filter:v", arg, options);
2393 }
2394
2395 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2396 {
2397     OptionsContext *o = optctx;
2398     return parse_option(o, "filter:a", arg, options);
2399 }
2400
2401 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2402 {
2403     if      (!av_strcasecmp(arg, "cfr"))         video_sync_method = VSYNC_CFR;
2404     else if (!av_strcasecmp(arg, "vfr"))         video_sync_method = VSYNC_VFR;
2405     else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2406     else if (!av_strcasecmp(arg, "drop"))        video_sync_method = VSYNC_DROP;
2407
2408     if (video_sync_method == VSYNC_AUTO)
2409         video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
2410     return 0;
2411 }
2412
2413 static int opt_timecode(void *optctx, const char *opt, const char *arg)
2414 {
2415     OptionsContext *o = optctx;
2416     char *tcr = av_asprintf("timecode=%s", arg);
2417     int ret = parse_option(o, "metadata:g", tcr, options);
2418     if (ret >= 0)
2419         ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
2420     av_free(tcr);
2421     return 0;
2422 }
2423
2424 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2425 {
2426     OptionsContext *o = optctx;
2427     char layout_str[32];
2428     char *stream_str;
2429     char *ac_str;
2430     int ret, channels, ac_str_size;
2431     uint64_t layout;
2432
2433     layout = av_get_channel_layout(arg);
2434     if (!layout) {
2435         av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2436         return AVERROR(EINVAL);
2437     }
2438     snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2439     ret = opt_default_new(o, opt, layout_str);
2440     if (ret < 0)
2441         return ret;
2442
2443     /* set 'ac' option based on channel layout */
2444     channels = av_get_channel_layout_nb_channels(layout);
2445     snprintf(layout_str, sizeof(layout_str), "%d", channels);
2446     stream_str = strchr(opt, ':');
2447     ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2448     ac_str = av_mallocz(ac_str_size);
2449     if (!ac_str)
2450         return AVERROR(ENOMEM);
2451     av_strlcpy(ac_str, "ac", 3);
2452     if (stream_str)
2453         av_strlcat(ac_str, stream_str, ac_str_size);
2454     ret = parse_option(o, ac_str, layout_str, options);
2455     av_free(ac_str);
2456
2457     return ret;
2458 }
2459
2460 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2461 {
2462     OptionsContext *o = optctx;
2463     return parse_option(o, "q:a", arg, options);
2464 }
2465
2466 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2467 {
2468     GROW_ARRAY(filtergraphs, nb_filtergraphs);
2469     if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2470         return AVERROR(ENOMEM);
2471     filtergraphs[nb_filtergraphs - 1]->index      = nb_filtergraphs - 1;
2472     filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
2473     if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
2474         return AVERROR(ENOMEM);
2475     return 0;
2476 }
2477
2478 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
2479 {
2480     uint8_t *graph_desc = read_file(arg);
2481     if (!graph_desc)
2482         return AVERROR(EINVAL);
2483
2484     GROW_ARRAY(filtergraphs, nb_filtergraphs);
2485     if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2486         return AVERROR(ENOMEM);
2487     filtergraphs[nb_filtergraphs - 1]->index      = nb_filtergraphs - 1;
2488     filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
2489     return 0;
2490 }
2491
2492 void show_help_default(const char *opt, const char *arg)
2493 {
2494     /* per-file options have at least one of those set */
2495     const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2496     int show_advanced = 0, show_avoptions = 0;
2497
2498     if (opt && *opt) {
2499         if (!strcmp(opt, "long"))
2500             show_advanced = 1;
2501         else if (!strcmp(opt, "full"))
2502             show_advanced = show_avoptions = 1;
2503         else
2504             av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2505     }
2506
2507     show_usage();
2508
2509     printf("Getting help:\n"
2510            "    -h      -- print basic options\n"
2511            "    -h long -- print more options\n"
2512            "    -h full -- print all options (including all format and codec specific options, very long)\n"
2513            "    See man %s for detailed description of the options.\n"
2514            "\n", program_name);
2515
2516     show_help_options(options, "Print help / information / capabilities:",
2517                       OPT_EXIT, 0, 0);
2518
2519     show_help_options(options, "Global options (affect whole program "
2520                       "instead of just one file:",
2521                       0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2522     if (show_advanced)
2523         show_help_options(options, "Advanced global options:", OPT_EXPERT,
2524                           per_file | OPT_EXIT, 0);
2525
2526     show_help_options(options, "Per-file main options:", 0,
2527                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
2528                       OPT_EXIT, per_file);
2529     if (show_advanced)
2530         show_help_options(options, "Advanced per-file options:",
2531                           OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2532
2533     show_help_options(options, "Video options:",
2534                       OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
2535     if (show_advanced)
2536         show_help_options(options, "Advanced Video options:",
2537                           OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2538
2539     show_help_options(options, "Audio options:",
2540                       OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2541     if (show_advanced)
2542         show_help_options(options, "Advanced Audio options:",
2543                           OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2544     show_help_options(options, "Subtitle options:",
2545                       OPT_SUBTITLE, 0, 0);
2546     printf("\n");
2547
2548     if (show_avoptions) {
2549         int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2550         show_help_children(avcodec_get_class(), flags);
2551         show_help_children(avformat_get_class(), flags);
2552 #if CONFIG_SWSCALE
2553         show_help_children(sws_get_class(), flags);
2554 #endif
2555         show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
2556         show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM);
2557     }
2558 }
2559
2560 void show_usage(void)
2561 {
2562     av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
2563     av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2564     av_log(NULL, AV_LOG_INFO, "\n");
2565 }
2566
2567 enum OptGroup {
2568     GROUP_OUTFILE,
2569     GROUP_INFILE,
2570 };
2571
2572 static const OptionGroupDef groups[] = {
2573     [GROUP_OUTFILE] = { "output file",  NULL, OPT_OUTPUT },
2574     [GROUP_INFILE]  = { "input file",   "i",  OPT_INPUT },
2575 };
2576
2577 static int open_files(OptionGroupList *l, const char *inout,
2578                       int (*open_file)(OptionsContext*, const char*))
2579 {
2580     int i, ret;
2581
2582     for (i = 0; i < l->nb_groups; i++) {
2583         OptionGroup *g = &l->groups[i];
2584         OptionsContext o;
2585
2586         init_options(&o);
2587         o.g = g;
2588
2589         ret = parse_optgroup(&o, g);
2590         if (ret < 0) {
2591             av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
2592                    "%s.\n", inout, g->arg);
2593             return ret;
2594         }
2595
2596         av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
2597         ret = open_file(&o, g->arg);
2598         uninit_options(&o);
2599         if (ret < 0) {
2600             av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
2601                    inout, g->arg);
2602             return ret;
2603         }
2604         av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
2605     }
2606
2607     return 0;
2608 }
2609
2610 int ffmpeg_parse_options(int argc, char **argv)
2611 {
2612     OptionParseContext octx;
2613     uint8_t error[128];
2614     int ret;
2615
2616     memset(&octx, 0, sizeof(octx));
2617
2618     /* split the commandline into an internal representation */
2619     ret = split_commandline(&octx, argc, argv, options, groups,
2620                             FF_ARRAY_ELEMS(groups));
2621     if (ret < 0) {
2622         av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
2623         goto fail;
2624     }
2625
2626     /* apply global options */
2627     ret = parse_optgroup(NULL, &octx.global_opts);
2628     if (ret < 0) {
2629         av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
2630         goto fail;
2631     }
2632
2633     /* open input files */
2634     ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
2635     if (ret < 0) {
2636         av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
2637         goto fail;
2638     }
2639
2640     /* open output files */
2641     ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
2642     if (ret < 0) {
2643         av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
2644         goto fail;
2645     }
2646
2647 fail:
2648     uninit_parse_context(&octx);
2649     if (ret < 0) {
2650         av_strerror(ret, error, sizeof(error));
2651         av_log(NULL, AV_LOG_FATAL, "%s\n", error);
2652     }
2653     return ret;
2654 }
2655
2656 static int opt_progress(void *optctx, const char *opt, const char *arg)
2657 {
2658     AVIOContext *avio = NULL;
2659     int ret;
2660
2661     if (!strcmp(arg, "-"))
2662         arg = "pipe:";
2663     ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
2664     if (ret < 0) {
2665         av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
2666                arg, av_err2str(ret));
2667         return ret;
2668     }
2669     progress_avio = avio;
2670     return 0;
2671 }
2672
2673 #define OFFSET(x) offsetof(OptionsContext, x)
2674 const OptionDef options[] = {
2675     /* main options */
2676 #include "cmdutils_common_opts.h"
2677     { "f",              HAS_ARG | OPT_STRING | OPT_OFFSET |
2678                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(format) },
2679         "force format", "fmt" },
2680     { "y",              OPT_BOOL,                                    {              &file_overwrite },
2681         "overwrite output files" },
2682     { "n",              OPT_BOOL,                                    {              &no_file_overwrite },
2683         "never overwrite output files" },
2684     { "c",              HAS_ARG | OPT_STRING | OPT_SPEC |
2685                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(codec_names) },
2686         "codec name", "codec" },
2687     { "codec",          HAS_ARG | OPT_STRING | OPT_SPEC |
2688                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(codec_names) },
2689         "codec name", "codec" },
2690     { "pre",            HAS_ARG | OPT_STRING | OPT_SPEC |
2691                         OPT_OUTPUT,                                  { .off       = OFFSET(presets) },
2692         "preset name", "preset" },
2693     { "map",            HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2694                         OPT_OUTPUT,                                  { .func_arg = opt_map },
2695         "set input stream mapping",
2696         "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
2697     { "map_channel",    HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
2698         "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
2699     { "map_metadata",   HAS_ARG | OPT_STRING | OPT_SPEC |
2700                         OPT_OUTPUT,                                  { .off       = OFFSET(metadata_map) },
2701         "set metadata information of outfile from infile",
2702         "outfile[,metadata]:infile[,metadata]" },
2703     { "map_chapters",   HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
2704                         OPT_OUTPUT,                                  { .off = OFFSET(chapters_input_file) },
2705         "set chapters mapping", "input_file_index" },
2706     { "t",              HAS_ARG | OPT_TIME | OPT_OFFSET |
2707                         OPT_INPUT | OPT_OUTPUT,                      { .off = OFFSET(recording_time) },
2708         "record or transcode \"duration\" seconds of audio/video",
2709         "duration" },
2710     { "to",             HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_OUTPUT,  { .off = OFFSET(stop_time) },
2711         "record or transcode stop time", "time_stop" },
2712     { "fs",             HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
2713         "set the limit file size in bytes", "limit_size" },
2714     { "ss",             HAS_ARG | OPT_TIME | OPT_OFFSET |
2715                         OPT_INPUT | OPT_OUTPUT,                      { .off = OFFSET(start_time) },
2716         "set the start time offset", "time_off" },
2717     { "accurate_seek",  OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
2718                         OPT_INPUT,                                   { .off = OFFSET(accurate_seek) },
2719         "enable/disable accurate seeking with -ss" },
2720     { "itsoffset",      HAS_ARG | OPT_TIME | OPT_OFFSET |
2721                         OPT_EXPERT | OPT_INPUT,                      { .off = OFFSET(input_ts_offset) },
2722         "set the input ts offset", "time_off" },
2723     { "itsscale",       HAS_ARG | OPT_DOUBLE | OPT_SPEC |
2724                         OPT_EXPERT | OPT_INPUT,                      { .off = OFFSET(ts_scale) },
2725         "set the input ts scale", "scale" },
2726     { "timestamp",      HAS_ARG | OPT_PERFILE,                       { .func_arg = opt_recording_timestamp },
2727         "set the recording timestamp ('now' to set the current time)", "time" },
2728     { "metadata",       HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
2729         "add metadata", "string=string" },
2730     { "dframes",        HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2731                         OPT_OUTPUT,                                  { .func_arg = opt_data_frames },
2732         "set the number of data frames to record", "number" },
2733     { "benchmark",      OPT_BOOL | OPT_EXPERT,                       { &do_benchmark },
2734         "add timings for benchmarking" },
2735     { "benchmark_all",  OPT_BOOL | OPT_EXPERT,                       { &do_benchmark_all },
2736       "add timings for each task" },
2737     { "progress",       HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_progress },
2738       "write program-readable progress information", "url" },
2739     { "stdin",          OPT_BOOL | OPT_EXPERT,                       { &stdin_interaction },
2740       "enable or disable interaction on standard input" },
2741     { "timelimit",      HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_timelimit },
2742         "set max runtime in seconds", "limit" },
2743     { "dump",           OPT_BOOL | OPT_EXPERT,                       { &do_pkt_dump },
2744         "dump each input packet" },
2745     { "hex",            OPT_BOOL | OPT_EXPERT,                       { &do_hex_dump },
2746         "when dumping packets, also dump the payload" },
2747     { "re",             OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2748                         OPT_INPUT,                                   { .off = OFFSET(rate_emu) },
2749         "read input at native frame rate", "" },
2750     { "target",         HAS_ARG | OPT_PERFILE | OPT_OUTPUT,          { .func_arg = opt_target },
2751         "specify target file type (\"vcd\", \"svcd\", \"dvd\","
2752         " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2753     { "vsync",          HAS_ARG | OPT_EXPERT,                        { opt_vsync },
2754         "video sync method", "" },
2755     { "async",          HAS_ARG | OPT_INT | OPT_EXPERT,              { &audio_sync_method },
2756         "audio sync method", "" },
2757     { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,          { &audio_drift_threshold },
2758         "audio drift threshold", "threshold" },
2759     { "copyts",         OPT_BOOL | OPT_EXPERT,                       { &copy_ts },
2760         "copy timestamps" },
2761     { "copytb",         HAS_ARG | OPT_INT | OPT_EXPERT,              { &copy_tb },
2762         "copy input stream time base when stream copying", "mode" },
2763     { "shortest",       OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2764                         OPT_OUTPUT,                                  { .off = OFFSET(shortest) },
2765         "finish encoding within shortest input" },
2766     { "apad",           OPT_STRING | HAS_ARG | OPT_SPEC |
2767                         OPT_OUTPUT,                                  { .off = OFFSET(apad) },
2768         "audio pad", "" },
2769     { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,       { &dts_delta_threshold },
2770         "timestamp discontinuity delta threshold", "threshold" },
2771     { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,       { &dts_error_threshold },
2772         "timestamp error delta threshold", "threshold" },
2773     { "xerror",         OPT_BOOL | OPT_EXPERT,                       { &exit_on_error },
2774         "exit on error", "error" },
2775     { "copyinkf",       OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2776                         OPT_OUTPUT,                                  { .off = OFFSET(copy_initial_nonkeyframes) },
2777         "copy initial non-keyframes" },
2778     { "copypriorss",    OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT,   { .off = OFFSET(copy_prior_start) },
2779         "copy or discard frames before start time" },
2780     { "frames",         OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
2781         "set the number of frames to record", "number" },
2782     { "tag",            OPT_STRING | HAS_ARG | OPT_SPEC |
2783                         OPT_EXPERT | OPT_OUTPUT,                     { .off = OFFSET(codec_tags) },
2784         "force codec tag/fourcc", "fourcc/tag" },
2785     { "q",              HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
2786                         OPT_SPEC | OPT_OUTPUT,                       { .off = OFFSET(qscale) },
2787         "use fixed quality scale (VBR)", "q" },
2788     { "qscale",         HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2789                         OPT_OUTPUT,                                  { .func_arg = opt_qscale },
2790         "use fixed quality scale (VBR)", "q" },
2791     { "profile",        HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
2792         "set profile", "profile" },
2793     { "filter",         HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
2794         "set stream filtergraph", "filter_graph" },
2795     { "filter_script",  HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
2796         "read stream filtergraph description from a file", "filename" },
2797     { "reinit_filter",  HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT,    { .off = OFFSET(reinit_filters) },
2798         "reinit filtergraph on input parameter changes", "" },
2799     { "filter_complex", HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_filter_complex },
2800         "create a complex filtergraph", "graph_description" },
2801     { "lavfi",          HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_filter_complex },
2802         "create a complex filtergraph", "graph_description" },
2803     { "filter_complex_script", HAS_ARG | OPT_EXPERT,                 { .func_arg = opt_filter_complex_script },
2804         "read complex filtergraph description from a file", "filename" },
2805     { "stats",          OPT_BOOL,                                    { &print_stats },
2806         "print progress report during encoding", },
2807     { "attach",         HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2808                         OPT_OUTPUT,                                  { .func_arg = opt_attach },
2809         "add an attachment to the output file", "filename" },
2810     { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
2811                          OPT_EXPERT | OPT_INPUT,                     { .off = OFFSET(dump_attachment) },
2812         "extract an attachment into a file", "filename" },
2813     { "debug_ts",       OPT_BOOL | OPT_EXPERT,                       { &debug_ts },
2814         "print timestamp debugging info" },
2815     { "max_error_rate",  HAS_ARG | OPT_FLOAT,                        { &max_error_rate },
2816         "maximum error rate", "ratio of errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success." },
2817
2818     /* video options */
2819     { "vframes",      OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_video_frames },
2820         "set the number of video frames to record", "number" },
2821     { "r",            OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC |
2822                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_rates) },
2823         "set frame rate (Hz value, fraction or abbreviation)", "rate" },
2824     { "s",            OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC |
2825                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_sizes) },
2826         "set frame size (WxH or abbreviation)", "size" },
2827     { "aspect",       OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC |
2828                       OPT_OUTPUT,                                                { .off = OFFSET(frame_aspect_ratios) },
2829         "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
2830     { "pix_fmt",      OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
2831                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_pix_fmts) },
2832         "set pixel format", "format" },
2833     { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG,                      { &frame_bits_per_raw_sample },
2834         "set the number of bits per raw sample", "number" },
2835     { "intra",        OPT_VIDEO | OPT_BOOL | OPT_EXPERT,                         { &intra_only },
2836         "deprecated use -g 1" },
2837     { "vn",           OPT_VIDEO | OPT_BOOL  | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) },
2838         "disable video" },
2839     { "vdt",          OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT ,               { &video_discard },
2840         "discard threshold", "n" },
2841     { "rc_override",  OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
2842                       OPT_OUTPUT,                                                { .off = OFFSET(rc_overrides) },
2843         "rate control override for specific intervals", "override" },
2844     { "vcodec",       OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_INPUT |
2845                       OPT_OUTPUT,                                                { .func_arg = opt_video_codec },
2846         "force video codec ('copy' to copy stream)", "codec" },
2847     { "sameq",        OPT_VIDEO | OPT_EXPERT ,                                   { .func_arg = opt_sameq },
2848         "Removed" },
2849     { "same_quant",   OPT_VIDEO | OPT_EXPERT ,                                   { .func_arg = opt_sameq },
2850         "Removed" },
2851     { "timecode",     OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT,            { .func_arg = opt_timecode },
2852         "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
2853     { "pass",         OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT,     { .off = OFFSET(pass) },
2854         "select the pass number (1 to 3)", "n" },
2855     { "passlogfile",  OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
2856                       OPT_OUTPUT,                                                { .off = OFFSET(passlogfiles) },
2857         "select two pass log file name prefix", "prefix" },
2858     { "deinterlace",  OPT_VIDEO | OPT_BOOL | OPT_EXPERT,                         { &do_deinterlace },
2859         "this option is deprecated, use the yadif filter instead" },
2860     { "psnr",         OPT_VIDEO | OPT_BOOL | OPT_EXPERT,                         { &do_psnr },
2861         "calculate PSNR of compressed frames" },
2862     { "vstats",       OPT_VIDEO | OPT_EXPERT ,                                   { &opt_vstats },
2863         "dump video coding statistics to file" },
2864     { "vstats_file",  OPT_VIDEO | HAS_ARG | OPT_EXPERT ,                         { opt_vstats_file },
2865         "dump video coding statistics to file", "file" },
2866     { "vf",           OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_video_filters },
2867         "set video filters", "filter_graph" },
2868     { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
2869                       OPT_OUTPUT,                                                { .off = OFFSET(intra_matrices) },
2870         "specify intra matrix coeffs", "matrix" },
2871     { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
2872                       OPT_OUTPUT,                                                { .off = OFFSET(inter_matrices) },
2873         "specify inter matrix coeffs", "matrix" },
2874     { "chroma_intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
2875                       OPT_OUTPUT,                                                { .off = OFFSET(chroma_intra_matrices) },
2876         "specify intra matrix coeffs", "matrix" },
2877     { "top",          OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_INT| OPT_SPEC |
2878                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(top_field_first) },
2879         "top=1/bottom=0/auto=-1 field first", "" },
2880     { "dc",           OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT ,               { &intra_dc_precision },
2881         "intra_dc_precision", "precision" },
2882     { "vtag",         OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_PERFILE |
2883                       OPT_OUTPUT,                                                { .func_arg = opt_old2new },
2884         "force video tag/fourcc", "fourcc/tag" },
2885     { "qphist",       OPT_VIDEO | OPT_BOOL | OPT_EXPERT ,                        { &qp_hist },
2886         "show QP histogram" },
2887     { "force_fps",    OPT_VIDEO | OPT_BOOL | OPT_EXPERT  | OPT_SPEC |
2888                       OPT_OUTPUT,                                                { .off = OFFSET(force_fps) },
2889         "force the selected framerate, disable the best supported framerate selection" },
2890     { "streamid",     OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2891                       OPT_OUTPUT,                                                { .func_arg = opt_streamid },
2892         "set the value of an outfile streamid", "streamIndex:value" },
2893     { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2894                           OPT_SPEC | OPT_OUTPUT,                                 { .off = OFFSET(forced_key_frames) },
2895         "force key frames at specified timestamps", "timestamps" },
2896     { "b",            OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT,            { .func_arg = opt_bitrate },
2897         "video bitrate (please use -b:v)", "bitrate" },
2898     { "hwaccel",          OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2899                           OPT_SPEC | OPT_INPUT,                                  { .off = OFFSET(hwaccels) },
2900         "use HW accelerated decoding", "hwaccel name" },
2901     { "hwaccel_device",   OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2902                           OPT_SPEC | OPT_INPUT,                                  { .off = OFFSET(hwaccel_devices) },
2903         "select a device for HW acceleration" "devicename" },
2904
2905     /* audio options */
2906     { "aframes",        OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_frames },
2907         "set the number of audio frames to record", "number" },
2908     { "aq",             OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_qscale },
2909         "set audio quality (codec-specific)", "quality", },
2910     { "ar",             OPT_AUDIO | HAS_ARG  | OPT_INT | OPT_SPEC |
2911                         OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(audio_sample_rate) },
2912         "set audio sampling rate (in Hz)", "rate" },
2913     { "ac",             OPT_AUDIO | HAS_ARG  | OPT_INT | OPT_SPEC |
2914                         OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(audio_channels) },
2915         "set number of audio channels", "channels" },
2916     { "an",             OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) },
2917         "disable audio" },
2918     { "acodec",         OPT_AUDIO | HAS_ARG  | OPT_PERFILE |
2919                         OPT_INPUT | OPT_OUTPUT,                                    { .func_arg = opt_audio_codec },
2920         "force audio codec ('copy' to copy stream)", "codec" },
2921     { "atag",           OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_PERFILE |
2922                         OPT_OUTPUT,                                                { .func_arg = opt_old2new },
2923         "force audio tag/fourcc", "fourcc/tag" },
2924     { "vol",            OPT_AUDIO | HAS_ARG  | OPT_INT,                            { &audio_volume },
2925         "change audio volume (256=normal)" , "volume" },
2926     { "sample_fmt",     OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_SPEC |
2927                         OPT_STRING | OPT_INPUT | OPT_OUTPUT,                       { .off = OFFSET(sample_fmts) },
2928         "set sample format", "format" },
2929     { "channel_layout", OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_PERFILE |
2930                         OPT_INPUT | OPT_OUTPUT,                                    { .func_arg = opt_channel_layout },
2931         "set channel layout", "layout" },
2932     { "af",             OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_filters },
2933         "set audio filters", "filter_graph" },
2934     { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
2935       "set the maximum number of channels to try to guess the channel layout" },
2936
2937     /* subtitle options */
2938     { "sn",     OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
2939         "disable subtitle" },
2940     { "scodec", OPT_SUBTITLE | HAS_ARG  | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
2941         "force subtitle codec ('copy' to copy stream)", "codec" },
2942     { "stag",   OPT_SUBTITLE | HAS_ARG  | OPT_EXPERT  | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
2943         , "force subtitle tag/fourcc", "fourcc/tag" },
2944     { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
2945         "fix subtitles duration" },
2946     { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
2947         "set canvas size (WxH or abbreviation)", "size" },
2948
2949     /* grab options */
2950     { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
2951         "deprecated, use -channel", "channel" },
2952     { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
2953         "deprecated, use -standard", "standard" },
2954     { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
2955
2956     /* muxer options */
2957     { "muxdelay",   OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
2958         "set the maximum demux-decode delay", "seconds" },
2959     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
2960         "set the initial demux-decode delay", "seconds" },
2961     { "override_ffserver", OPT_BOOL | OPT_EXPERT | OPT_OUTPUT, { &override_ffserver },
2962         "override the options from ffserver", "" },
2963
2964     { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
2965         "A comma-separated list of bitstream filters", "bitstream_filters" },
2966     { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
2967         "deprecated", "audio bitstream_filters" },
2968     { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
2969         "deprecated", "video bitstream_filters" },
2970
2971     { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT,    { .func_arg = opt_preset },
2972         "set the audio options to the indicated preset", "preset" },
2973     { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT,    { .func_arg = opt_preset },
2974         "set the video options to the indicated preset", "preset" },
2975     { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
2976         "set the subtitle options to the indicated preset", "preset" },
2977     { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT,                { .func_arg = opt_preset },
2978         "set options from indicated preset file", "filename" },
2979     /* data codec support */
2980     { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
2981         "force data codec ('copy' to copy stream)", "codec" },
2982     { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },
2983         "disable data" },
2984
2985     { NULL, },
2986 };