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